package org.apache.onami.autobind.configuration;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You 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.
   */
  
  import static com.google.inject.TypeLiteral.get;
  import static java.lang.System.getProperty;
  import static java.util.Collections.addAll;
  import static java.util.logging.Level.FINE;
  import static java.util.logging.Level.INFO;
  import static java.util.logging.Logger.getLogger;
  import static org.apache.onami.autobind.jsr330.Names.named;
  
  import java.io.File;
  import java.net.MalformedURLException;
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.net.URL;
  import java.net.URLClassLoader;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  import java.util.logging.Logger;
  
  import org.apache.onami.autobind.annotations.features.AutoBindingFeature;
  import org.apache.onami.autobind.annotations.features.ImplementationBindingFeature;
  import org.apache.onami.autobind.annotations.features.ModuleBindingFeature;
  import org.apache.onami.autobind.annotations.features.MultiBindingFeature;
  import org.apache.onami.autobind.install.BindingTracer;
  import org.apache.onami.autobind.install.InstallationContext;
  import org.apache.onami.autobind.install.bindjob.BindingJob;
  import org.apache.onami.autobind.scanner.ClasspathScanner;
  import org.apache.onami.autobind.scanner.PackageFilter;
  import org.apache.onami.autobind.scanner.ScannerModule;
  import org.apache.onami.autobind.scanner.features.ScannerFeature;
  import org.apache.onami.configuration.PropertiesURLReader;
  
  import com.google.inject.AbstractModule;
  import com.google.inject.Binder;
  import com.google.inject.Guice;
  import com.google.inject.Injector;
  import com.google.inject.Module;
  import com.google.inject.multibindings.Multibinder;
  
  /**
   * The StartupModule is used for creating an initial Injector, which binds and
   * instantiates the Scanning module. Due the fact that we have multiple Scanner
   * Implementations, you have to pass the Class for the Scanner and the Packages
   * which should be scanned. You can override the bindAnnotationListeners-Method,
   * to add your own {@link ScannerFeature}.
   */
  public abstract class StartupModule extends AbstractModule {
  
  	protected final Logger _logger = getLogger(getClass().getName());
  
  	protected PackageFilter[] _packages;
  
  	protected Class<? extends ClasspathScanner> _scanner;
  
  	protected List<Class<? extends ScannerFeature>> _features = new ArrayList<Class<? extends ScannerFeature>>();
  
  	protected boolean bindSystemProperties;
  
  	protected boolean bindEnvironment;
  
  	protected boolean bindStartupConfiguration = true;
  
  	protected boolean verbose = (getProperty("org.apache.onami.autobind.verbose") != null ? true
  			: false);
  
  	public StartupModule(Class<? extends ClasspathScanner> scanner,
  			PackageFilter... filter) {
  		_packages = (filter == null ? new PackageFilter[0] : filter);
  		_scanner = scanner;
  	}
  
  	@Override
  	public void configure() {
  		List<PackageFilter> packages = new ArrayList<PackageFilter>();
  		addAll(packages, _packages);
  		addAll(packages, bindPackages());
  
  		_packages = packages.toArray(new PackageFilter[packages.size()]);
 		Module scannerModule = new AbstractModule() {
 			@Override
 			protected void configure() {
 				Binder binder = binder();
 				if (_logger.isLoggable(FINE)) {
 					_logger.fine("Binding ClasspathScanner to "
 							+ _scanner.getName());
 					for (PackageFilter p : _packages) {
 						_logger.fine("Using Package " + p + " for scanning.");
 					}
 				}
 
 				binder.bind(InstallationContext.class).asEagerSingleton();
 				binder.bind(ClasspathScanner.class).to(_scanner);
 				binder.bind(get(PackageFilter[].class))
 						.annotatedWith(named("packages")).toInstance(_packages);
 				Set<URL> classpath = findClassPaths();
 				binder.bind(get(URL[].class))
 						.annotatedWith(named("classpath"))
 						.toInstance(
 								classpath.toArray(new URL[classpath.size()]));
 
 				bindFeatures(binder);
 			}
 		};
 
 		ConfigurationModule configurationModule = new ConfigurationModule();
 		if (bindSystemProperties) {
 			configurationModule.bindSystemProperties();
 		}
 		if (bindEnvironment) {
 			configurationModule.bindEnvironmentVariables();
 		}
 
 		if (bindStartupConfiguration) {
 			URL startup = getClass().getResource("/conf/startup.xml");
 			if (startup != null) {
 				try {
 					URI startupURI = startup.toURI();
 					_logger.log(INFO, "Startup Config is used from Path: "
 							+ startupURI);
 					PropertiesURLReader reader = new PropertiesURLReader(
 							startup);
 					reader.inXMLFormat();
 					configurationModule.addConfigurationReader(reader);
 				} catch (URISyntaxException e) {
 					_logger.log(INFO,
 							"Startup Config couldn't be found in Classpath.", e);
 				}
 			} else {
 				_logger.log(INFO,
 						"Startup Config couldn't be found, so it is not used.");
 			}
 		}
 
 		Injector internal = Guice.createInjector(scannerModule,
 				configurationModule);
 		binder().install(internal.getInstance(ScannerModule.class));
 		binder().install(configurationModule);
 
 		if (verbose) {
 			BindingTracer tracer = internal.getInstance(BindingTracer.class);
 
 			StringBuilder builder = new StringBuilder(
 					"Following Binding were processed.\n");
 			for (BindingJob job : tracer) {
 				builder.append(job.toString()).append("\n");
 			}
 			_logger.info(builder.toString());
 		}
 	}
 
 	protected abstract Multibinder<ScannerFeature> bindFeatures(Binder binder);
 
 	protected PackageFilter[] bindPackages() {
 		return new PackageFilter[0];
 	}
 
 	protected Set<URL> findClassPaths() {
 		Set<URL> urlSet = new HashSet<URL>();
 
 		ClassLoader loader = Thread.currentThread().getContextClassLoader();
 		while (loader != null) {
 			if (loader instanceof URLClassLoader) {
 				URL[] urls = ((URLClassLoader) loader).getURLs();
 				Collections.addAll(urlSet, urls);
 			}
 			loader = loader.getParent();
 		}
 
 		String classpath = System.getProperty("java.class.path");
 		if (classpath != null && classpath.length() > 0) {
 			try {
 				URL resource = StartupModule.class.getResource("/");
 
 				if (resource == null) {
 					String className = StartupModule.class.getName().replace(
 							'.', '/')
 							+ ".class";
 					resource = StartupModule.class.getResource(className);
 
 					if (resource != null) {
 						String url = resource.toExternalForm();
 						url = url.substring(0,
 								url.length() - className.length());
 						resource = new URL(url);
 					}
 				}
 
 				if (resource != null) {
 					classpath = classpath + File.pathSeparator
 							+ new File(resource.toURI()).getAbsolutePath();
 				}
 			} catch (URISyntaxException e) {
 				// FIXME ignore for now
 			} catch (MalformedURLException e) {
 				// FIXME ignore for now
 			}
 
 			for (String path : classpath.split(File.pathSeparator)) {
 				File file = new File(path);
 				try {
 					if (file.exists()) {
 						urlSet.add(file.toURI().toURL());
 					}
 				} catch (MalformedURLException e) {
 					_logger.log(INFO,
 							"Found invalid URL in Classpath: " + path, e);
 				}
 			}
 		}
 
 		return urlSet;
 	}
 
 	public StartupModule addFeature(Class<? extends ScannerFeature> listener) {
 		_features.add(listener);
 		return this;
 	}
 
 	public StartupModule bindSystemProperties() {
 		bindSystemProperties = true;
 		return this;
 	}
 
 	public StartupModule disableStartupConfiguration() {
 		bindStartupConfiguration = false;
 		return this;
 	}
 
 	public StartupModule bindEnvironment() {
 		bindEnvironment = true;
 		return this;
 	}
 
 	public void verbose() {
 		verbose = true;
 	}
 
 	public static StartupModule create(
 			Class<? extends ClasspathScanner> scanner, PackageFilter... filter) {
 		return new DefaultStartupModule(scanner, filter);
 	}
 
 	public static class DefaultStartupModule extends StartupModule {
 		public DefaultStartupModule(Class<? extends ClasspathScanner> scanner,
 				PackageFilter... filter) {
 			super(scanner, filter);
 		}
 
 		@Override
 		protected Multibinder<ScannerFeature> bindFeatures(Binder binder) {
 			Multibinder<ScannerFeature> listeners = Multibinder.newSetBinder(
 					binder, ScannerFeature.class);
 			listeners.addBinding().to(AutoBindingFeature.class);
 			listeners.addBinding().to(ImplementationBindingFeature.class);
 			listeners.addBinding().to(MultiBindingFeature.class);
 			listeners.addBinding().to(ModuleBindingFeature.class);
 
 			for (Class<? extends ScannerFeature> listener : _features) {
 				listeners.addBinding().to(listener);
 			}
 
 			return listeners;
 		}
 
 		@Override
 		protected PackageFilter[] bindPackages() {
 			try {
 				return new PackageFilter[] { PackageFilter
 						.create(Thread
 								.currentThread()
 								.getContextClassLoader()
 								.loadClass(
 										"org.apache.onami.autobind.configuration.ConfigurationModule"),
 								false) };
 			} catch (ClassNotFoundException e) {
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 				return new PackageFilter[0];
 			}
 		}
 	}
 
 }