package liquibase.servicelocator;

 import java.io.IOException;

 import java.io.InputStream;

 import java.lang.reflect.Modifier;

 import java.net.URL;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.jar.Manifest;

 import liquibase.exception.ServiceNotFoundException;

 import liquibase.exception.UnexpectedLiquibaseException;

 import liquibase.logging.Logger;

 import liquibase.logging.core.DefaultLogger;

 import liquibase.resource.ClassLoaderResourceAccessor;

 import liquibase.resource.ResourceAccessor;

 import liquibase.util.StringUtils;

 public class ServiceLocator {

     private static ServiceLocator instance;

     static {

         try {

             Class<?> scanner = Class.forName("Liquibase.ServiceLocator.ClrServiceLocator, Liquibase");

             instance = (ServiceLocator) scanner.newInstance();

         } catch (Exception e) {

             instance = new ServiceLocator();

         }

     }

     private ResourceAccessor resourceAccessor;

     private Map<Class, List<Class>> classesBySuperclass;

     private List<String> packagesToScan;

     private Logger logger = new DefaultLogger(); // cannot look up regular logger because you get a stackoverflow since

     // we are in the servicelocator

     private PackageScanClassResolver classResolver;

     private ServiceLocator() {

         setResourceAccessor(new ClassLoaderResourceAccessor());

     }

     private ServiceLocator(ResourceAccessor accessor) {

         setResourceAccessor(accessor);

     }

     public static ServiceLocator getInstance() {

         return instance;

     }

     public void setResourceAccessor(ResourceAccessor resourceAccessor) {

         this.resourceAccessor = resourceAccessor;

         this.classesBySuperclass = new HashMap<Class, List<Class>>();

         if (WebSpherePackageScanClassResolver.isWebSphereClassLoader(this.getClass().getClassLoader())) {

             logger.debug("Using WebSphere Specific Class Resolver");

             this.classResolver = new WebSpherePackageScanClassResolver("liquibase/parser/core/xml/dbchangelog-2.0.xsd");

         } else {

             this.classResolver = new DefaultPackageScanClassResolver();

         }

         this.classResolver.setClassLoaders(new HashSet<ClassLoader>(Arrays.asList(new ClassLoader[] { resourceAccessor

                 .toClassLoader() })));

         packagesToScan = new ArrayList<String>();

         String packagesToScanSystemProp = System.getProperty("liquibase.scan.packages");

         if ((packagesToScanSystemProp != null)

                 && ((packagesToScanSystemProp = StringUtils.trimToNull(packagesToScanSystemProp)) != null)) {

             for (String value : packagesToScanSystemProp.split(",")) {

                 addPackageToScan(value);

             }

         } else {

             Enumeration<URL> manifests = null;

             try {

                 manifests = resourceAccessor.getResources("META-INF/MANIFEST.MF");

                 while (manifests.hasMoreElements()) {

                     URL url = manifests.nextElement();

                     InputStream is = url.openStream();

                     Manifest manifest = new Manifest(is);

                     String attributes = StringUtils.trimToNull(manifest.getMainAttributes().getValue(

                             "Liquibase-Package"));

                     if (attributes != null) {

                         for (Object value : attributes.split(",")) {

                             addPackageToScan(value.toString());

                         }

                     }

                     is.close();

                 }

             } catch (IOException e) {

                 throw new UnexpectedLiquibaseException(e);

             }

             if (packagesToScan.size() == 0) {

                 addPackageToScan("liquibase.change");

                 addPackageToScan("liquibase.database");

                 addPackageToScan("liquibase.parser");

                 addPackageToScan("liquibase.precondition");

                 addPackageToScan("liquibase.serializer");

                 addPackageToScan("liquibase.sqlgenerator");

                 addPackageToScan("liquibase.executor");

                 addPackageToScan("liquibase.snapshot");

                 addPackageToScan("liquibase.logging");

                 addPackageToScan("liquibase.ext");

             }

         }

     }

     public void addPackageToScan(String packageName) {

         packagesToScan.add(packageName);

     }

     public Class findClass(Class requiredInterface) throws ServiceNotFoundException {

         Class[] classes = findClasses(requiredInterface);

         if (PrioritizedService.class.isAssignableFrom(requiredInterface)) {

             PrioritizedService returnObject = null;

             for (Class clazz : classes) {

                 PrioritizedService newInstance;

                 try {

                     newInstance = (PrioritizedService) clazz.newInstance();

                 } catch (Exception e) {

                     throw new UnexpectedLiquibaseException(e);

                 }

                 if (returnObject == null || newInstance.getPriority() > returnObject.getPriority()) {

                     returnObject = newInstance;

                 }

             }

             if (returnObject == null) {

                 throw new ServiceNotFoundException("Could not find implementation of " + requiredInterface.getName());

             }

             return returnObject.getClass();

         }

         if (classes.length != 1) {

             throw new ServiceNotFoundException("Could not find unique implementation of " + requiredInterface.getName()

                     + ".  Found " + classes.length + " implementations");

         }

         return classes[0];

     }

     public Class[] findClasses(Class requiredInterface) throws ServiceNotFoundException {

         logger.debug("ServiceLocator.findClasses for " + requiredInterface.getName());

         try {

             Class.forName(requiredInterface.getName());

             if (!classesBySuperclass.containsKey(requiredInterface)) {

                 classesBySuperclass.put(requiredInterface, findClassesImpl(requiredInterface));

             }

         } catch (Exception e) {

             throw new ServiceNotFoundException(e);

         }

         List<Class> classes = classesBySuperclass.get(requiredInterface);

         HashSet<Class> uniqueClasses = new HashSet<Class>(classes);

         return uniqueClasses.toArray(new Class[uniqueClasses.size()]);

     }

     public Object newInstance(Class requiredInterface) throws ServiceNotFoundException {

         try {

             return findClass(requiredInterface).newInstance();

         } catch (Exception e) {

             throw new ServiceNotFoundException(e);

         }

     }

     private List<Class> findClassesImpl(Class requiredInterface) throws Exception {

         logger.debug("ServiceLocator finding classes matching interface " + requiredInterface.getName());

         List<Class> classes = new ArrayList<Class>();

         classResolver.addClassLoader(resourceAccessor.toClassLoader());

         for (Class<?> clazz : classResolver.findImplementations(requiredInterface,

                 packagesToScan.toArray(new String[packagesToScan.size()]))) {

             if (clazz.getAnnotation(LiquibaseService.class) != null

                     && clazz.getAnnotation(LiquibaseService.class).skip()) {

                 continue;

             }

             if (!Modifier.isAbstract(clazz.getModifiers()) && !Modifier.isInterface(clazz.getModifiers())

                     && Modifier.isPublic(clazz.getModifiers())) {

                 try {

                     clazz.getConstructor();

                     logger.debug(clazz.getName() + " matches " + requiredInterface.getName());

                     classes.add(clazz);

                 } catch (NoSuchMethodException e) {

                     logger.info("Can not use " + clazz

                             + " as a Liquibase service because it does not have a no-argument constructor");

                 }

             }

         }

         return classes;

     }

     public static void reset() {

         instance = new ServiceLocator();

     }

     protected Logger getLogger() {

         return logger;

     }

 }