/*

  ORG Usurper is a random value object generator library 

  Copyright (C) 2007  Pierre-Antoine Grégoire

  This library is free software; you can redistribute it and/or

  modify it under the terms of the GNU Lesser General Public

  License as published by the Free Software Foundation; either

  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public

  License along with this library; if not, write to the Free Software

  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

  */

 package org.org.usurper.springframework;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import org.org.usurper.handlers.IHandler;

 import org.org.usurper.handlers.basic.AbstractPropertyTypeHandler;

 import org.org.usurper.handlers.basic.AbstractSpecificPropertyHandler;

 import org.org.usurper.handlers.basic.ArrayHandler;

 import org.org.usurper.handlers.basic.EnumHandler;

 import org.org.usurper.model.ITargetDefinition;

 import org.org.usurper.model.PropertyTypeDefinition;

 import org.org.usurper.model.SpecificPropertyDefinition;

 import org.org.usurper.setup.ICountCallback;

 import org.org.usurper.setup.IUsurperGeneratorSetup;

 import org.org.usurper.setup.UsurperGeneratorSetup;

 import org.org.usurper.setup.constants.OnMissingHandlers;

 import org.org.usurper.setup.constants.PropertyWritingMechanism;

 import org.springframework.beans.factory.FactoryBean;

 import org.springframework.beans.factory.InitializingBean;

 /**

  * The Class UsurperGeneratorSetupFactoryBean is a Spring compliant FactoryBean and InitializingBean.

  * As such, it can be used as any other Spring Factory Bean.

  * It generates an UsurperGeneratorSetup.

  */

 public class UsurperGeneratorSetupFactoryBean implements FactoryBean, InitializingBean {

     private ArrayHandler arrayHandler;

     private ICountCallback countCallback;

     private EnumHandler enumHandler;

     private OnMissingHandlers onMissingHandlers=null;

     private PropertyWritingMechanism propertyWritingMechanism=null;

     private Map<PropertyTypeDefinition, AbstractPropertyTypeHandler> propertyTypeHandlersMap;

     private Map<SpecificPropertyDefinition, AbstractSpecificPropertyHandler> specificPropertyHandlersMap;

     private UsurperGeneratorSetup usurperGeneratorSetup;

     private IUsurperGeneratorSetup parentSetup;

     public UsurperGeneratorSetupFactoryBean() {

         super();

     }

     public Object getObject() throws Exception {

         return usurperGeneratorSetup;

     }

     @SuppressWarnings("unchecked")

     public Class getObjectType() {

         return IUsurperGeneratorSetup.class;

     }

     public boolean isSingleton() {

         return false;

     }

     @SuppressWarnings("unchecked")

     public void afterPropertiesSet() throws Exception {

         if (parentSetup != null) {

             usurperGeneratorSetup = new UsurperGeneratorSetup(parentSetup);

         } else {

             usurperGeneratorSetup = new UsurperGeneratorSetup();

         }

         if (arrayHandler != null) {

             usurperGeneratorSetup.setArrayHandler(arrayHandler);

         }

         if (enumHandler != null) {

             usurperGeneratorSetup.setArrayHandler(arrayHandler);

         }

         if (onMissingHandlers != null) {

             usurperGeneratorSetup.onMissingHandlers(onMissingHandlers);

         }

         if (propertyWritingMechanism != null) {

             usurperGeneratorSetup.usePropertyWritingMechanism(propertyWritingMechanism);

         }

         if (countCallback != null) {

             usurperGeneratorSetup.setCountCallback(countCallback);

         }

         Map<ITargetDefinition, IHandler> handlers = new HashMap<ITargetDefinition, IHandler>();

         if (propertyTypeHandlersMap != null) {

             handlers.putAll(propertyTypeHandlersMap);

         }

         if (specificPropertyHandlersMap != null) {

             handlers.putAll(specificPropertyHandlersMap);

         }

         usurperGeneratorSetup.setAllHandlers(handlers);

     }

     public void setArrayHandlerName(String arrayHandler) {

         try {

             this.arrayHandler = (ArrayHandler) Class.forName(arrayHandler).newInstance();

         } catch (Exception e) {

             throw new IllegalArgumentException("Impossible to instanciate class " + arrayHandler, e);

         }

     }

     public void setArrayHandler(ArrayHandler arrayHandler) {

         this.arrayHandler = arrayHandler;

     }

     public void setCountCallback(ICountCallback countCallback) {

         this.countCallback = countCallback;

     }

     public void setCountCallbackName(String countCallback) {

         try {

             this.countCallback = (ICountCallback) Class.forName(countCallback).newInstance();

         } catch (Exception e) {

             throw new IllegalArgumentException("Impossible to instanciate class " + countCallback, e);

         }

     }

     public void setConstructorParameterTypes(List<String> constructorParameterTypesNames) {

         Class<?>[] constructorParameterTypes = new Class<?>[constructorParameterTypesNames.size()];

         int i = 0;

         for (String constructorParameterType : constructorParameterTypesNames) {

             try {

                 constructorParameterTypes[i++] = Class.forName(constructorParameterType);

             } catch (Exception e) {

                 throw new IllegalArgumentException("Impossible to find class " + constructorParameterType, e);

             }

         }

     }

     public void setEnumHandlerName(String enumHandler) {

         try {

             this.enumHandler = (EnumHandler) Class.forName(enumHandler).newInstance();

         } catch (Exception e) {

             throw new IllegalArgumentException("Impossible to instanciate class " + enumHandler, e);

         }

     }

     public void setEnumHandler(EnumHandler enumHandler) {

         this.enumHandler = enumHandler;

     }

     public void setOnMissingHandlers(String onMissingHandlers) {

         this.onMissingHandlers = OnMissingHandlers.valueOf(onMissingHandlers.toUpperCase());

     }

     public void setPropertyTypeHandlers(Set<AbstractPropertyTypeHandler> propertyTypeHandlers) {

         initPropertyTypeHandlersMap();

         for (AbstractPropertyTypeHandler propertyTypeHandler : propertyTypeHandlers) {

             for (PropertyTypeDefinition propertyTypeDefinition : propertyTypeHandler.getHandledTypes()) {

                 this.propertyTypeHandlersMap.put(propertyTypeDefinition, propertyTypeHandler);

             }

         }

     }

     public void setSpecificPropertyHandlers(Set<AbstractSpecificPropertyHandler> specificPropertyHandlers) {

         initSpecificPropertyHandlersMap();

         for (AbstractSpecificPropertyHandler specificPropertyHandler : specificPropertyHandlers) {

             this.specificPropertyHandlersMap.put(specificPropertyHandler.getTargetProperty(), specificPropertyHandler);

         }

     }

     public void setPropertyTypeHandlersClassNames(Map<Class<?>, Class<?>> propertyTypeHandlersMap) {

         initPropertyTypeHandlersMap();

         Map<PropertyTypeDefinition, AbstractPropertyTypeHandler> result = new HashMap<PropertyTypeDefinition, AbstractPropertyTypeHandler>();

         for (Class<?> key : propertyTypeHandlersMap.keySet()) {

             try {

                 Set<PropertyTypeDefinition> propertyTypeDefinitions = new HashSet<PropertyTypeDefinition>();

                 PropertyTypeDefinition propertyTypeDefinition = new PropertyTypeDefinition(key);

                 propertyTypeDefinitions.add(propertyTypeDefinition);

                 AbstractPropertyTypeHandler value = (AbstractPropertyTypeHandler) propertyTypeHandlersMap.get(key).getConstructor(Set.class).newInstance(new Object[] { propertyTypeDefinitions });

                 result.put(new PropertyTypeDefinition(key), value);

             } catch (Exception e) {

                 throw new IllegalArgumentException();

             }

         }

         this.propertyTypeHandlersMap.putAll(result);

     }

     public void setSpecificPropertyHandlersClassNames(Map<String, Class<?>> specificPropertyHandlersMap) {

         initSpecificPropertyHandlersMap();

         Map<SpecificPropertyDefinition, AbstractSpecificPropertyHandler> result = new HashMap<SpecificPropertyDefinition, AbstractSpecificPropertyHandler>();

         for (String key : specificPropertyHandlersMap.keySet()) {

             SpecificPropertyDefinition specificPropertyDefinition = new SpecificPropertyDefinition(key);

             try {

                 AbstractSpecificPropertyHandler value = (AbstractSpecificPropertyHandler) specificPropertyHandlersMap.get(key).getConstructor(SpecificPropertyDefinition.class).newInstance(specificPropertyDefinition);

                 result.put(specificPropertyDefinition, value);

             } catch (Exception e) {

                 throw new IllegalArgumentException();

             }

         }

         this.specificPropertyHandlersMap.putAll(result);

     }

     private synchronized void initPropertyTypeHandlersMap() {

         if(propertyTypeHandlersMap==null)propertyTypeHandlersMap = new HashMap<PropertyTypeDefinition, AbstractPropertyTypeHandler>();

     }

     private synchronized void initSpecificPropertyHandlersMap() {

         if(specificPropertyHandlersMap==null)specificPropertyHandlersMap = new HashMap<SpecificPropertyDefinition, AbstractSpecificPropertyHandler>();

     }

     public void setPropertyWritingMechanism(String propertyWritingMechanism) {

         this.propertyWritingMechanism = PropertyWritingMechanism.valueOf(propertyWritingMechanism.toUpperCase());

     }

     public void onMissingHandlers(OnMissingHandlers onMissingHandlers) {

         this.onMissingHandlers = onMissingHandlers;

     }

     public void usePropertyWritingMechanism(PropertyWritingMechanism propertyWritingMechanism) {

         this.propertyWritingMechanism = propertyWritingMechanism;

     }

     public void setParentSetup(IUsurperGeneratorSetup parentSetup) {

         this.parentSetup = parentSetup;

     }

 }