/*******************************************************************************
    * 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.
   *******************************************************************************/
  package org.apache.commons.convert;
  
  import java.lang.reflect.Modifier;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Set;
  import java.util.concurrent.ConcurrentHashMap;
  
  import javax.imageio.spi.ServiceRegistry;
  
  /** A <code>Converter</code> factory and utility class.
   * <p>The factory loads {@link org.apache.commons.convert.Converter} instances
   * via the Java service provider registry. Applications can extend the
   * converter framework by:<br />
   * <ul>
   * <li>Creating classes that implement the
   * {@link org.apache.commons.convert.Converter} class</li>
   * <li>Create a {@link org.apache.commons.convert.ConverterLoader} class that
   * registers those classes</li>
   * <li>Create a <code>META-INF/services/org.apache.commons.convert.ConverterLoader</code>
   * file that contains the {@link org.apache.commons.convert.ConverterLoader} class name(s)</li>
   * </ul></p>
   * <p>To convert an object, call the static {@link #getConverter(Class, Class)} method to
   * get a {@link org.apache.commons.convert.Converter} instance, then call the converter's
   * {@link org.apache.commons.convert.Converter#convert(Object)} method.
   * </p>
   */
  public class Converters {
      protected static final String DELIMITER = "->";
      protected static final ConcurrentHashMap<String, Converter<?, ?>> converterMap = new ConcurrentHashMap<String, Converter<?, ?>>();
      protected static final Set<ConverterCreator> creators = Collections.synchronizedSet(new HashSet<ConverterCreator>());
      protected static final Set<String> noConversions = Collections.synchronizedSet(new HashSet<String>());
  
      static {
          registerCreator(new PassThruConverterCreator());
          ClassLoader loader = Thread.currentThread().getContextClassLoader();
          Iterator<ConverterLoader> converterLoaders = ServiceRegistry.lookupProviders(ConverterLoader.class, loader);
          while (converterLoaders.hasNext()) {
              try {
                  ConverterLoader converterLoader = converterLoaders.next();
                  converterLoader.loadConverters();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
      }
  
      private Converters() {}
  
  
      /** Returns an appropriate <code>Converter</code> instance for
       * <code>sourceClass</code> and <code>targetClass</code>. If no matching
       * <code>Converter</code> is found, the method throws
       * <code>ClassNotFoundException</code>.
       *
       * <p>This method is intended to be used when the source or
       * target <code>Object</code> types are unknown at compile time.
       * If the source and target <code>Object</code> types are known
       * at compile time, then the appropriate converter instance should be used.</p>
       *
       * @param sourceClass The object class to convert from
       * @param targetClass The object class to convert to
       * @return A matching <code>Converter</code> instance
       * @throws ClassNotFoundException
       */
      public static <S, T> Converter<S, T> getConverter(Class<S> sourceClass, Class<T> targetClass) throws ClassNotFoundException {
          String key = sourceClass.getName().concat(DELIMITER).concat(targetClass.getName());
          OUTER:
              do {
                  Converter<?, ?> result = converterMap.get(key);
                  if (result != null) {
                      return Util.cast(result);
                  }
                  if (noConversions.contains(key)) {
                      throw new ClassNotFoundException("No converter found for " + key);
                  }
                  Class<?> foundSourceClass = null;
                  Converter<?, ?> foundConverter = null;
                  for (Converter<?, ?> value : converterMap.values()) {
                      if (value.canConvert(sourceClass, targetClass)) {
                         // this converter can deal with the source/target pair
                         if (foundSourceClass == null || foundSourceClass.isAssignableFrom(value.getSourceClass())) {
                             // remember the current target source class; if we find another converter, check
                             // to see if it's source class is assignable to this one, and if so, it means it's
                             // a child class, so we'll then take that converter.
                             foundSourceClass = value.getSourceClass();
                             foundConverter = value;
                         }
                     }
                 }
                 if (foundConverter != null) {
                     converterMap.putIfAbsent(key, foundConverter);
                     continue OUTER;
                 }
                 for (ConverterCreator value : creators) {
                     result = createConverter(value, sourceClass, targetClass);
                     if (result != null) {
                         converterMap.putIfAbsent(key, result);
                         continue OUTER;
                     }
                 }
                 noConversions.add(key);
                 throw new ClassNotFoundException("No converter found for " + key);
             } while (true);
     }
 
     private static <S, SS extends S, T, TT extends T> Converter<SS, TT> createConverter(ConverterCreator creater, Class<SS> sourceClass, Class<TT> targetClass) {
         return creater.createConverter(sourceClass, targetClass);
     }
 
     /** Load all classes that implement {@link org.apache.commons.convert.Converter} and are
      * contained in <code>containerClass</code>.
      *
      * @param containerClass A class that contains {@link org.apache.commons.convert.Converter}
      * implementations
      */
     public static void loadContainedConverters(Class<?> containerClass) {
         // This only returns public classes and interfaces
         for (Class<?> clz: containerClass.getClasses()) {
             try {
                 // non-abstract, which means no interfaces or abstract classes
                 if ((clz.getModifiers() & Modifier.ABSTRACT) == 0) {
                     Object value;
                     try {
                         value = clz.getConstructor().newInstance();
                     } catch (NoSuchMethodException e) {
                         // ignore this, as this class might be some other helper class,
                         // with a non-pubilc constructor
                         continue;
                     }
                     if (value instanceof ConverterLoader) {
                         ConverterLoader loader = (ConverterLoader) value;
                         loader.loadConverters();
                     }
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }
 
     /** Registers a <code>ConverterCreator</code> instance to be used by the
      * {@link org.apache.commons.convert.Converters#getConverter(Class, Class)}
      * method, when a converter can't be found.
      *
      * @param <S> The source object type
      * @param <T> The target object type
      * @param creator The <code>ConverterCreator</code> instance to register
      */
     public static <S, T> void registerCreator(ConverterCreator creator) {
         creators.add(creator);
     }
 
     /** Registers a <code>Converter</code> instance to be used by the
      * {@link org.apache.commons.convert.Converters#getConverter(Class, Class)}
      * method.
      *
      * @param <S> The source object type
      * @param <T> The target object type
      * @param converter The <code>Converter</code> instance to register
      */
     public static <S, T> void registerConverter(Converter<S, T> converter) {
         registerConverter(converter, converter.getSourceClass(), converter.getTargetClass());
     }
 
     /** Registers a <code>Converter</code> instance to be used by the
      * {@link org.apache.commons.convert.Converters#getConverter(Class, Class)}
      * method.
      * 
      * @param <S> The source object type
      * @param <T> The target object type
      * @param converter
      * @param sourceClass
      * @param targetClass
      */
     public static <S, T> void registerConverter(Converter<S, T> converter, Class<?> sourceClass, Class<?> targetClass) {
         StringBuilder sb = new StringBuilder();
         if (sourceClass != null) {
             sb.append(sourceClass.getName());
         } else {
             sb.append("<null>");
         }
         sb.append(DELIMITER);
         if (targetClass != null) {
             sb.append(targetClass.getName());
         } else {
             sb.append("<null>");
         }
         String key = sb.toString();
         converterMap.putIfAbsent(key, converter);
     }
 
     protected static class PassThruConverterCreator implements ConverterCreator{
         protected PassThruConverterCreator() {
         }
 
         public <S, T> Converter<S, T> createConverter(Class<S> sourceClass, Class<T> targetClass) {
             if (sourceClass == targetClass || targetClass == Object.class || Util.instanceOf(sourceClass, targetClass)) {
                 return new PassThruConverter<S, T>(sourceClass, targetClass);
             } else {
                 return null;
             }
         }
     }
 
     /** Pass-through converter used when the source and target java object
      * types are the same. The <code>convert</code> method returns the
      * source object.
      *
      */
     protected static class PassThruConverter<S, T> implements Converter<S, T> {
         private final Class<S> sourceClass;
         private final Class<T> targetClass;
 
         public PassThruConverter(Class<S> sourceClass, Class<T> targetClass) {
             this.sourceClass = sourceClass;
             this.targetClass = targetClass;
         }
 
         public boolean canConvert(Class<?> sourceClass, Class<?> targetClass) {
             return this.sourceClass == sourceClass && this.targetClass == targetClass;
         }
 
         @SuppressWarnings("unchecked")
         public T convert(S obj) throws ConversionException {
             return (T) obj;
         }
 
         public Class<?> getSourceClass() {
             return sourceClass;
         }
 
         public Class<?> getTargetClass() {
             return targetClass;
         }
     }
 }