/*******************************************************************************
 * Copyright (c) 2001, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.xsd.ui.internal.refactor.delete;

import java.text.MessageFormat;
import java.util.Iterator;

import org.eclipse.xsd.XSDAttributeDeclaration;
import org.eclipse.xsd.XSDAttributeGroupContent;
import org.eclipse.xsd.XSDAttributeGroupDefinition;
import org.eclipse.xsd.XSDAttributeUse;
import org.eclipse.xsd.XSDComplexTypeDefinition;
import org.eclipse.xsd.XSDConcreteComponent;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDModelGroupDefinition;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDSchemaContent;
import org.eclipse.xsd.XSDSchemaDirective;
import org.eclipse.xsd.XSDSimpleTypeDefinition;
import org.eclipse.xsd.XSDTypeDefinition;
import org.eclipse.xsd.util.XSDConstants;
import org.w3c.dom.Element;

public class XSDExternalFileCleanup extends BaseCleanup
{
  /**
   * Constructor for XSDExternalFileCleanup.
   */
  public XSDExternalFileCleanup(String oldFilename)
  {
    super();
    this.oldFilename = oldFilename;
  }
  
  protected XSDSchema deletedSchema;
  public XSDExternalFileCleanup(XSDSchema deletedSchema)
  {
    this.deletedSchema = deletedSchema;
  }

  protected String oldFilename;
  
  /**
   * @see org.eclipse.wst.xsd.ui.internal.refactor.XSDVisitor#visitElementDeclaration(XSDElementDeclaration)
   */
  public void visitElementDeclaration(XSDElementDeclaration element)
  {
    boolean addMessage = true;
    String schemaLocation = element.getSchema().getSchemaLocation();
    if (schemaLocation!= null)
    {
      if (!schemaLocation.equals(schema.getSchemaLocation()))
      {
        addMessage = false;
      }
    }
    if (element.isElementDeclarationReference())
    {
      if (isFromDeletedSchema(element.getResolvedElementDeclaration()))
      {
        if (addMessage)
        {
          // String msg = XSDPlugin.getSchemaString("_INFO_REMOVE_ELEMENT_REFERENCE") + " <" + getNamedComponentName(element.getContainer()) + ">";
					String msg = "_INFO_REMOVE_ELEMENT_REFERENCE" + " <" + getNamedComponentName(element.getContainer()) + ">";
          addMessage(msg, element.getContainer());
        }
        childrenToRemove.add(element.getElement());
//        Element domElement = element.getElement();
//        domElement.getParentNode().removeChild(domElement);     
      }
    }
    else if (removeType(element))
    {
      String msg = "";
      if (element.isGlobal())
      {
      	// String pattern = XSDPlugin.getSchemaString("_INFO_RESET_GLOBAL_ELEMENT");
				String pattern = "_INFO_RESET_GLOBAL_ELEMENT";
        Object args[] = {element.getName()};
        msg = MessageFormat.format(pattern, args);
      }
      else
      {
      	// msg = XSDPlugin.getSchemaString("_INFO_RESET_ELEMENT");
				msg = "_INFO_RESET_ELEMENT";
      	// msg += "<" + element.getName() + "> " + XSDPlugin.getSchemaString("_UI_TO_TYPE_STRING");
				msg += "<" + element.getName() + "> " + "_UI_TO_TYPE_STRING";
      }
      if (addMessage)
      {
        addMessage(msg, element);
      }
    }


    super.visitElementDeclaration(element);
  }

  protected void resetTypeToString(Element element)
  {
    String prefix = element.getPrefix();
    prefix = (prefix == null) ? "" : (prefix + ":");
    
    element.setAttribute(XSDConstants.TYPE_ATTRIBUTE, prefix + "string"); 
  }
  
  protected boolean removeType(XSDElementDeclaration element)
  {
  	if (removeType(element.getTypeDefinition()))
  	{
      resetTypeToString(element.getElement());
  	  return true;
  	}
  	return false;
  }
  
  protected boolean isFromDeletedSchema(XSDConcreteComponent component)
  {
    if (component == null)
    {
      return false;
    }
    XSDConcreteComponent root = component.getRootContainer();

    boolean isFromDeletedSchema = false;
    if (deletedSchema.getContents() != null)
    {
      Iterator contents = deletedSchema.getContents().iterator();
      while (contents.hasNext())
      {
        XSDSchemaContent content = (XSDSchemaContent)contents.next();
        if (content instanceof XSDSchemaDirective)
        {
          XSDSchema aSchema = ((XSDSchemaDirective)content).getResolvedSchema();
          if (root != null && root.equals(aSchema))
          {
            isFromDeletedSchema = true;
          }
        }
      }
    }
    if (root != null && root.equals(deletedSchema))
    {
      isFromDeletedSchema = true;
    }
    return isFromDeletedSchema;
  }
      
  /**
   * Remove the type from the element if it belongs to the external file
   */
  protected boolean removeType(XSDTypeDefinition typeDef)
  {
    if (typeDef == null)
    {
      return false;
    }
    return isFromDeletedSchema(typeDef);
  }

  /**
   * @see org.eclipse.wst.xsd.utility.XSDVisitor#visitComplexTypeDefinition(XSDComplexTypeDefinition)
   */
  public void visitComplexTypeDefinition(XSDComplexTypeDefinition type)
  {
    super.visitComplexTypeDefinition(type);
    if (type.getAttributeContents() != null)
    {
      for (Iterator iter = type.getAttributeContents().iterator(); iter.hasNext(); )
      {
        XSDAttributeGroupContent attrGroupContent = (XSDAttributeGroupContent) iter.next();
        if (attrGroupContent instanceof XSDAttributeUse)
        {
          XSDAttributeUse attrUse = (XSDAttributeUse) attrGroupContent;
          XSDAttributeDeclaration attrDecl = attrUse.getContent();
          
          // now is this a reference?
          if (attrDecl.isAttributeDeclarationReference())
          {
            if (isFromDeletedSchema(attrDecl.getResolvedAttributeDeclaration()))
            {
              String name = getNamedComponentName(type);
              // String msg = XSDPlugin.getSchemaString("_INFO_REMOVE_ATTRIBUTE_REFERENCE") +
							String msg = "_INFO_REMOVE_ATTRIBUTE_REFERENCE" +
                       " <" + name + ">";
              addMessage(msg, attrDecl.getContainer());
              
              childrenToRemove.add(attrDecl.getElement());
            }
          }
          // otherwise check the type of the attribute and see if it is from the deleted schema
          else
          {
            if (removeType(attrDecl.getTypeDefinition()))
            {
              // reset the type of the attribute decl to string
              // String msg = XSDPlugin.getSchemaString("_INFO_RESET_ATTRIBUTE") +
							String msg = "_INFO_RESET_ATTRIBUTE" +
                          " <" + attrDecl.getName() + "> " +
                          // XSDPlugin.getSchemaString("_UI_TO_TYPE_STRING");
							            "_UI_TO_TYPE_STRING";
              addMessage(msg, attrDecl);
              resetTypeToString(attrDecl.getElement());

            }
          }
        }
        else if (attrGroupContent instanceof XSDAttributeGroupDefinition)
        {
          XSDAttributeGroupDefinition attrGroupDef = (XSDAttributeGroupDefinition) attrGroupContent;
          
          if (isFromDeletedSchema(attrGroupDef.getResolvedAttributeGroupDefinition()))
          {
          	// remove the attribute group reference
            String name = getNamedComponentName(type);
            // String msg = XSDPlugin.getSchemaString("_INFO_REMOVE_ATTRIBUTE_GROUP_REFERENCE") + " <" + name + ">";
						String msg = "_INFO_REMOVE_ATTRIBUTE_GROUP_REFERENCE" + " <" + name + ">";

            addMessage(msg, attrGroupDef.getContainer());
            
            childrenToRemove.add(attrGroupDef.getElement());
          }
        }
      }
    }

    // For the complex type with simple content case, see the visitComplexTypeDefinition method
    XSDTypeDefinition base = type.getBaseTypeDefinition();
    if (base instanceof XSDSimpleTypeDefinition)
    {
      XSDSimpleTypeDefinition baseType = (XSDSimpleTypeDefinition)base;
      if (isFromDeletedSchema(baseType))
      {
        // String msg = XSDPlugin.getSchemaString("_INFO_RESET_COMPLEX_TYPE") +
				String msg = "_INFO_RESET_COMPLEX_TYPE" +
                " <" + getNamedComponentName(type) + "> " +
                // XSDPlugin.getSchemaString("_UI_DERIVATION");
				        "_UI_DERIVATION";
        addMessage(msg, type);
      
        type.setBaseTypeDefinition(schema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
      }
    }
  }

  /**
   * @see org.eclipse.wst.xsd.utility.XSDVisitor#visitModelGroupDefinition(XSDModelGroupDefinition)
   */
  public void visitModelGroupDefinition(XSDModelGroupDefinition modelGroup)
  {
    super.visitModelGroupDefinition(modelGroup);
    if (modelGroup.isModelGroupDefinitionReference())
    {
      if (isFromDeletedSchema(modelGroup.getResolvedModelGroupDefinition()))
      {
        String name = getNamedComponentName(modelGroup);
        // String msg = XSDPlugin.getSchemaString("_INFO_REMOVE_GROUP_REFERENCE") + " <" + name + ">";
				String msg = "_INFO_REMOVE_GROUP_REFERENCE" + " <" + name + ">";
        addMessage(msg, modelGroup.getContainer());
        childrenToRemove.add(modelGroup.getElement());
      }
    }      
  }

  /**
   * @see org.eclipse.wst.xsd.utility.XSDVisitor#visitSimpleTypeDefinition(XSDSimpleTypeDefinition)
   */
  public void visitSimpleTypeDefinition(XSDSimpleTypeDefinition type)
  {
    super.visitSimpleTypeDefinition(type);
    XSDSimpleTypeDefinition baseType = type.getBaseTypeDefinition();
    if (isFromDeletedSchema(baseType))
    {
      // String msg = XSDPlugin.getSchemaString("_INFO_RESET_SIMPLE_TYPE") +
			String msg = "_INFO_RESET_SIMPLE_TYPE" +
              " <" + getNamedComponentName(type) + "> " +
              // XSDPlugin.getSchemaString("_UI_DERIVATION");
			        "_UI_DERIVATION";
      addMessage(msg, type);
      

    // This will set the simple Type base to string 
    // For the complex type with simple content case, see the visitComplexTypeDefinition method

      type.getFacetContents().clear();
      type.getFacets().clear();
      type.setBaseTypeDefinition(schema.getSchemaForSchema().resolveSimpleTypeDefinition("string"));
    }
  }

}