/*
    * Created on 1 janv. 2005
    *
    * This program is free software; you can redistribute it and/or
    * modify it under the terms of the GNU General Public License
    * as published by the Free Software Foundation; either version 2
    * of the License, or (at your option) any later version.
    *
    * This program 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 General Public License for more details.
   * 
   * Full GNU GPL license terms : http://www.fsf.org/licenses/gpl.txt
   * 
   * Author : mchaplin@users.sourceforge.net
   */
  package net.mchaplin.ioc.component;
  
  import java.lang.reflect.Constructor;
  import java.lang.reflect.InvocationTargetException;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import net.mchaplin.commons.StackTraceUtils;
  import net.mchaplin.commons.WmindObject;
  import net.mchaplin.ioc.ContainerI;
  
  /***
   * Delegate class for components instanciation
   * 
   * @author mchaplin@users.sourceforge.net
   * 
   * $Header$Revision$Date:
   */
  public class DefaultComponentFactory implements ComponentI {
      
      protected transient ContainerI container;
      protected static Log log = LogFactory.getLog(DefaultComponentFactory.class);
      
      public DefaultComponentFactory(ContainerI aContainer) {
          container = aContainer;
      }
      
      /***
       * Instanciate a component. Constructor dependencies
       * are looked up inside the container hierarchy.
       * 
       * @param component the component to instanciate
       * @return an instance of component
       */
      private Object instanciateComponent(Class component) {
  
          boolean emtyCnstr = false;
          String constrLoc = null;
          int params = 0;
          Constructor curConstr = null;
          Constructor targetConstr = null; // the constructor that will be
                                                // used for this component
                                                // instanciation
          Class[] constrParams = null;
          Class curParam = null;
          Object instance = null;
  
          Constructor[] cmpConstr = component.getDeclaredConstructors();
  
          // introspect object constructors : for each constructor
          for (int i = 0; i < cmpConstr.length; i++) {
              curConstr = cmpConstr[i];
              constrParams = curConstr.getParameterTypes();
              // if it's not an empty parameter one
              if (constrParams.length != 0) {
                  log.debug("Introspecting a " + constrParams.length + " parameters Constructor");
                  // check if the container knows about constructor parameter types
                  for (int j = 0; j < constrParams.length; j++) {
                      curParam = constrParams[j];
                      constrLoc = container.lookupComponent(curParam);
                      // if not found, check if the parent container knows about
                      // constructor parameter types
                      if (constrLoc == null) {
                          constrLoc = container.getParent().lookupComponent(curParam);
                      }
                  }
                  // check if this is the biggest constructor we know
                  if (constrLoc != null && constrParams.length > params) {
                      params = constrParams.length;
                      targetConstr = curConstr;
                  }
              } else {
                  emtyCnstr = true;
              }
          }
          if (!emtyCnstr && targetConstr != null) {
              instance = parameterizedConstructorInstanciation(targetConstr);
          } else { // the component has an empty constructor only.
              instance = emptyConstructorInstanciation(component);
          }
  
         return instance;
     }
     
     /***
      * @param component
      * @param instance
      * @return
      */
     private Object emptyConstructorInstanciation(Class component) {
         Object instance = null;
         try {
             instance = component.newInstance();
         } catch (InstantiationException e) {
             log.error("InstantiationException thrown while instanciating : " + component.toString().substring(6));
             log.error(WmindObject.EX_CAUSE);
             StackTraceUtils.printStackTrace(e.getCause());
             log.error(WmindObject.EX_STACK);
         } catch (IllegalAccessException e) {
             log.error("IllegalAccessException thrown while instanciating : " + component.toString().substring(6));
             StackTraceUtils.printStackTrace(e);
         }
         
         return instance;
     }
 
     /***
      * @param component
      * @param curConstructor
      * @param constr
      * @param instance
      * @return
      */
     private Object parameterizedConstructorInstanciation(Constructor constr) {
         Class[] cnstrPrms = null;
         Object[] oParams = null;
         Object instance = null;
         /* instanciate the component, injecting instances from container
          * into constructor 
          */ 
         
         cnstrPrms = constr.getParameterTypes();
         oParams = new Object[cnstrPrms.length];
         for (int k = 0; k < cnstrPrms.length; k++) {
             oParams[k] = container.retrieveComponentInstance(cnstrPrms[k]);
         }
         try {
             instance = constr.newInstance(oParams);
         } catch (IllegalArgumentException e) {
             log.error("IllegalArgumentException thrown while instanciating : " + constr.getName());
             StackTraceUtils.printStackTrace(e);
         } catch (InstantiationException e) {
             log.error(WmindObject.EX_CAUSE);
             StackTraceUtils.printStackTrace(e.getCause());
             log.error(WmindObject.EX_STACK);
             log.error("InstantiationException thrown while instanciating : " +  constr.getName());
             StackTraceUtils.printStackTrace(e);
         } catch (IllegalAccessException e) {
             log.error("IllegalAccessException thrown while instanciating : " +  constr.getName());
             StackTraceUtils.printStackTrace(e);
         } catch (InvocationTargetException e) {
             log.error("InvocationTargetException thrown while instanciating : " +  constr.getName());
             log.error(WmindObject.EX_CAUSE);
             StackTraceUtils.printStackTrace(e.getCause());
             log.error(WmindObject.EX_STACK);
             StackTraceUtils.printStackTrace(e);
         }
         return instance;
     }
 
     /* (non-Javadoc)
      * @see net.mchaplin.container.component.ComponentI#getContainer()
      */
     public ContainerI getContainer() {
         // TODO Auto-generated method stub
         return null;
     }
 
     /* (non-Javadoc)
      * @see net.mchaplin.container.component.ComponentI#reset()
      */
     public void reset() {
         // TODO Auto-generated method stub
         
     }
 
     /* (non-Javadoc)
      * @see net.mchaplin.container.component.ComponentI#setContainer(net.mchaplin.container.ContainerI)
      */
     public void setContainer(ContainerI container) {
         // TODO Auto-generated method stub
         
     }
     
     
 
 }