/*
    * Created on Nov 10, 2004
    *
    * 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.
   * 
   * Full GNU LGPL license terms : http://www.gnu.org/copyleft/lesser.txt
   * 
   * Project : iky-container
   * Package : net.wmind.container
   * Author : mchaplin@users.sourceforge.net
   */
  package net.mchaplin.ioc;
  
  import java.io.FileNotFoundException;
  import java.io.FileReader;
  import java.util.Iterator;
  
  import net.mchaplin.commons.WmindObject;
  import net.mchaplin.ioc.component.ComponentFactoryI;
  import net.mchaplin.ioc.component.ComponentI;
  import net.mchaplin.ioc.exp.ContainerException;
  import net.mchaplin.ioc.model.Component;
  import net.mchaplin.ioc.model.Container;
  
  import com.thoughtworks.xstream.XStream;
  
  /***
   * Instanciate containers & components, register components into containers from
   * XML definition file
   * 
   * 
   * @author mchaplin@users.sourceforge.net
   * 
   * $Header$Revision$Date:
   */
  public class XmlContainerFactory extends WmindObject implements ComponentFactoryI {
  
      private static final String CONTROLLER = "Controller [";
      private static final String SERVICE = "Service [";
      private static final String CLASS_NOT_FOUND = "] is not on the classpath !";
  
      /*** XStream object model */
      private transient Container config = null;
  
      public XmlContainerFactory(String fileName) {
          FileReader xmlFile = null;
          try {
              xmlFile = new FileReader(fileName);
          } catch (FileNotFoundException e) {
              log.error("Unable to load Container configuration file [" + fileName + "]");
          }
          // load xml configuration file
          loadConfigurationFile(xmlFile);
      }
  
      /***
       * Load the XML configuration file
       * 
       * @param fileName
       */
      private Container loadConfigurationFile(FileReader xmlFile) {
          if (xmlFile != null) {
              XStream xstream = new XStream();
              xstream.alias("container", Container.class);
              // Containers are components
              xstream.alias("container", Component.class);
              xstream.alias("component", Component.class);
              config = (Container) xstream.fromXML(xmlFile);
          } else {
              log.warn("Unable to load null configuration file !");
          }
          return config;
  
      }
  
      /***
       * Start containers defined in xml file
       * 
       * @return
       */
      public ContainerI retrieveInstance() {
          ContainerI[] containers = null;
          // Start default container
          DefaultContainer container = new DefaultContainer("core");
          // Register its configuration
          container.registerComponentInstance((ComponentI) config);
          // Load components
          loadComponents(container, config.getComponents().iterator());
          return container;
      }
  
     /***
      * Instanciate components from definitions object & register them into
      * target container
      * 
      * @param container
      *            container to load components to
      * @param itr
      *            iterator of components definition object, mapping xml
      *            definition file values.
      */
     public void loadComponents(ContainerI container, Iterator itr) {
         Component component;
         String className;
         // iterate through net.mchaplin.container.config.modelComponents objects
         while (itr.hasNext()) {
             Class cmpClass = null;
             component = (Component) itr.next();
             // unless not started by default..
             if (component.getLoadOnStartup().equals("true")) {
                 className = component.getClassname();
 
                 log.info("Starting service [" + component.getName() + "]");
                 // classpath lookup
                 try {
                     cmpClass = Class.forName(className);
                 } catch (ClassNotFoundException e) {
                     log.error(SERVICE + className + CLASS_NOT_FOUND);
                 }
                 // if component is in classpath
                 if (cmpClass != null) {
                     // factory and alias present
                     if (component.getFactory() != null && !component.getFactory().equals("")
                             && component.getAlias() != null && !component.getAlias().equals("")) {
 
                         Class controller = null;
                         try {
                             controller = Class.forName(component.getFactory());
                             container.registerComponentImplementation(cmpClass, controller, component.getAlias());
                         } catch (ClassNotFoundException e1) {
                             log.error(CONTROLLER + component.getFactory() + CLASS_NOT_FOUND);
                         } catch (ContainerException e2) {
                             // TODO Implement catch (ContainerException e2)
                             e2.printStackTrace();
                         }
                     // look for an alias
                     } else if (component.getAlias() != null && !component.getAlias().equals("")) {
                         container.registerComponentImplementation(cmpClass, component.getAlias());
                     // look for factory
                     } else if (component.getFactory() != null && !component.getFactory().equals("")) {
                         Class controller = null;
                         try {
                             controller = Class.forName(component.getFactory());
                             container.registerComponentImplementation(cmpClass, controller);
                         } catch (ClassNotFoundException e1) {
                             log.error(CONTROLLER + component.getFactory() + CLASS_NOT_FOUND);
                         } catch (ContainerException ex) {
                             ex.printStackTrace();
                         }
                     // register under classname    
                     } else {
                         container.registerComponentImplementation(cmpClass);
                     }
                 }
 
             } // end loadOnStartup
             // Register any RMI facade
             if (component.getRmiClassname() != null) {
                 
             }
         }
     }
 }