/*
    *  Copyright 2013 Chris Pheby
    *
    *  Licensed under the Apache License, Version 2.0 (the "License");
    *  you may not use this file except in compliance with the License.
    *  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
   *  Unless required by applicable law or agreed to in writing, software
   *  distributed under the License is distributed on an "AS IS" BASIS,
   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *  See the License for the specific language governing permissions and
   *  limitations under the License.
   */
  package org.jadira.scanner;
  
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  
  import org.jadira.scanner.classpath.filter.NameFilter;
  import org.jadira.scanner.core.api.Filter;
  import org.jadira.scanner.core.api.Locator;
  import org.jadira.scanner.core.exception.ClasspathAccessException;
  import org.jadira.scanner.core.utils.reflection.ClassLoaderUtils;
  
  public class ConfigurationBuilder implements Configuration {
      
      private List<URL> urls = new ArrayList<URL>();
      
      private List<Locator<URL>> locators = new ArrayList<Locator<URL>>();
  
      private List<ClassLoader> classLoaders = new ArrayList<ClassLoader>();
      
      private List<Filter<?>> filters = new ArrayList<Filter<?>>();
  
      public ConfigurationBuilder() {
          ClassLoader[] cls = ClassLoaderUtils.getClassLoaders();
          for (ClassLoader next : cls) {
              classLoaders.add(next);
          }
      }
  
      public static ConfigurationBuilder build(final Object... params) {
          
          ConfigurationBuilder builder = new ConfigurationBuilder();
          List<Object> paramsList = flattenParams(params);
  
          List<ClassLoader> cLoaders = new ArrayList<ClassLoader>();
          
          for (Object param : paramsList) {
              if (param instanceof ClassLoader) {
                  cLoaders.add((ClassLoader) param);
              } else if (param instanceof URL) {
                  builder.addUrls((URL) param);
              } else if (param instanceof Locator) {
                  @SuppressWarnings("unchecked") final Locator<URL>[] myParams = new Locator[] {(Locator<URL>)param};
                  builder.addLocators(myParams);
              } else if (param instanceof Filter) {
                  builder.addFilters((Filter<?>) param);
              } else if (param instanceof String) {
                  builder.addFilters(new NameFilter((String)param));
              } else {
                  throw new ClasspathAccessException("Could not handle builder parameter " + param.toString());
              }
              
          }
  
          builder.setClassLoaders(cLoaders);        
          return builder;
      }
  
      private static List<Object> flattenParams(final Object... params) {
          List<Object> paramsList = new ArrayList<Object>(params.length);
          if (params != null) {
              for (Object param : params) {
                  if (param != null) {
                      if (param.getClass().isArray()) {
                          for (Object nextEntry : (Object[]) param) {
                              if (nextEntry != null) {
                                  paramsList.add(nextEntry); 
                              }
                          }
                      }
                      else if (param instanceof Iterable) {
                          for (Object nextEntry : (Iterable<?>) param) {
                              if (nextEntry != null) {
                                  paramsList.add(nextEntry); }
                              }
                          }
                      else {
                          paramsList.add(param);
                      }
                  }
              }
          }
          return paramsList;
     }
 
     public Scanner build() {
         return new Scanner(this);
     }
     
     @Override
     public List<URL> getUrls() {
         return urls;
     }
 
     ConfigurationBuilder setUrls(final Collection<URL> urls) {
         this.urls = new ArrayList<URL>(urls);
         return this;
     }
 
     ConfigurationBuilder setUrls(final URL... urls) {
         this.urls = new ArrayList<URL>(urls.length);
         for(URL next : urls) {
             this.urls.add(next);
         }
         return this;
     }
     
     ConfigurationBuilder addUrls(final Collection<URL> urls) {
         this.urls.addAll(urls);
         return this;
     }
     
     ConfigurationBuilder addUrls(final URL... urls) {
         for(URL next : urls) {
             this.urls.add(next);
         }
         return this;
     }
     
     @Override
     public List<Locator<URL>> getLocators() {
         return locators;
     }
 
     ConfigurationBuilder setLocators(final Collection<Locator<URL>> locators) {
         this.locators = new ArrayList<Locator<URL>>(locators);
         return this;
     }
 
     @SafeVarargs 
     final ConfigurationBuilder setLocators(final Locator<URL>... locators) {
         this.locators = new ArrayList<Locator<URL>>(locators.length);
         for (Locator<URL> next : locators) {
             this.locators.add(next);
         }
         return this;
     }
         
     ConfigurationBuilder addLocators(final Collection<Locator<URL>> locators) {
         this.locators.addAll(locators);
         return this;
     }
     
     @SafeVarargs
     final ConfigurationBuilder addLocators(final Locator<URL>... locators) {
         for (Locator<URL> next : locators) {
             this.locators.add(next);
         }
         return this;
     }
     
     @Override
     public List<ClassLoader> getClassLoaders() {
         return classLoaders;
     }
 
     ConfigurationBuilder setClassLoaders(final Collection<ClassLoader> classLoaders) {
         this.classLoaders = new ArrayList<ClassLoader>(classLoaders);
         return this;
     }
 
     ConfigurationBuilder setClassLoaders(final ClassLoader... classLoaders) {
         this.classLoaders = new ArrayList<ClassLoader>(classLoaders.length);
         for (ClassLoader next : classLoaders) {
             this.classLoaders.add(next);
         }
         return this;
     }
     
     ConfigurationBuilder addClassLoaders(final Collection<ClassLoader> classLoaders) {
         this.classLoaders.addAll(classLoaders);
         return this;
     }
 
     ConfigurationBuilder addClassLoaders(final ClassLoader... classLoaders) {
         for (ClassLoader next : classLoaders) {
             this.classLoaders.add(next);
         }
         return this;
     }
     
     @Override
     public List<Filter<?>> getFilters() {
         return filters;
     }
 
     ConfigurationBuilder setFilters(final List<Filter<?>> filters) {
         this.filters = new ArrayList<Filter<?>>(filters);
         return this;
     }
 
     ConfigurationBuilder setFilters(final Filter<?>... filters) {
         this.filters = new ArrayList<Filter<?>>(filters.length);
         for (Filter<?> next : filters) {
             this.filters.add(next);
         }
         return this;
     }
     
     ConfigurationBuilder addFilters(final List<Filter<?>> filters) {
         this.filters.addAll(filters);
         return this;
     }
     
     ConfigurationBuilder addFilters(final Filter<?>... filters) {
         for (Filter<?> next : filters) {
             this.filters.add(next);
         }
         return this;
     }
 }