/*
    * Copyright 2004 Ronald Blaschke.
    *
    * 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.rblasch.convert.converters.lang;
  
  import org.rblasch.convert.converters.AbstractConverterFactory;
  import org.rblasch.convert.converters.OnceConverterFactory;
  import org.rblasch.convert.converters.primitives.ByteToShortConverter;
  import org.rblasch.convert.converters.primitives.FloatToDoubleConverter;
  import org.rblasch.convert.converters.primitives.IntegerToLongConverter;
  import org.rblasch.convert.converters.primitives.ShortToIntegerConverter;
  import org.rblasch.convert.type.ClassType;
  import org.rblasch.convert.type.ParameterizableType;
  import org.rblasch.convert.type.Type;
  import org.rblasch.convert.type.Types;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Set;
  
  /***
   * @author Ronald Blaschke
   */
  public class JlConverterFactory extends AbstractConverterFactory implements OnceConverterFactory {
      public Set/*<MetaConverter>*/ createOnce() {
          final Set/*<MetaConverter>*/ converters = new HashSet();
  
          // autoboxing
          converters.add(new CastConverter(Types.findTypeByName("byte"),
                  Types.findTypeByClass(Byte.class)));
          converters.add(new CastConverter(Types.findTypeByClass(Byte.class),
                  Types.findTypeByName("byte")));
          converters.add(new CastConverter(Types.findTypeByName("short"),
                  Types.findTypeByClass(Short.class)));
          converters.add(new CastConverter(Types.findTypeByClass(Short.class),
                  Types.findTypeByName("short")));
          converters.add(new CastConverter(Types.findTypeByName("int"),
                  Types.findTypeByClass(Integer.class)));
          converters.add(new CastConverter(Types.findTypeByClass(Integer.class),
                  Types.findTypeByName("int")));
          converters.add(new CastConverter(Types.findTypeByName("long"),
                  Types.findTypeByClass(Long.class)));
          converters.add(new CastConverter(Types.findTypeByClass(Long.class),
                  Types.findTypeByName("long")));
  
          // "default" number widening
          converters.add(new ByteToShortConverter());
          converters.add(new ShortToIntegerConverter());
          converters.add(new IntegerToLongConverter());
  
          converters.add(new FloatToDoubleConverter());
  
          // "default" .toString() conversion
          converters.add(new ObjectToStringConverter());
  
          return converters;
      }
  
      // cache already resolved types
      private final Set/*<Type>*/ resolvedTypes = new HashSet();
  
      public Set/*<MetaConverter>*/ create(final Type sourceType, final Type destinationType) {
          final Set/*<MetaConverter>*/ converters = new HashSet();
          if (!resolvedTypes.contains(sourceType)) {
              converters.addAll(jlConverters(sourceType));
              resolvedTypes.add(sourceType);
          }
  
          if (!resolvedTypes.contains(destinationType)) {
              converters.addAll(jlConverters(destinationType));
              resolvedTypes.add(destinationType);
          }
  
          return converters;
      }
  
      private Set/*<MetaConverter>*/ jlConverters(final Type t) {
          final Set/*<MetaConverter>*/ converters = new HashSet();
  
          converters.add(new IdentityConverter(t));
  
          // class lookup
          if (t instanceof ClassType) {
             converters.addAll(castConverters(t));
         } else if (t instanceof ParameterizableType) {
             converters.addAll(castConverters(t));
 
             // recurse into all parameters
             final ParameterizableType pt = (ParameterizableType) t;
             for (final Iterator i = pt.getParameters().iterator(); i.hasNext();) {
                 converters.addAll(jlConverters((Type) i.next()));
             }
         }
 
         return converters;
     }
 
     private Set/*<MetaConverter>*/ castConverters(final Type t) {
         final Set/*<MetaConverter>*/ converters = new HashSet();
 
         final LinkedList/*<Type>*/ pending = new LinkedList();
         pending.add(t);
 
         while (!pending.isEmpty()) {
             final Type current = (Type) pending.removeFirst();
 
             final Set/*<Type>*/ superTypes = getSuperTypes(current);
             pending.addAll(superTypes);
             for (final Iterator i = superTypes.iterator(); i.hasNext();) {
                 converters.add(new CastConverter(current, (Type) i.next()));
             }
             resolvedTypes.add(current);
         }
 
         return converters;
     }
 
     static Set/*<Type>*/ getSuperTypes(final Type t) {
         final Set/*<Type>*/ superTypes = new HashSet();
         if (t instanceof ClassType) {
             final ClassType ct = (ClassType) t;
             final Class c = ct.getTheClass();
             if (c.getSuperclass() != null) {
                 superTypes.add(Types.findTypeByClass(c.getSuperclass()));
                 for (final Iterator i = Arrays.asList(c.getInterfaces()).iterator(); i.hasNext();) {
                     final Class iface = (Class) i.next();
                     superTypes.add(Types.findTypeByClass(iface));
                 }
             }
             if (c.isInterface()) {
                 superTypes.add(Types.findTypeByClass(Object.class));
             }
         } else if (t instanceof ParameterizableType) {
             final ParameterizableType pt = (ParameterizableType) t;
 
             final List/*<Type>*/ ptl = toList(pt);
 
             for (int i = ptl.size()-1; i>=0; --i) {
                 final List/*<Type>*/ ptli = new ArrayList(ptl);
                 for (final Iterator j = getSuperTypes((Type) ptl.get(i)).iterator(); j.hasNext();) {
                     ptli.set(i, j.next());
                     final ParameterizableType pti = fromList(ptli);
                     superTypes.add(pti);
                 }
             }
         }
 
         return superTypes;
     }
 
     private static List/*<Type>*/ toList(final ParameterizableType t) {
         final List/*<Type>*/ l = new ArrayList();
 
         l.add(t.getType());
         l.addAll(t.getParameters());
 
         return l;
     }
 
     private static ParameterizableType fromList(final List/*<Type>*/ l) {
         return Types.findPTypeByType((Type) l.get(0), l.subList(1, l.size()));
     }
 }