/*
    * Copyright 2009-2010 Steve Chaloner
    *
    * 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 be.objectify.led;
  
  import be.objectify.led.factory.object.BooleanFactory;
  import be.objectify.led.factory.object.ByteFactory;
  import be.objectify.led.factory.object.CharacterFactory;
  import be.objectify.led.factory.object.DoubleFactory;
  import be.objectify.led.factory.object.FloatFactory;
  import be.objectify.led.factory.object.IntegerFactory;
  import be.objectify.led.factory.object.LongFactory;
  import be.objectify.led.factory.object.ShortFactory;
  import be.objectify.led.factory.object.StringFactory;
  import be.objectify.led.util.ContractUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  /**
   * Registry of object factories for creating objects of the correct type based on the field.
   *
   * @author Steve Chaloner
   */
  public class ObjectFactoryRegistry
  {
      private static final Logger LOGGER = LoggerFactory.getLogger(ObjectFactoryRegistry.class);
  
      private final Map<Class, ObjectFactory> objectFactories = new HashMap<Class, ObjectFactory>();
  
      private static final Map<Class, Class> PRIMITIVE_TO_WRAPPER_MAP = new HashMap<Class, Class>();
  
      static
      {
          PRIMITIVE_TO_WRAPPER_MAP.put(boolean.class,
                                       Boolean.class);
          PRIMITIVE_TO_WRAPPER_MAP.put(byte.class,
                                       Byte.class);
          PRIMITIVE_TO_WRAPPER_MAP.put(char.class,
                                       Character.class);
          PRIMITIVE_TO_WRAPPER_MAP.put(double.class,
                                       Double.class);
          PRIMITIVE_TO_WRAPPER_MAP.put(float.class,
                                       Float.class);
          PRIMITIVE_TO_WRAPPER_MAP.put(int.class,
                                       Integer.class);
          PRIMITIVE_TO_WRAPPER_MAP.put(long.class,
                                       Long.class);
          PRIMITIVE_TO_WRAPPER_MAP.put(short.class,
                                       Short.class);
      }
  
      /**
       * Initialises a new instance of this class by registering the default object factories.
       */
      public ObjectFactoryRegistry()
      {
          ObjectFactory<Boolean> booleanFactory = new BooleanFactory();
          objectFactories.put(booleanFactory.getBoundClass(),
                              booleanFactory);
          ObjectFactory<Byte> byteFactory = new ByteFactory();
          objectFactories.put(byteFactory.getBoundClass(),
                              byteFactory);
          ObjectFactory<Character> characterFactory = new CharacterFactory();
          objectFactories.put(characterFactory.getBoundClass(),
                              characterFactory);
          ObjectFactory<Double> doubleFactory = new DoubleFactory();
          objectFactories.put(doubleFactory.getBoundClass(),
                              doubleFactory);
          ObjectFactory<Float> floatFactory = new FloatFactory();
          objectFactories.put(floatFactory.getBoundClass(),
                              floatFactory);
          ObjectFactory<Integer> integerFactory = new IntegerFactory();
          objectFactories.put(integerFactory.getBoundClass(),
                              integerFactory);
          ObjectFactory<Long> longFactory = new LongFactory();
          objectFactories.put(longFactory.getBoundClass(),
                              longFactory);
          ObjectFactory<Short> shortFactory = new ShortFactory();
          objectFactories.put(shortFactory.getBoundClass(),
                              shortFactory);
          ObjectFactory<String> stringFactory = new StringFactory();
          objectFactories.put(stringFactory.getBoundClass(),
                             stringFactory);
     }
 
     /**
      * Registers the object factories with the registry.
      *
      * @param objectFactories the object factories.  None of the factories can be null.
      */
     public void register(ObjectFactory... objectFactories)
     {
         ContractUtils.nonNull(objectFactories,
                                    "objectFactories");
 
         register(Arrays.asList(objectFactories));
     }
 
     /**
      * Registers the object factories with the registry.
      *
      * @param objectFactories the object factories to register.  Must not be null; none of contents
      */
     public void register(List<ObjectFactory> objectFactories)
     {
         ContractUtils.nonNull(objectFactories,
                                    "objectFactories");
 
         for (ObjectFactory objectFactory : objectFactories)
         {
             this.objectFactories.put(objectFactory.getBoundClass(),
                                      objectFactory);
         }
     }
 
     /**
      * Gets the object factory for the given class.
      *
      * @param clazz the class of the required object
      * @return the object factory, or null if no factory is registered for the class
      */
     public ObjectFactory getFactory(Class clazz)
     {
         if (clazz.isPrimitive())
         {
             clazz = PRIMITIVE_TO_WRAPPER_MAP.get(clazz);
         }
 
         ObjectFactory factory = objectFactories.get(clazz);
 
         if (factory != null)
         {
             LOGGER.debug("Found object factory [{}] for class [{}]",
                          factory,
                          clazz.getCanonicalName());
         }
         else
         {
             LOGGER.debug("Could not find object factory for {}",
                          clazz.getCanonicalName());
         }
 
         return factory;
     }
 }