/*******************************************************************************
 * 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.properties;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.views.properties.IPropertyDescriptor;
import org.eclipse.ui.views.properties.IPropertySource;
import org.eclipse.ui.views.properties.PropertyDescriptor;
import org.eclipse.ui.views.properties.TextPropertyDescriptor;
import org.eclipse.wst.xsd.ui.internal.XSDEditorPlugin;
import org.eclipse.wst.xsd.ui.internal.refactor.rename.GlobalElementRenamer;
import org.eclipse.wst.xsd.ui.internal.util.TypesHelper;
import org.eclipse.wst.xsd.ui.internal.util.XSDDOMHelper;
import org.eclipse.xsd.XSDConcreteComponent;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDNamedComponent;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.util.XSDConstants;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;
import org.w3c.dom.Node;


public class ElementPropertySource extends BasePropertySource implements IPropertySource
{
  private static final String PROPERTY_NAME = "org.eclipse.wst.xsd.ui.internal.name";
  private String[] blockComboValues =
    { "", "#all", "extension", "restriction", "substitution" };
  private String[] finalComboValues =
    { "", "#all", "extension", "restriction" };
  private String[] substitutionGroupComboValues = { "" };
  private String[] formComboValues =
  {
      "",
      XSDEditorPlugin.getXSDString("_UI_COMBO_UNQUALIFIED"),
      XSDEditorPlugin.getXSDString("_UI_COMBO_QUALIFIED")
  };

  public ElementPropertySource()
  {
    super();
  }

  public ElementPropertySource(XSDSchema xsdSchema)
  {
    super(xsdSchema);
  }
  
  public ElementPropertySource(Viewer viewer, XSDSchema xsdSchema)
  {
    super(viewer, xsdSchema);
  }

  public void setInput(Element element)
  {
    this.element = element;
    TypesHelper helper = new TypesHelper(xsdSchema);
    List globals = helper.getGlobalElements();
    int size = globals.size() + 1;
    substitutionGroupComboValues = new String[size];
    substitutionGroupComboValues[0] = "";
    if (globals != null)
    {
      for (int k = 0; k < globals.size(); k++)
      {
        substitutionGroupComboValues[k + 1] = (String) globals.get(k);
      }
    }
  }

  /*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.views.properties.IPropertySource#getEditableValue()
	 */
  public Object getEditableValue()
  {
//    return element.getNodeName();
    return null;
  }

  /*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.views.properties.IPropertySource#getPropertyDescriptors()
	 */
  public IPropertyDescriptor[] getPropertyDescriptors()
  {
    Object parentNode = element.getParentNode();
    boolean isGlobalElement = XSDDOMHelper.inputEquals(parentNode, XSDConstants.SCHEMA_ELEMENT_TAG, false);
    
    List list = new ArrayList();
    // Create a descriptor and set a category
//  These have been moved to the general tab
//    PropertyDescriptor nameDescriptor =
//      new TextPropertyDescriptor(
//        XSDConstants.NAME_ATTRIBUTE,
//        XSDConstants.NAME_ATTRIBUTE);
//    list.add(nameDescriptor);
//    TypesPropertyDescriptor typeDescriptor = new TypesPropertyDescriptor(
//        XSDConstants.TYPE_ATTRIBUTE,
//        XSDConstants.TYPE_ATTRIBUTE,
//        element, xsdSchema);
//    list.add(typeDescriptor);
    if (isGlobalElement)
    {
      XSDComboBoxPropertyDescriptor abstractDescriptor =
        new XSDComboBoxPropertyDescriptor(
          XSDConstants.ABSTRACT_ATTRIBUTE,
          XSDConstants.ABSTRACT_ATTRIBUTE,
          trueFalseComboValues);
      list.add(abstractDescriptor);
    }
    if (!isGlobalElement)
    {
      PropertyDescriptor minOccursDescriptor =
        new TextPropertyDescriptor(
          XSDConstants.MINOCCURS_ATTRIBUTE,
          XSDConstants.MINOCCURS_ATTRIBUTE);
      list.add(minOccursDescriptor);
    
      PropertyDescriptor maxOccursDescriptor =
        new TextPropertyDescriptor(
          XSDConstants.MAXOCCURS_ATTRIBUTE,
          XSDConstants.MAXOCCURS_ATTRIBUTE);
      list.add(maxOccursDescriptor);
    }
    XSDComboBoxPropertyDescriptor nillableDescriptor =
      new XSDComboBoxPropertyDescriptor(
        XSDConstants.NILLABLE_ATTRIBUTE,
        XSDConstants.NILLABLE_ATTRIBUTE,
        trueFalseComboValues);
    list.add(nillableDescriptor);
    XSDComboBoxPropertyDescriptor blockDescriptor =
      new XSDComboBoxPropertyDescriptor(
        XSDConstants.BLOCK_ATTRIBUTE,
        XSDConstants.BLOCK_ATTRIBUTE,
        blockComboValues);
    list.add(blockDescriptor);
    if (isGlobalElement)
    {      
      XSDComboBoxPropertyDescriptor finalDescriptor =
        new XSDComboBoxPropertyDescriptor(
          XSDConstants.FINAL_ATTRIBUTE,
          XSDConstants.FINAL_ATTRIBUTE,
          finalComboValues);
      list.add(finalDescriptor);
      XSDComboBoxPropertyDescriptor substitutionGroupDescriptor =
        new XSDComboBoxPropertyDescriptor(
          XSDConstants.SUBSTITUTIONGROUP_ATTRIBUTE,
          XSDConstants.SUBSTITUTIONGROUP_ATTRIBUTE,
          substitutionGroupComboValues);
      list.add(substitutionGroupDescriptor);
    }
    if (!isGlobalElement)
    {
      XSDComboBoxPropertyDescriptor formDescriptor =
        new XSDComboBoxPropertyDescriptor(
          XSDConstants.FORM_ATTRIBUTE,
          XSDConstants.FORM_ATTRIBUTE,
          formComboValues);
      list.add(formDescriptor);
    }

    Attr fixedAttr = element.getAttributeNode(XSDConstants.FIXED_ATTRIBUTE);
    Attr defaultAttr = element.getAttributeNode(XSDConstants.DEFAULT_ATTRIBUTE);
    String str;
    if (fixedAttr != null)
    {
      str = XSDConstants.FIXED_ATTRIBUTE;
    }
    else if (defaultAttr != null)
    {
      str = XSDConstants.DEFAULT_ATTRIBUTE;
    }
    else
    {
      str = XSDConstants.FIXED_ATTRIBUTE + "/" + XSDConstants.DEFAULT_ATTRIBUTE;
    }
    
    FixedOrDefaultTextPropertyDescriptor fixedOrDefaultDescriptor =
      new FixedOrDefaultTextPropertyDescriptor(
        str, 
        str,
        element);
    list.add(fixedOrDefaultDescriptor);

    IPropertyDescriptor[] result = new IPropertyDescriptor[list.size()];
    list.toArray(result);
    return result;
    //    return propertyDescriptors;
  }

  /*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.views.properties.IPropertySource#getPropertyValue(java.lang.Object)
	 */
  public Object getPropertyValue(Object id)
  {
    Object result = null;
    if (id instanceof String)
    {
      String attributeName = (String)id;
      result = element.getAttribute(attributeName);
      if (result == null)
      {
        result = "";
      }
      if (attributeName.equals(XSDConstants.TYPE_ATTRIBUTE))
      {
        boolean isAnonymous = checkForAnonymousType(element);
        if (isAnonymous)
        {
          return "**anonymous**";
        }
        if (result.equals(""))
        {
          result = XSDEditorPlugin.getXSDString("_UI_NO_TYPE");
        }
        return result;
      }
      else if (attributeName.equals(XSDConstants.MAXOCCURS_ATTRIBUTE) 
        || attributeName.equals(XSDConstants.MINOCCURS_ATTRIBUTE)
        || attributeName.equals(XSDConstants.SUBSTITUTIONGROUP_ATTRIBUTE)
        || attributeName.equals(XSDConstants.FORM_ATTRIBUTE)
        || attributeName.equals(XSDConstants.ABSTRACT_ATTRIBUTE)
        || attributeName.equals(XSDConstants.NILLABLE_ATTRIBUTE)
        || attributeName.equals(XSDConstants.BLOCK_ATTRIBUTE)
        || attributeName.equals(XSDConstants.FINAL_ATTRIBUTE)
        || attributeName.equals(XSDConstants.FIXED_ATTRIBUTE) 
        || attributeName.equals(XSDConstants.DEFAULT_ATTRIBUTE)
        || attributeName.equals(XSDConstants.NAME_ATTRIBUTE))
      {
        return result;
      }
    }
    return "";
  }

  /*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.views.properties.IPropertySource#isPropertySet(java.lang.Object)
	 */
  public boolean isPropertySet(Object id)
  {
    return false;
  }

  /*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.views.properties.IPropertySource#resetPropertyValue(java.lang.Object)
	 */
  public void resetPropertyValue(Object id)
  {
  }

  /*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ui.views.properties.IPropertySource#setPropertyValue(java.lang.Object,
	 *      java.lang.Object)
	 */
  public void setPropertyValue(Object id, Object value)
  {
    if (value == null)
    {
      value = "";
    }
    if (value instanceof String)
    {
      String newValue = (String)value;
      String attributeName = (String)id;
      
      if (attributeName.equals(XSDConstants.MAXOCCURS_ATTRIBUTE))
      {
        beginRecording(XSDEditorPlugin.getXSDString("_UI_MAXOCCURS_CHANGE"), element);
      }
      else if (attributeName.equals(XSDConstants.MINOCCURS_ATTRIBUTE))
      {
        beginRecording(XSDEditorPlugin.getXSDString("_UI_MINOCCURS_CHANGE"), element);      
      }
      else if (attributeName.equals(XSDConstants.SUBSTITUTIONGROUP_ATTRIBUTE))
      {
        beginRecording(XSDEditorPlugin.getXSDString("_UI_ELEMENT_SUBSTITUTIONGROUP_CHANGE"), element);
      }
      else if (attributeName.equals(XSDConstants.FORM_ATTRIBUTE))
      {
        beginRecording(XSDEditorPlugin.getXSDString("_UI_ELEMENT_FORM_CHANGE"), element);
      }
      else if (attributeName.equals(XSDConstants.ABSTRACT_ATTRIBUTE))
      {
        beginRecording(XSDEditorPlugin.getXSDString("_UI_ELEMENT_ABSTRACT_CHANGE"), element);
      }
      else if (attributeName.equals(XSDConstants.NILLABLE_ATTRIBUTE))
      {
        beginRecording(XSDEditorPlugin.getXSDString("_UI_ELEMENT_NILLABLE_CHANGE"), element);
      }
      else if (attributeName.equals(XSDConstants.BLOCK_ATTRIBUTE))
      {
        beginRecording(XSDEditorPlugin.getXSDString("_UI_ELEMENT_BLOCK_CHANGE"), element);
      }
      else if (attributeName.equals(XSDConstants.FINAL_ATTRIBUTE))
      {
        beginRecording(XSDEditorPlugin.getXSDString("_UI_ELEMENT_FINAL_CHANGE"), element);
      }
      else if (attributeName.equals(XSDConstants.FIXED_ATTRIBUTE) || attributeName.equals(XSDConstants.DEFAULT_ATTRIBUTE))
      {  
        beginRecording(XSDEditorPlugin.getXSDString("_UI_ELEMENT_VALUE_CHANGE"), element);
      }
      else if (attributeName.equals(XSDConstants.NAME_ATTRIBUTE))
      {
        if (validateName(newValue))
        {
          beginRecording(XSDEditorPlugin.getXSDString("_UI_ELEMENT_NAME_CHANGE"), element);
          // now rename any references to this element
          if (xsdSchema != null)
          {
            XSDConcreteComponent comp = xsdSchema.getCorrespondingComponent(element);
            if (comp != null && comp instanceof XSDElementDeclaration && comp.getContainer().equals(xsdSchema))
            {
              GlobalElementRenamer renamer = new GlobalElementRenamer((XSDNamedComponent)comp, newValue);
              renamer.visitSchema(xsdSchema);
            }
          }
        }
      }
      else if (attributeName.equals(XSDConstants.TYPE_ATTRIBUTE))
      {
        // put logic in descriptor/cell editor
//          beginRecording(XSDEditorPlugin.getXSDString("_UI_ELEMENT_TYPE_CHANGE"), element);
      }
    
      if (newValue.length() > 0)
      {
        element.setAttribute((String) id, (String) value);
      }
      else
      {
        if (!attributeName.equals(XSDConstants.NAME_ATTRIBUTE))
        {
          element.removeAttribute((String) id);
        }
      }
      endRecording(element);
    }
    Runnable delayedUpdate = new Runnable()
    {
      public void run()
      {
        if (viewer != null)
          viewer.refresh();
      }
    };
    Display.getCurrent().asyncExec(delayedUpdate);

  }

  boolean checkForAnonymousType(Element element)
  {
    /* Using Ed's model to check
     boolean isAnonymous = false;

     XSDConcreteComponent component = getXSDSchema().getCorrespondingComponent(element);
     if (component instanceof XSDElementDeclaration)
     {
     XSDElementDeclaration xsdElem = (XSDElementDeclaration)component;
     isAnonymous = xsdElem.isSetAnonymousTypeDefinition();
     }
     return isAnonymous;
     */

    boolean isAnonymous = false;

    Node aNode = getDomHelper().getChildNode(element, XSDConstants.SIMPLETYPE_ELEMENT_TAG);
    if (aNode != null)
     {
      return true;
    }
    aNode = getDomHelper().getChildNode(element, XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
    if (aNode != null)
     {
      isAnonymous = true;
    }
    return isAnonymous;
  }
  
  
//  void updateElementToAnonymous(Element element, String xsdType)
//  {
//    String prefix = element.getPrefix();
//    prefix = (prefix == null) ? "" : (prefix + ":");
//
//    updateElementToNotAnonymous(element);
//    boolean hasChildrenElements = hasElementChildren(element);
//
//    Element childNode = null;
//    if (xsdType.equals(XSDConstants.COMPLEXTYPE_ELEMENT_TAG))
//     {
//      childNode = element.getOwnerDocument().createElementNS(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001, prefix + XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
//    }
//    else if (xsdType.equals(XSDConstants.SIMPLETYPE_ELEMENT_TAG))
//     {
//      childNode = element.getOwnerDocument().createElementNS(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001, prefix + XSDConstants.SIMPLETYPE_ELEMENT_TAG);
//    }
//
//    element.appendChild(childNode);
//    formatChild(childNode, hasChildrenElements);    
//
//
//    /* Using Ed's model to do the above
//     XSDConcreteComponent component = getXSDSchema().getCorrespondingComponent(element);
//     if (component instanceof XSDElementDeclaration)
//     {
//     XSDElementDeclaration xsdElem = (XSDElementDeclaration)component;
//     XSDFactoryImpl factory = new XSDFactoryImpl();
//     XSDComplexTypeDefinition complex = factory.createXSDComplexTypeDefinition();
//     XSDSimpleTypeDefinition simple = factory.createXSDSimpleTypeDefinition();
//
//     Node child = element.getFirstChild();
//     if (XSDDOMHelper.inputEquals(child, XSDConstants.SIMPLETYPE_ELEMENT_TAG, false) ||
//     XSDDOMHelper.inputEquals(child, XSDConstants.COMPLEXTYPE_ELEMENT_TAG, false))
//     {
//     element.removeChild(child);
//     }
//     
//     FormatProcessor formatProcessor = new FormatProcessor();
//     if (xsdType.equals(XSDConstants.COMPLEXTYPE_ELEMENT_TAG))
//     {
//     xsdElem.setAnonymousTypeDefinition(complex);
//     Element elem = complex.getElement();
//     formatProcessor.formatWithSiblingIndent((XMLNode)elem);
//     }
//     else if (xsdType.equals(XSDConstants.SIMPLETYPE_ELEMENT_TAG))
//     {
//     xsdElem.setAnonymousTypeDefinition(simple);
//     Element elem = simple.getElement();  
//     formatProcessor.formatWithSiblingIndent((XMLNode)elem);
//     }
//     }
//     component.updateElement();
//     */
//  }
//
//  boolean isSTAnonymous(Element element)
//  {
//    Node aNode = getDomHelper().getChildNode(element, XSDConstants.SIMPLETYPE_ELEMENT_TAG);
//    if (aNode != null)
//     {
//      if (XSDDOMHelper.inputEquals(aNode, XSDConstants.SIMPLETYPE_ELEMENT_TAG, false))
//       {
//        return true;
//      }
//    }
//    return false;
//  }  
//
//  boolean isCTAnonymous(Element element)
//  {
//    Node aNode = getDomHelper().getChildNode(element, XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
//    if (aNode != null)
//     {
//      if (XSDDOMHelper.inputEquals(aNode, XSDConstants.COMPLEXTYPE_ELEMENT_TAG, false))
//       {
//        return true;
//      }
//    }
//    return false;
//  }  
//
//  XSDTypeDefinition getAnonymousTypeDefinition(Element element)
//  {
//    Node typeDefinitionNode = getDomHelper().getChildNode(element, XSDConstants.SIMPLETYPE_ELEMENT_TAG);
//    if (typeDefinitionNode == null)
//     {
//      typeDefinitionNode = getDomHelper().getChildNode(element, XSDConstants.COMPLEXTYPE_ELEMENT_TAG);
//    }
//    if (typeDefinitionNode != null)
//     {
//      XSDConcreteComponent component = getXSDSchema().getCorrespondingComponent(typeDefinitionNode);
//      if (component instanceof XSDTypeDefinition)
//       {
//        return (XSDTypeDefinition)component;
//      }
//    }
//    return null;    
//
//    /*    XSDConcreteComponent component = getXSDSchema().getCorrespondingComponent(element);
//     if (component instanceof XSDElementDeclaration)
//     {
//     XSDElementDeclaration xsdElem = (XSDElementDeclaration)component;
//
//     return xsdElem.getAnonymousTypeDefinition();
//     }
//     return null;
//     */
//  }
//
//  void updateElementToNotAnonymous(Element element)
//  {
//    NodeList children = element.getChildNodes();
//    if (children != null)
//     {
//      for (int i = 0; i < children.getLength(); i++)
//       {
//        Node node = (Node)children.item(i);
//        if (node instanceof Element)
//         {
//          if (node.getLocalName().equals(XSDConstants.SIMPLETYPE_ELEMENT_TAG) ||
//              node.getLocalName().equals(XSDConstants.COMPLEXTYPE_ELEMENT_TAG))
//           {
//            XSDDOMHelper.removeNodeAndWhitespace(node);
//            i=0;
//          }
//        }
//      }
//    }
//    /*    XSDConcreteComponent component = getXSDSchema().getCorrespondingComponent(element);
//     if (component instanceof XSDElementDeclaration)
//     {
//     XSDElementDeclaration xsdElem = (XSDElementDeclaration)component;
//     if (xsdElem.isSetAnonymousTypeDefinition())
//     {
//     xsdElem.unsetAnonymousTypeDefinition();
//     xsdElem.setAnonymousTypeDefinition(null);
//     }
//     }
//     component.updateElement();
//     */
//  }
  
}