/*
    * 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.type;
  
  import org.rblasch.convert.assertion.Assertion;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  /***
   * @author Ronald Blaschke
   */
  public class Types {
      // cache for already resolved types
      private static Map/*<Object, Type>*/ types = new HashMap();
  
      private static boolean isKnown(final Object key) {
          return types.containsKey(key);
      }
  
      private static void makeKnown(final Object key, final Type t) {
          Type knownT = null;
          if (types.containsValue(t)) {
              for (final Iterator i = types.values().iterator(); i.hasNext();) {
                  final Type ti = (Type) i.next();
                  if (t.equals(ti)) {
                      knownT = ti;
                  }
              }
          } else {
              knownT = t;
          }
          Assertion.ensure(knownT != null, "Known type must not be null");
  
          types.put(key, knownT);
      }
  
      private static Type knownType(final Object key) {
          if (isKnown(key)) {
              return (Type) types.get(key);
          } else {
              throw new UnknownTypeException(key + " is not a known type");
          }
      }
  
      public static Type findTypeByName(final String name) throws UnknownTypeException {
          return findType(name);
      }
  
      public static Type primitiveArrayType() {
          return ArrayType.getInstance();
      }
  
      public static Type nullType() {
          return NullType.getInstance();
      }
  
      public static Type findPrimitiveType(final Class c) {
          return new PrimitiveType(c);
      }
  
      public static Type findTypeByClass(final Class c) {
          return findType(c);
      }
  
      public static Type findPTypeByName(final String t, final String p1) throws UnknownTypeException {
          return findPType(t, Collections.singletonList(p1));
      }
  
      public static Type findPTypeByClass(final Class c, final Class p1) throws UnknownTypeException {
          return findPType(c, Collections.singletonList(p1));
      }
  
      public static Type findPTypeByType(final Type t, final Type p1) throws UnknownTypeException {
          return findPType(t, Collections.singletonList(p1));
      }
  
      public static ParameterizableType findPTypeByType(final Type t, final List/*<Type>*/ parameters) throws UnknownTypeException {
          return findPType(t, parameters);
      }
  
     private static ParameterizableType findPType(final Object type, final List/*<Object>*/ parameters) throws UnknownTypeException {
         final List/* <Object>*/ request = new ArrayList(2);
         request.add(type);
         request.addAll(parameters);
         if (isKnown(request)) {
             return (ParameterizableType) knownType(request);
         } else {
             final ParameterizableType t = findPTypeInternal(type, parameters);
             makeKnown(request, t);
             return t;
         }
     }
 
     private static Type findType(final Object type) throws UnknownTypeException {
         if (isKnown(type)) {
             return knownType(type);
         } else {
             final Type t = findTypeInternal(type);
             makeKnown(type, t);
             return t;
         }
     }
 
     private static Type findTypeInternal(final Object t) throws UnknownTypeException {
         if (t instanceof Type) {
             return (Type) t;
         } else if (t instanceof String) {
             return findTypeInternal((String) t);
         } else if (t instanceof Class) {
             return findTypeInternal((Class) t);
         } else {
             throw new UnknownTypeException("Don't know how to resolve type " + t + " (" + t.getClass() + ")");
         }
     }
 
     private static Type findTypeInternal(final String name) throws UnknownTypeException {
         if ("any".equals(name)) {
             return AnyType.getInstance();
         } else if ("array".equals(name)) {
             return ArrayType.getInstance();
         } else {
             try {
                 return PrimitiveType.valueOf(name);
             } catch (final UnknownTypeException ex) {
                 try {
                     return ClassType.valueOf(name);
                 } catch (final UnknownTypeException ex2) {
                     try {
                         return ParameterizableType.valueOf(name);
                     } catch (final UnknownTypeException ex3) {
                         throw new UnknownTypeException(name + " is not a known type");
                     }
                 }
             }
         }
     }
 
     private static Type findTypeInternal(final Class c) throws UnknownTypeException {
         if (c.isPrimitive()) {
             return new PrimitiveType(c);
         } else if (c.isArray()) {
             return new ParameterizableType(ArrayType.getInstance(),
                     Arrays.asList(new Type[]{findTypeByClass(c.getComponentType())}));
         } else {
             return new ClassType(c);
         }
     }
 
     private static ParameterizableType findPTypeInternal(final Object t, final List/*<Object>*/ parameters) throws UnknownTypeException {
         final List/*<Type>*/ l = new ArrayList(parameters.size());
         for (final Iterator i = parameters.iterator(); i.hasNext();) {
             l.add(findType(i.next()));
         }
         return new ParameterizableType(findType(t), l);
     }
 }