/*
    * Copyright 2006 Werner Guttmann
    *
    * 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 org.exolab.castor.builder.conflictresolution;
  
  import java.util.Enumeration;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.exolab.castor.builder.SGStateInfo;
  import org.exolab.castor.builder.binding.XPathHelper;
  import org.exolab.castor.builder.info.ClassInfo;
  import org.exolab.castor.builder.info.nature.XMLInfoNature;
  import org.exolab.castor.util.dialog.ConsoleDialog;
  import org.exolab.castor.xml.schema.Annotated;
  import org.exolab.castor.xml.schema.ElementDecl;
  import org.exolab.castor.xml.schema.SchemaNames;
  import org.exolab.javasource.JClass;
  
  /**
   * An implementation of {@link ClassNameCRStrategy} that
   * reports any conflict notifications to a log file, basically
   * stating what classes have been overwriten as a result of such
   * a name conflict.
   *
   * @author <a href="mailto:werner DOT guttmann AT gmx DOT net">Werner Guttmann</a>
   * @since 1.1
   */
  public final class InformViaLogClassNameCRStrategy
  extends BaseClassNameCRStrategy implements ClassNameCRStrategy {
  
      /** Logger instance used for logging naming conflicts. */
      private static final Log LOG = LogFactory.getLog(InformViaLogClassNameCRStrategy.class);
      /** Name of this strategy. */
      public static final String NAME = "informViaLog";
  
      /**
       * Creates an instance of this name conflict resolution strategy, that will
       * emit warnings to the user as part of a standard logging aproach.
       */
      public InformViaLogClassNameCRStrategy() {
          // Nothing to do.
      }
  
      /**
       * Handle a class name conflict between newClassInfo and conflict.
       *
       * @param state SourceGeneration state
       * @param newClassInfo ClassInfo for the new class
       * @param conflict JClass for the existing class
       * @return the provided source generator state, as modified by the strategy
       * @see org.exolab.castor.builder.conflictresolution.ClassNameCRStrategy
       *      #dealWithClassNameConflict(org.exolab.castor.builder.SGStateInfo,
       *      org.exolab.castor.builder.info.ClassInfo,
       *      org.exolab.javasource.JClass)
       */
      public SGStateInfo dealWithClassNameConflict(final SGStateInfo state,
              final ClassInfo newClassInfo, final JClass conflict) {
          // If the ClassInfo are equal, we can just return
          ClassInfo oldClassInfo = state.resolve(conflict);
          if (oldClassInfo == newClassInfo) {
              return state;
          }
  
          // Find the Schema structures that are conflicting
          Annotated a1 = null;
          Annotated a2 = null;
  
          // Loop until we exhaust the Enumeration or until we have found both
          Enumeration enumeration = state.keys();
          while (enumeration.hasMoreElements() && (a1 == null || a2 == null)) {
              Object key = enumeration.nextElement();
              if (!(key instanceof Annotated)) {
                  continue;
              }
  
              ClassInfo cInfo = state.resolve(key);
              if (newClassInfo == cInfo) {
                  a1 = (Annotated) key;
              } else if (oldClassInfo == cInfo) {
                  a2 = (Annotated) key;
              }
          }
  
          String annotated1XPath;
          String annotated2XPath;
          
         StringBuilder message = new StringBuilder();
         message.append("Warning: A class name generation conflict has occured between ");
         
         if (a1 != null) {
             message.append(SchemaNames.getStructureName(a1));
             message.append(" '");
             if (a1 instanceof ElementDecl) {
                 ElementDecl element = (ElementDecl) a1;
                 annotated1XPath = XPathHelper.getSchemaLocation(a1) + "[/complexType:" 
                 + element.getType().getName() + "]";
                 message.append(annotated1XPath);
             } else {
                 message.append(XPathHelper.getSchemaLocation(a1));
             }
         } else {
             if (newClassInfo.hasNature(XMLInfoNature.class.getName())) {
                 XMLInfoNature xmlNature = new XMLInfoNature(newClassInfo);
                 message.append(xmlNature.getNodeTypeName());
                 message.append(" '");
                 message.append(xmlNature.getNodeName());
             }
         }
         message.append("' and ");
         if (a2 != null) {
             message.append(SchemaNames.getStructureName(a2));
             message.append(" '");
             if (a2 instanceof ElementDecl) {
                 ElementDecl element = (ElementDecl) a2;
                 annotated2XPath = XPathHelper.getSchemaLocation(a2) + "[/complexType:" 
                 + element.getType().getName() + "]";
                 message.append(annotated2XPath);
             } else {
                 message.append(XPathHelper.getSchemaLocation(a2));
             }
         } else {
             if (oldClassInfo.hasNature(XMLInfoNature.class.getName())) {
                 XMLInfoNature xmlNature = new XMLInfoNature(oldClassInfo);
                 message.append(xmlNature.getNodeTypeName());
                 message.append(" '");
                 message.append(xmlNature.getNodeName());
             }
         }
         message.append("'. Please use a Binding file to solve this problem.");
         LOG.warn(message);
         return state;
     }
 
     /**
      * Returns the name of the strategy.
      * @return the name of the strategy.
      * @see org.exolab.castor.builder.conflictresolution.ClassNameCRStrategy#getName()
      */
     public String getName() {
         return NAME;
     }
 
     /**
      * Sets the console dialog to use with this strategy.
      *
      * @param dialog the console dialog to use with this strategy.
      * @see org.exolab.castor.builder.conflictresolution.ClassNameCRStrategy#
      *      setConsoleDialog(org.exolab.castor.util.dialog.ConsoleDialog)
      */
     public void setConsoleDialog(final ConsoleDialog dialog) {
         // No console dialog needed.
     }
 
     /**
      * Presents the user with a console dialog, asking for confirmation whether
      * an existing file should be overwritten (or not).
      *
      * @param filename the filename to potentially overwrite.
      * @return whether or not the file should be overwritten.
      *
      * @see org.exolab.castor.builder.conflictresolution.ClassNameCRStrategy
      *      #dealWithFileOverwrite(java.lang.String, boolean)
      */
     public boolean dealWithFileOverwrite(final String filename) {
         LOG.warn(filename + " already exists, but will be overwritten.");
         return true;
     }
 
 }