/**
    * 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 2004 (C) Intalio Inc. All Rights Reserved.
   *
   * $Id$
   */
  package org.exolab.castor.xml.schema;
  
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Hashtable;
  import java.util.Map;
  
  import org.exolab.castor.xml.ValidationException;
  
  /**
   * <p>This class is a wrapper used to save meta information concerning redefined
   * structures from an XML schema.</p>
   *  
   * <p>This wrapper is identified by:
   * <ul>
   *     <li>a reference to the schema redefined</li>
   *     <li>the schema location of the redefined schema</li>
   *     <li>A vector containing the names of the structures redefined</li>
   * </ul>
   * 
   * @author <a href="mailto:blandin@intalio.com">Arnaud Blandin</a>
   * @version $Revision$ $Date: 2006-04-13 06:47:36 -0600 (Thu, 13 Apr 2006) $
   **/
  public class RedefineSchema extends Annotated {
      /** SerialVersionUID */
      private static final long serialVersionUID = -7095458840388436859L;
  
      /**
  	 * The original schema that is imported in the 
  	 * parent schema
  	 */
  	private Schema _originalSchema;
  	
  	/**
  	 * The parent schema in which this redefined XML Schema
  	 * is used.
  	 */
  	private Schema _parentSchema;
  	
  	/**
  	 * The schema location of the redefined schema
  	 */
  	private String _schemaLocation = null;
  	
  	/**
  	 * A vector with the names of the redefined complexTypes
  	 */
  	private Map<String, ComplexType> _complexTypes;
  	
  	/**
  	 * A vector with the names of the redefined simpleTypes
  	 */
  	private Map<String, SimpleType> _simpleTypes;
  	
  	/**
 	 * A vector with the names of the redefined groups
 	 */
 	private Map<String, ModelGroup> _groups;
 	
 	/**
 	 * A vector with the names of the redefined attributeGroups
 	 */
 	private Map<String, AttributeGroup> _attributeGroups;
 	
 	/**
 	 * Default constructor to create a RedefineSchema
 	 * that contains only Annotations
 	 * 
 	 */
 	public RedefineSchema(Schema parentSchema) {
 		super();
 		_parentSchema = parentSchema;
 		_schemaLocation = "";
 	}
 	
 	/**
 	 * Constructs a new RedefineSchema structure
 	 */
 	public RedefineSchema(Schema parentSchema, Schema originalSchema) {
 		super();
 		_schemaLocation = originalSchema.getSchemaLocation();
 		_parentSchema = parentSchema;
 		_originalSchema= originalSchema;
 		_complexTypes = new Hashtable<String, ComplexType>();
 		_simpleTypes = new Hashtable<String, SimpleType>();
 		_attributeGroups = new Hashtable<String, AttributeGroup>();
 		_groups = new Hashtable<String, ModelGroup>();
 	}
 	
 	/**
 	 * Adds the given complexType in the list of redefined complexTypes.
 	 * @param complexType the ComplexType to add.
 	 */
 	public void addComplexType(ComplexType complexType) throws SchemaException {
 	    if (_schemaLocation.length() == 0)
 	    	throw new IllegalStateException("A RedefineSchema with no schemaLocation must contain only annotations");
 	    String name = complexType.getName();
 
 	    if (name == null) {
 	    	String err = "a global ComplexType must contain a name.";
 	    	throw new SchemaException(err);
 	    }
 	    
 	    if (complexType.getSchema() != _parentSchema) {
 	    	String err = "invalid attempt to add an ComplexType which ";
 	    	err += "belongs to a different Schema; type name: " + name;
 	    	throw new SchemaException(err);
 	    }
 	    
 	    if (getComplexType(name) != null ) {
 	    	String err = "In the RedefineSchema:"+_schemaLocation+"a ComplexType already exists with the given name: ";
 	    	throw new SchemaException(err + name);
 	    }
 	    
 	    //--forces the redefine character
 	    complexType.setRedefined();
 	    
 	    _complexTypes.put(name, complexType);
 	    complexType.setParent(_parentSchema);
 	}
 	
 	/**
 	 * Enumerates the complexType names.
 	 * @return an enumeration of the names of the redefined ComplexTypes
 	 */
 	public Collection<ComplexType> enumerateComplexTypes() {
 		if (_schemaLocation.length() == 0) {
             return Collections.emptyList();
         }
 		return _complexTypes.values();
 	}
 	
 	/**
 	 * Returns the ComplexType corresponding to the given name.
 	 * 
 	 * @param name the name of the ComplexType to look for.
 	 * @return the ComplexType corresponding to the gven name.
 	 */
 	public ComplexType getComplexType(String name) {
 		if (_schemaLocation.length() == 0) {
             return null;
         }
 		
 		return _complexTypes.get(name);
 	}
 	
 	/**
 	 * Returns true if this redefinition contains a redefinition for a complexType with 
 	 * the given name.
 	 * 
 	 * @param name the canonical name of the complexType.
 	 */
 	public boolean hasComplexTypeRedefinition(String name) {
 		if (_schemaLocation.length() == 0)
 			return false;
 		
 		return (_complexTypes.containsKey(name));
 	}
 	
 	/**
 	 * Removes the complexType with the given name from the redefine structure.
 	 * 
 	 * @param complexType The complexType to be removed from this Redefined Structure.
 	 */
 	public boolean removeComplexType(ComplexType complexType) {
 		if (_schemaLocation.length() == 0)
 			return false;
 		
 		boolean result = false;
 		if (_complexTypes.containsValue(complexType)) {
 			_complexTypes.remove(complexType);
 			result = true;
 		}
 		return result;
 	}
 
 	/**
 	 * Adds a simpleType in the list of redefined simpleTypes.
 	 * 
 	 * @param simpleType the SimpleType to add.
 	 */
 	public void addSimpleType(SimpleType simpleType) throws SchemaException {
 		
 		String name = simpleType.getName();
 		if (name == null)
 			throw new IllegalArgumentException("A redefined simpleType must have a name");
 		if (_schemaLocation.length() == 0)
 			throw new IllegalStateException("A RedefineSchema with no schemaLocation must contain only annotations");
 
 		if (simpleType.getSchema() != _parentSchema) {
 			String err = "invalid attempt to add a SimpleType which ";
 			err += "belongs to a different Schema; type name: " + name;
 			throw new SchemaException(err);
 		}
 		
 		if (getSimpleType(name) != null) {
 			String err = "In the RedefineSchema:"+_schemaLocation+"a SimpleType already exists with the given name: ";
 			throw new SchemaException(err + name);
 		}
         //--forces the redefine character
 		simpleType.setRedefined();
 		
 		simpleType.setParent(this);
 		_simpleTypes.put(name, simpleType);
 	}
 	
 	/**
 	 * Enumerates the simpleType names.
 	 * @return an enumeration of the names of the redefined SimpleTypes.
 	 */
 	public Collection<SimpleType> enumerateSimpleTypes() {
 		if (_schemaLocation.length() == 0) {
             return Collections.emptyList();
         }
 		
 		return _simpleTypes.values();
 	}
 	
 	/**
 	 * Returns the SimpleType corresponding to the given name.
 	 * 
 	 * @param name the name of the SimpleType to look for.
 	 * @return the SimpleType corresponding to the gven name.
 	 */
 	public SimpleType getSimpleType(String name) {
 		if (_schemaLocation.length() == 0) {
             return null;
         }
 		
 		return _simpleTypes.get(name);
 	}
 	
 	/**
 	 * Returns true if this redefinition contains a redefinition for a simpleType with 
 	 * the given name.
 	 * 
 	 * @param name the canonical name of the simpleType.
 	 */
 	public boolean hasSimpleTypeRedefinition(String name) {
 		if (_schemaLocation.length() == 0) {
             return false;
         }
 		
 		return (_simpleTypes.containsKey(name));
 	}
 	
 	/**
 	 * Removes the given simpleType from the redefine structure.
 	 * 
 	 * @param simpleType the simpleType to be removed from this Redefined Structure.
 	 */
 	public boolean removeSimpleType(SimpleType simpleType) {
 		if (_schemaLocation.length() == 0)
 			return false;
 		
 		boolean result = false;
 		if (_simpleTypes.containsValue(simpleType)) {
 			_simpleTypes.remove(simpleType);
 			result = true;
 		}
 		return result;
 	}
 
 	/**
 	 * Adds a group name in the list of redefined groups.
 	 */
 	public void addGroup(ModelGroup group) throws SchemaException {
 		if (_schemaLocation.length() == 0) {
             throw new IllegalStateException("A RedefineSchema with no schemaLocation must contain only annotations");
         }
 		
 		String name = group.getName();
 
 		if (name == null) {
 			String err = "a group declaration must contain a name.";
 			throw new SchemaException(err);
 		}
 		
 		if (getModelGroup(name) != null) {
 			String err = "In the RedefineSchema:"+ _schemaLocation+" a group declaration already exists with the given name: ";
 			throw new SchemaException(err + name);
 		}
         //--forces the redefine character
 		group.setRedefined();
 		group.setParent(_parentSchema);
 		
 		_groups.put(name, group);
 	}
 	
 	/**
 	 * Returns the Model Group of the given name that is contained in this RedefineSchema.
 	 * 
 	 * @param name the name of the ModelGroup to retrieve.
 	 * @return the ModelGroup of the given name contained in this RedefineSchema.
 	 */
 	public ModelGroup getModelGroup(String name) {
 		if (_schemaLocation.length() == 0) {
             return null;
         }
 		
 		return _groups.get(name);
 	}
 	
 	/**
 	 * Enumerates the group names.
 	 * @return an enumeration of the names of the redefined groups.
 	 */
 	public Collection<ModelGroup> enumerateGroups() {
 		if (_schemaLocation.length() == 0) {
             return Collections.emptyList();
         }
 		
 		return _groups.values();
 	}
 	
 	/**
 	 * Returns true if this redefinition contains a redefinition for a group with 
 	 * the given name.
 	 * 
 	 * @param name the canonical name of the complexType.
 	 */
 	public boolean hasGroupRedefinition(String name) {
 		if (_schemaLocation.length() == 0)
 			return false;
 		
 		return (_groups.containsKey(name));
 	}
 	
 	/**
 	 * Removes the given ModelGroup from the redefine structure.
 	 * 
 	 * @param group the ModelGroup to be removed from this Redefined Structure.
 	 */
 	public boolean removeGroup(ModelGroup group) {
 		if (_schemaLocation.length() == 0)
 			return false;
 		
 		boolean result = false;
 		if (_groups.containsValue(group)) {
 		    _groups.remove(group);
 		    result = true;
 		}
 		return result;
 	}
 	
 	/**
 	 * Adds a AttributeGroup name in the list of redefined attributeGroups.
 	 */
 	public void addAttributeGroup(AttributeGroupDecl attrGroup) throws SchemaException {
 		if (_schemaLocation.length() == 0)
 			throw new IllegalStateException("A RedefineSchema with no schemaLocation must contain only annotations");
 		
 		if (attrGroup == null) return;
 
 		String name = attrGroup.getName();
 
 		//-- handle namespace prefix, if necessary
 		int idx = name.indexOf(':');
 		if (idx >= 0)
 		{
 			String nsPrefix = name.substring(0,idx);
 			name = name.substring(idx + 1);
 			String ns = _parentSchema.getNamespace(nsPrefix);
 			if (ns == null)  {
 				String err = "addAttributeGroup: ";
 				err += "Namespace prefix not recognized '"+nsPrefix+"'";
 				throw new IllegalArgumentException(err);
 			}
 			if (!ns.equals(_parentSchema.getTargetNamespace())) {
 				String err = "AttributeGroup has different namespace " +
 				"than this Schema definition.";
 				throw new IllegalArgumentException(err);
 			}
 		}
 
 		if (attrGroup.getSchema() != _parentSchema) {
 			String err = "invalid attempt to add an AttributeGroup which ";
 			err += "belongs to a different Schema; " + name;
 			throw new SchemaException(err);
 		}
 		
 		attrGroup.setRedefined();
 		
 		_attributeGroups.put(name, attrGroup);
 	}
 	
 	/**
 	 * Returns the AttributeGroup corresponding to the given 
 	 * canonical name (unqualified name).
 	 * 
 	 * @return the AttributeGroup corresponding to the given 
 	 * canonical name (unqualified name).
 	 */
 	public AttributeGroupDecl getAttributeGroup(String name) {
 		if (_schemaLocation.length() == 0)
 			return null;
 		
 		return (AttributeGroupDecl)_attributeGroups.get(name);
 	}
 	
 	/**
 	 * Enumerates the attributeGroup names.
 	 * @return an enumeration of the names of the redefined AttributeGroups.
 	 */
 	public Collection<AttributeGroup> enumerateAttributeGroups() {
 		if (_schemaLocation.length() == 0) {
             return Collections.emptyList();
         }
 		
 		return _attributeGroups.values();
 	}
 		
 	/**
 	 * Returns true if this redefinition contains a redefinition for an AttributeGroup with 
 	 * the given name.
 	 * 
 	 * @param name the canonical name of the complexType.
 	 */
 	public boolean hasAttributeGroupRedefinition(String name) {
 		if (_schemaLocation.length() == 0)
 			return false;
 		
 		return (_attributeGroups.containsKey(name));
 	}
 	
 	/**
 	 * Removes the attributeGroup with the given name from the redefine structure.
 	 * 
 	 * @param attrGroup the attributeGroup to be removed from this Redefined Structure.
 	 */
 	public boolean removeAttributeGroup(AttributeGroupDecl attrGroup) {
 		if (_schemaLocation.length() == 0)
 			return false;
 		
 		boolean result = false;
 		if (_attributeGroups.containsValue(attrGroup)) {
 		    _attributeGroups.remove(attrGroup);
 		    result = true;
 		}
 		return result;
 	}
 	
 	/**
 	 * Returns true if at least one structure other than
 	 * an annotation is present.
 	 * 
 	 * @return  true if at least one structure other than
 	 * an annotation is present.
 	 */
 	public boolean hasRedefinition() {
 		if (_schemaLocation.length() == 0)
 			return false;
 		
 		return (!_complexTypes.isEmpty()) || (!_simpleTypes.isEmpty()) || (!_groups.isEmpty()) || (!_attributeGroups.isEmpty());
 	}
 	
 	/**
 	 * Returns the URI of the imported schema.
 	 * 
 	 * @return the URI of the imported schema.
 	 */
 	public String getSchemaLocation() {
 		return _schemaLocation;
 	}
 	
 	/**
 	 * Returns the schema imported used for the redefinitions.
 	 * @return the original schema imported.
 	 */
 	public Schema getOriginalSchema() {
 		return _originalSchema;
 	}
 	
 	/**
 	 * Returns the parent schema in which this RedefineSchema is used.
 	 * 
 	 * @return the parent schema in which this Redefined Schema 
 	 * is used.
 	 */
 	public Schema getParentSchema(){
 		return _parentSchema;
 	}
 	
 	/**
 	 * Returns the type of this Redefine Structure
 	 * @return the type of this Redefin Structure
 	 **/
 	public short getStructureType() {
 		return Structure.REDEFINE;
 	} //-- getStructureType
 	
 	
 	public void validate() throws ValidationException {
 		//-- no validation performed on the structure since
 		//-- it is simply a place holder for names and not for real structures.
 	}
 	
 }