/*
    * Redistribution and use of this software and associated documentation
    * ("Software"), with or without modification, are permitted provided
    * that the following conditions are met:
    *
    * 1. Redistributions of source code must retain copyright
    *    statements and notices.  Redistributions must also contain a
    *    copy of this document.
    *
   * 2. Redistributions in binary form must reproduce the
   *    above copyright notice, this list of conditions and the
   *    following disclaimer in the documentation and/or other
   *    materials provided with the distribution.
   *
   * 3. The name "Exolab" must not be used to endorse or promote
   *    products derived from this Software without prior written
   *    permission of Intalio, Inc.  For written permission,
   *    please contact info@exolab.org.
   *
   * 4. Products derived from this Software may not be called "Exolab"
   *    nor may "Exolab" appear in their names without prior written
   *    permission of Intalio, Inc. Exolab is a registered
   *    trademark of Intalio, Inc.
   *
   * 5. Due credit should be given to the Exolab Project
   *    (http://www.exolab.org/).
   *
   * THIS SOFTWARE IS PROVIDED BY INTALIO, INC. AND CONTRIBUTORS
   * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
   * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
   * INTALIO, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
   * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * Copyright 2002 (C) Intalio Inc. All Rights Reserved.
   *
   * $Id$
   */
  package org.exolab.castor.builder.binding;
  
  //--Castor imports
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Hashtable;
  import java.util.Map;
  import java.util.Set;
  
  import org.exolab.castor.builder.binding.xml.AutomaticNamingType;
  import org.exolab.castor.builder.binding.xml.Binding;
  import org.exolab.castor.builder.binding.xml.ComponentBindingType;
  import org.exolab.castor.builder.binding.xml.Exclude;
  import org.exolab.castor.builder.binding.xml.Excludes;
  import org.exolab.castor.builder.binding.xml.Forces;
  import org.exolab.castor.xml.schema.Annotated;
  import org.exolab.castor.xml.schema.AttributeDecl;
  import org.exolab.castor.xml.schema.ElementDecl;
  import org.exolab.castor.xml.schema.Structure;
  
  /**
   * This class adds the necessary logic to a Binding Object to bring the gap
   * between the XML Schema Object Model and the Binding File. It queries the
   * Binding Object to retrieve the the associated ComponentBinding.
   * <p>
   * An "XPath like" representation of an XML Schema structure is built to lookup
   * the component bindings in their storage structure. The algorithm used to
   * build the "XPath like" representation is summarized in the following example:
   * Given the XML schema declaration:
   *
   * <pre>
   *        &lt;xsd:element name=&quot;foo&quot;&gt;
   *            &lt;xsd:complextype&gt;
   *                &lt;xsd:attribute name=&quot;bar&quot; type=&quot;xsd:string&quot;/&gt;
   *            &lt;/xsd:complextype&gt;
   *        &lt;/xsd:element&gt;
   * </pre>
   *
   * The path to identify the attribute 'bar' will be:
   *
   * <pre>
   *        /foo/@bar
   * </pre>
   *
   * The keywords <tt>complexType</tt> and <tt>group</tt> are used to identify
   * respectively an XML Schema ComplexType and a Model Group <b>definition</b>.
   *
   * @author <a href="mailto:blandin@intalio.com">Arnaud Blandin</a>
   * @version $Revision$ $Date: 2005-03-05 06:42:06 -0700 (Sat, 05 Mar 2005) $
   */
  public final class ExtendedBinding extends Binding {
  
      /**
       * Constants needed to create the XPath.
       */
     protected static final String PATH_SEPARATOR   = "/";
     /**
      * Prefix used to identify an attribute.
      */
     protected static final String ATTRIBUTE_PREFIX = "@";
     /**
      * Prefix used to identify a complexType.
      */
     public static final String COMPLEXTYPE_ID = "complexType:";
     /**
      * Prefix used to identity a simplyType.
      */
     public static final String SIMPLETYPE_ID = "simpleType:";
     /**
      * Prefix used to identify an enumeration.
      */
     public static final String ENUMTYPE_ID = "enumType:";
     /**
      * Prefix used to identify a model group.
      */
     public static final String GROUP_ID = "group:";
 
     private static final short ATTRIBUTE   = 10;
     private static final short ELEMENT     = 11;
     private static final short COMPLEXTYPE = 12;
     private static final short GROUP       = 13;
     private static final short ENUM_TYPE   = 14;
     private static final short SIMPLETYPE = 15;
 
     /**
      * The hashtables that contain the different componentBindings.
      */
     private Hashtable<String, ComponentBindingType> _componentBindings;
 
     /**
      * A flag that indicates if the component bindings of that Binding have been
      * processed.
      */
     private boolean _bindingProcessed = false;
     
     /**
      * Maintains a list of element names where automatic name conflict resolution should be 
      * used all times, incl. the first one.
      */
     private Set<String> _automaticNameResolutionForced = new HashSet<String>();
     
     /**
      * Maintains a map of exclusions from the automatic name conflict.  
      */
    private Map<String, Exclude> _automaticNameResolutionExcludes = new HashMap<String, Exclude>();
 
     /**
      * Default constructor.
      * @see java.lang.Object#Object()
      */
     public ExtendedBinding() {
         super();
         _componentBindings = new Hashtable<String, ComponentBindingType>();
     }
 
     /**
      * Returns the ComponentBinding that corresponds to the given Annotated XML
      * Schema structure An Schema location will be built for the given Annotated
      * XML schema structure.
      *
      * @param annotated the XML Schema annotated structure for which to query
      *        the Binding object for a ComponentBinding.
      *
      * @return the ComponentBinding that corresponds to the given Annotated XML
      *         Schema structure.
      */
     public ComponentBindingType getComponentBindingType(final Annotated annotated) {
         if (annotated == null) {
             return null;
         }
 
         //--no binding can be defined for a GROUP
         if (annotated.getStructureType() == Structure.GROUP) {
            return null;
         }
 
         if (!_bindingProcessed) {
             processBindingComponents();
         }
 
         String xPath = XPathHelper.getSchemaLocation(annotated);
         ComponentBindingType result = lookupComponentBindingType(xPath);
         if (result == null) {
             //--handle reference
             switch (annotated.getStructureType()) {
 
                 case Structure.ELEMENT :
                     //--handle reference: if the element referred a
                     //--global element then we use the global binding
                     if (result == null) {
                         ElementDecl element = (ElementDecl) annotated;
                         if (element.isReference()) {
                             xPath = XPathHelper.getSchemaLocation(element.getReference());
                             result = lookupComponentBindingType(xPath);
                         }
                         //--discard the element
                         element = null;
                     }
                     break;
 
                 case Structure.ATTRIBUTE :
                     if (result == null) {
                         //--handle reference: if the element referred a
                         //--global element then we use the global binding
                         AttributeDecl attribute = (AttributeDecl) annotated;
                         if (attribute.isReference()) {
                             xPath = XPathHelper.getSchemaLocation(attribute.getReference());
                             result = lookupComponentBindingType(xPath);
                         }
                         attribute = null;
                     }
                     break;
 
                 default :
                     break;
             }
         } //--result == null
 
         return result;
     }
 
     /**
      * Returns the ComponentBindingType that corresponds to the given Schema
      * location XPath. This is a direct lookup in the hashtable, null is
      * returned if no ComponentBindingType corresponds to the given Schema
      * Location XPath.
      *
      * @param xPath the schema location xpath
      * @return The ComponentBindingType that correspond to the given Schema
      *         Location XPath, Null is returned when no ComponentBindingType is
      *         found.
      * @see org.exolab.castor.builder.binding.XPathHelper#getSchemaLocation(Structure)
      */
     private ComponentBindingType lookupComponentBindingType(final String xPath) {
         if (xPath == null) {
             return null;
         }
         ComponentBindingType componentBinding = 
             _componentBindings.get(xPath);
         
         // if no component binding has been found, retry with xpath without namespaces
         // this is to ensure backwards compatibility
         if (componentBinding == null) {
             int occurence = xPath.indexOf('{');
             String xPathNoNamespaces = xPath;
             if (occurence > 0) {
                 while (occurence > 0) {
                     String xPathOld = xPathNoNamespaces;
                     xPathNoNamespaces = xPathOld.substring(0, occurence);
                     int closingOccurence = xPathOld.indexOf('}');
                     xPathNoNamespaces += xPathOld.substring(closingOccurence + 1);
                     occurence = xPathNoNamespaces.indexOf('{');
                 }
                 componentBinding = lookupComponentBindingType(xPathNoNamespaces);
             }
         }
         return componentBinding;
     }
 
     /**
      * Process the top-level Binding Component definitions and their children.
      * Processing a binding component is a 2-step process:
      * <ul>
      *    <li>Create a key for the component for direct lookup.</li>
      *    <li>Process its children</li>
      * </ul>
      */
     private void processBindingComponents() {
         ComponentBindingType temp;
         ComponentBindingType[] tempBindings = getAttributeBinding();
 
         //1--attributes
         for (int i = 0; i < tempBindings.length; i++) {
             temp = tempBindings[i];
             //--top-level attribute --> no location computation
             handleComponent(temp, null, ATTRIBUTE);
         }
 
         //2--complexTypes
         tempBindings = getComplexTypeBinding();
         for (int i = 0; i < tempBindings.length; i++) {
             temp = tempBindings[i];
             handleComponent(temp, null, COMPLEXTYPE);
         }
 
         //3--elements
         tempBindings = getElementBinding();
         for (int i = 0; i < tempBindings.length; i++) {
             temp = tempBindings[i];
             handleComponent(temp, null, ELEMENT);
         }
 
         //4--groups
         tempBindings = getGroupBinding();
         for (int i = 0; i < tempBindings.length; i++) {
             temp = tempBindings[i];
             handleComponent(temp, null, GROUP);
         }
 
         //5--enums
         tempBindings = getEnumBinding();
         for (int i = 0; i < tempBindings.length; i++) {
             temp = tempBindings[i];
             handleComponent(temp, null, ENUM_TYPE);
         }
 
         //6--simpleTypes
         tempBindings = getSimpleTypeBinding();
         for (int i = 0; i < tempBindings.length; i++) {
             temp = tempBindings[i];
             handleComponent(temp, null, SIMPLETYPE);
         }
 
         temp = null;
         tempBindings = null;
 
         _bindingProcessed = true;
     }
 
     /**
      * Process automatic name conflict resolution section, and memorize definitions.
      * @param type {@link AutomaticNamingType} instance
      */
     void handleAutomaticNaming(final AutomaticNamingType type) {
         Forces forcesOuter = type.getForces();
         if (forcesOuter != null) {
             String[] forces = forcesOuter.getForce();
             for (int i = 0; i < forces.length; i++) {
                 String elementName = forces[i];     
                 _automaticNameResolutionForced.add(elementName);
 
             }
         }
         
         Excludes excludesOuter = type.getExcludes();
         if (excludesOuter != null) {
             Exclude[] excludes = excludesOuter.getExclude();
             for (int i = 0; i < excludes.length; i++) {
                 Exclude exclude = excludes[i];
                 _automaticNameResolutionExcludes.put(exclude.getName(), exclude);
             }
         }
     }
 
     /**
      * Processes the given ComponentBindingType given its type.
      *
      * @param binding the ComponentBindingType for which we want to process the
      *        children.
      * @param xPath the current XPath location that points to the parent of the
      *        given ComponentBindingType.
      * @param type an integer that indicates the type of the given
      *        ComponentBindingType
      */
     private void handleComponent(
             final ComponentBindingType binding, final String xPath, final int type) {
         if (binding == null) {
             return;
         }
 
         String currentPath = xPath;
         if (currentPath == null) {
             currentPath = new String();
         }
 
         String name = binding.getName();
         boolean xpathUsed = (name.indexOf("/") != -1);
 
         switch (type) {
             case ATTRIBUTE :
                 //--handle attributes
                 if (!xpathUsed) {
                     currentPath = currentPath + PATH_SEPARATOR + ATTRIBUTE_PREFIX;
                 }
                 currentPath += name;
                 _componentBindings.put(currentPath, binding);
                 break;
 
             case SIMPLETYPE :
                 //--handle simpleType
                 if (!xpathUsed) {
                     currentPath += SIMPLETYPE_ID;
                 }
                 currentPath += name;
                 _componentBindings.put(currentPath, binding);
                 break;
 
             case ELEMENT :
                 //--handle element
                 if (!xpathUsed) {
                     currentPath += PATH_SEPARATOR;
                 }
                 currentPath += name;
                 _componentBindings.put(currentPath, binding);
                 break;
 
             case COMPLEXTYPE :
                 //--handle complexType
                 if (!xpathUsed) {
                     currentPath += COMPLEXTYPE_ID;
                 } else {
                     if (!name.substring(1, 12).equals("complexType")) {
                         currentPath += PATH_SEPARATOR + COMPLEXTYPE_ID;
                         currentPath += name.substring(1);
                     } else {
                         currentPath += name;
                     }
                 }
                 _componentBindings.put(currentPath, binding);
                 break;
 
             case ENUM_TYPE :
                 //--handle enum
                 if (!xpathUsed) {
                     currentPath += ENUMTYPE_ID;
                 }
                 currentPath += name;
                 _componentBindings.put(currentPath, binding);
                 break;
 
             case GROUP :
                 //--handle group
                 if (!xpathUsed) {
                     currentPath += GROUP_ID;
                 }
                 currentPath += name;
                 _componentBindings.put(currentPath, binding);
                 break;
 
             default :
                 //--there's a problem somewhere
                 throw new IllegalStateException("Invalid ComponentBindingType: the"
                         + " type (attribute, element, complextype or group) is unknown");
         }
 
         //--process children
         ComponentBindingType temp;
         ComponentBindingType[] tempBindings = binding.getAttributeBinding();
 
         //1--attributes
         for (int i = 0; i < tempBindings.length; i++) {
             temp = tempBindings[i];
             //--top-level attribute --> no location computation
             handleComponent(temp, currentPath, ATTRIBUTE);
         }
 
         //2--complexTypes
         tempBindings = binding.getComplexTypeBinding();
         for (int i = 0; i < tempBindings.length; i++) {
             temp = tempBindings[i];
             handleComponent(temp, currentPath, COMPLEXTYPE);
         }
 
         //X--simpleTypes
         tempBindings = binding.getSimpleTypeBinding();
         for (int i = 0; i < tempBindings.length; i++) {
             temp = tempBindings[i];
             handleComponent(temp, currentPath, SIMPLETYPE);
         }
 
         //3--elements
         tempBindings = binding.getElementBinding();
         for (int i = 0; i < tempBindings.length; i++) {
             temp = tempBindings[i];
             handleComponent(temp, currentPath, ELEMENT);
         }
 
         //4--groups
         tempBindings = binding.getGroupBinding();
         for (int i = 0; i < tempBindings.length; i++) {
             temp = tempBindings[i];
             handleComponent(temp, currentPath, GROUP);
         }
 
         //5--enums
         tempBindings = binding.getEnumBinding();
         for (int i = 0; i < tempBindings.length; i++) {
             temp = tempBindings[i];
             handleComponent(temp, currentPath, ENUM_TYPE);
         }
 
         //
         temp = null;
         tempBindings = null;
     }
     
     /**
      * Indicates whether an &lt;exclude&gt; element has been specified in a binding
      * file for the given 'local name' of an element definition.
      * @param localName 'local name' of an element definition
      * @return True if an &lt;exclude&gt; element has been specified
      */
     public boolean existsExclusion(final String localName) {
         return _automaticNameResolutionExcludes.containsKey(localName);
     }
 
     /**
      * Returns the {@link Exclude} instance for the element identified by the given local name.
      * @param localName Local name for an element (definition).
      * @return The {@link Exclude} instance.
      */
     public Exclude getExclusion(final String localName) {
         return _automaticNameResolutionExcludes.get(localName);
     }
 
     /**
      * Indicates whether an &lt;force&gt; element has been specified in a binding
      * file for the given 'local name' of an element definition.
      * @param localName 'local name' of an element definition
      * @return True if an &lt;force&gt; element has been specified
      */
     public boolean existsForce(final String localName) {
         return _automaticNameResolutionForced.contains(localName);
     }
     
     /**
      * Returns all &lt;force&gt; elements defined in the binding file.
      * @return all &lt;force&gt; elements defined in the binding file
      */
     public Set<String> getForces() {
         return _automaticNameResolutionForced;
     }
 
 }