/*
    * 
    * $Revision: 1.4 $
    * $Date: 2004/07/09 18:02:27 $
    *
    * ====================================================================
    * struts-it
    * Copyright (C) 2004 - strutsit community
    * 
   * 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.
   *
   * created: 2004-06-05  Manfred Wolff
   */
  package org.strutsit.chain.configuration;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  import org.apache.commons.chain.Catalog;
  import org.apache.commons.chain.Command;
  import org.apache.commons.chain.impl.CatalogBase;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.strutsit.chain.ChainException;
  import org.strutsit.chain.DependCommand;
  import org.strutsit.chain.interfaces.ChainConfiguration;
  
  /***
   * Base implementation of a {@link ChainConfiguration}-interface.
   * 
   * @author <a href="mailto:wolff@struts-it.de">Manfred Wolff </a>
   * @since JDK 1.4
   * @version $Revision: 1.4 $
   */
  public abstract class ChainConfigurationBase implements ChainConfiguration {
  
      /// Check if init is called.
      private boolean initHasCalled = false;
  
      /// The logger of this class
      private static transient Log log = LogFactory
              .getLog(ChainConfigurationBase.class);
  
      /// Map with all names of commands
      private List names = new ArrayList();
  
      /// Map with all classnames of commands
      private List classes = new ArrayList();
  
      /***
       * Default name of the configfile.
       */
      private String configFile = "/chain-config.xml";
  
      /***
       * @return Returns the configFile.
       */
      public final String getConfigFile() {
          return configFile;
      }
  
      /***
       * Sets the configfile.
       * 
       * @param aConfigFile The configFile to set.
       */
      public final void setConfigFile(final String aConfigFile) {
          this.configFile = aConfigFile;
      }
  
      /***
       * Checks the configuration of all chains
       * 
       * @return true if all dependencies are all right, false otherwise
       * @throws ChainException
       */
      public boolean checkConfiguration() throws ChainException {
  
          boolean check = true;
          String exError = null;
  
          if (log.isTraceEnabled()) {
              log.trace("checkConfiguration -> START");
          }
  
          if (!this.initHasCalled) {
              init();
          }
 
         CatalogBase catalog = (CatalogBase) getCatalog();
         if (catalog == null) { throw new IllegalArgumentException(
                 "Error, not catalog initialized."); }
 
         // Iterates over all names of the Catalog. That maybe commands or
         // chains.
         // Only chains with the Flag checkDependencies should be verified.
         for (Iterator it = catalog.getNames(); it.hasNext();) {
 
             String name = (String) it.next();
             Command chain = catalog.getCommand(name);
 
             // Only verify if it is a chain and the checkDependencies attribute
             // is true
             if ((chain instanceof ChainConfBase)
                     && ("true".equals(((ChainConfBase) chain)
                             .getCheckDependencies()))) {
 
                 Command commands[] = ((ChainConfBase) chain).getAllCommands();
                 names.clear();
                 classes.clear();
 
                 for (int i = 0; i < commands.length; ++i) {
 
                     Command dependCommand = commands[i];
 
                     // registers the command with name and classname
                     names.add(name);
                     classes.add(dependCommand.getClass().getName());
 
                     if (dependCommand instanceof DependCommand) {
 
                         // Registers the dependencies
                         ((DependCommand) dependCommand).doRegister();
 
                         List commandNames = ((DependCommand) dependCommand)
                                 .getNames();
                         List commandClassNames = ((DependCommand) dependCommand)
                                 .getClassNames();
 
                         // Iterates over all names, that depends to this
                         // command.
                         // This name must be in the names-List of this
                         // configuration!
                         for (Iterator it2 = commandNames.iterator(); it2
                                 .hasNext();) {
 
                             // cannot be refactored out of the iteration,
                             // because
                             // this iteration might not be attached, maybe
                             // empty.
                             check = false;
                             String commandName = (String) it2.next();
                             if (log.isInfoEnabled()) {
                                 log.info("Looking for dependency: "
                                         + commandName);
                             }
                             if (!names.contains(commandName)) {
                                 exError = new StringBuffer().append(
                                         "Failure: [").append(
                                         dependCommand.getClass().getName())
                                         .append("] Don't find [").append(
                                                 commandName).append(
                                                 "] in namelist.").toString();
                                 log.error(exError);
                                 continue;
                             } else {
                                 check = true;
                                 break;
                             }
                         }
 
                         // Iterates over all classNames, that depends to this
                         // command.
                         // This name must be in the classNames-List of this
                         // configuration!
                         for (Iterator it2 = commandClassNames.iterator(); it2
                                 .hasNext();) {
 
                             // cannot be refactored out of the iteration,
                             // because
                             // this iteration might not be attached, maybe
                             // empty.
                             check = false;
                             String commandClassName = (String) it2.next();
                             if (log.isInfoEnabled()) {
                                 log.info("Looking for dependency: "
                                         + commandClassName);
                             }
                             if (!classes.contains(commandClassName)) {
                                 exError = new StringBuffer().append(
                                         "Failure: [").append(
                                         dependCommand.getClass().getName())
                                         .append("] Don't find [").append(
                                                 commandClassName).append(
                                                 "] in classnamelist.")
                                         .toString();
                                 ;
                                 log.error(exError);
                                 continue;
                             } else {
                                 check = true;
                                 break;
                             }
                         }
                     }
                 }
                 if (check == false) { throw new ChainException(exError); }
             }
         }
 
         if (log.isTraceEnabled()) {
             log.trace("checkConfiguration -> END");
         }
 
         return check;
 
     }
 
     /***
      * Inits the configuration.
      * 
      * @throws ChainException if something goes wrong
      */
     public void init() throws ChainException {
 
         // creates a PropertyReader object
         PropertyReader reader = PropertyReader.getInstance();
         setConfigFile(reader.getConfName());
         initHasCalled = true;
     }
 
     /***
      * Rereads the configuration.
      */
     public void reread() {
 
     }
 
     /***
      * @return Returns the catalog.
      */
     public abstract Catalog getCatalog();
 
 }