/*******************************************************************************
 * 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.wst.xsd.ui.internal.XSDEditorPlugin;
import org.eclipse.wst.xsd.ui.internal.actions.SetBaseTypeAction;
import org.eclipse.wst.xsd.ui.internal.refactor.rename.GlobalSimpleOrComplexTypeRenamer;
import org.eclipse.wst.xsd.ui.internal.util.XSDDOMHelper;
import org.eclipse.xsd.XSDComplexTypeDefinition;
import org.eclipse.xsd.XSDConcreteComponent;
import org.eclipse.xsd.XSDNamedComponent;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.util.XSDConstants;
import org.w3c.dom.Element;

public class ComplexTypePropertySource
  extends BasePropertySource
  implements IPropertySource
{
  private String DERIVED_BY_ID = "derived by"; // XSDEditorPlugin.getXSDString("_UI_LABEL_DERIVED_BY"); 
  private String BASE_TYPE_ID = "base type"; //  XSDEditorPlugin.getXSDString("_UI_LABEL_BASE_TYPE");
  
  private String[] blockOrFinalComboValues = 
  {
    "",
    "#all",
    "extension",
    "restriction"
  };
  
  private String derivedByChoicesComboValues[] =
  {
        "",
        XSDConstants.RESTRICTION_ELEMENT_TAG,
        XSDConstants.EXTENSION_ELEMENT_TAG
  };
  
  /**
   * 
   */
  public ComplexTypePropertySource()
  {
    super();
  }
  /**
   * @param viewer
   * @param xsdSchema
   */
  public ComplexTypePropertySource(Viewer viewer, XSDSchema xsdSchema)
  {
    super(viewer, xsdSchema);
  }
  /**
   * @param xsdSchema
   */
  public ComplexTypePropertySource(XSDSchema xsdSchema)
  {
    super(xsdSchema);
  }
  /* (non-Javadoc)
   * @see org.eclipse.ui.views.properties.IPropertySource#getEditableValue()
   */
  public Object getEditableValue()
  {
    return null;
  }
  /* (non-Javadoc)
   * @see org.eclipse.ui.views.properties.IPropertySource#getPropertyDescriptors()
   */
  public IPropertyDescriptor[] getPropertyDescriptors()
  {
    List list = new ArrayList();
    // Create a descriptor and set a category
    boolean isAnonymousType = checkForAnonymousType(element);
// The three properties name, base type and derived by have been moved to the general tab
//    if (isAnonymousType)
//    {
//      PropertyDescriptor nameDescriptor =
//      new PropertyDescriptor(
//          XSDConstants.NAME_ATTRIBUTE,
//          XSDConstants.NAME_ATTRIBUTE);
//      list.add(nameDescriptor);
//    }
//    else
//    {
//      PropertyDescriptor nameDescriptor =
//      new TextPropertyDescriptor(
//          XSDConstants.NAME_ATTRIBUTE,
//          XSDConstants.NAME_ATTRIBUTE);
//      list.add(nameDescriptor);
//    }

    Element contentModelElement = getDomHelper().getContentModelFromParent(element);
//    SimpleContentPropertyDescriptor typeDescriptor = new SimpleContentPropertyDescriptor(
//        BASE_TYPE_ID,
//        BASE_TYPE_ID,
//        contentModelElement, xsdSchema);
//    list.add(typeDescriptor);
//    XSDComboBoxPropertyDescriptor derivedByDescriptor =
//    new XSDComboBoxPropertyDescriptor(
//        DERIVED_BY_ID,
//        DERIVED_BY_ID,
//        derivedByChoicesComboValues);
//    list.add(derivedByDescriptor);
    
    XSDComboBoxPropertyDescriptor abstractDescriptor =
    new XSDComboBoxPropertyDescriptor(
        XSDConstants.ABSTRACT_ATTRIBUTE,
        XSDConstants.ABSTRACT_ATTRIBUTE,
        trueFalseComboValues);
    list.add(abstractDescriptor);

    XSDComboBoxPropertyDescriptor mixedDescriptor =
    new XSDComboBoxPropertyDescriptor(
        XSDConstants.MIXED_ATTRIBUTE,
        XSDConstants.MIXED_ATTRIBUTE,
        trueFalseComboValues);
    list.add(mixedDescriptor);
        
    XSDComboBoxPropertyDescriptor blockDescriptor =
    new XSDComboBoxPropertyDescriptor(
        XSDConstants.BLOCK_ATTRIBUTE,
        XSDConstants.BLOCK_ATTRIBUTE,
        blockOrFinalComboValues);
    list.add(blockDescriptor);
    XSDComboBoxPropertyDescriptor finalDescriptor =
    new XSDComboBoxPropertyDescriptor(
        XSDConstants.FINAL_ATTRIBUTE,
        XSDConstants.FINAL_ATTRIBUTE,
        blockOrFinalComboValues);
    list.add(finalDescriptor);
    
    IPropertyDescriptor[] result = new IPropertyDescriptor[list.size()];
    list.toArray(result);
    return result;
  }

  public void setInput(Element element)
  {
    this.element = element;
    
  }
  
  /* (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((String) id);
      Element contentModelElement = getDomHelper().getContentModelFromParent(element);    
      String baseType = getDomHelper().getBaseType(contentModelElement);
      
      if (result == null)
      {
        result = "";
      }
      
      if (attributeName.equals(DERIVED_BY_ID))
      {
        return getDomHelper().getDerivedByName(contentModelElement);
      }
      else if (attributeName.equals(BASE_TYPE_ID))
      {
        if (baseType != null)
        {
          return baseType;
        }
        else
        {
          return "";
        }
      }
      else if (attributeName.equals(XSDConstants.NAME_ATTRIBUTE))
      {
        String name = element.getAttribute(XSDConstants.NAME_ATTRIBUTE);
        
        boolean isAnonymousType = checkForAnonymousType(element);
        if (isAnonymousType)
        {
          return "**anonymous**";
        }
        else
        {
          return name;
        }
      }
        
      return result;
//      if (((String) id).equals(XSDConstants.ABSTRACT_ATTRIBUTE)
//          || ((String) id).equals(XSDConstants.MIXED_ATTRIBUTE))
//      {
//      }
//      else if (((String) id).equals(XSDConstants.BLOCK_ATTRIBUTE))
//       {
//      }
//      else if (((String) id).equals(XSDConstants.FINAL_ATTRIBUTE))
//      {
//      }
    }
    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.NAME_ATTRIBUTE))
      {
        if (validateName(newValue))
        {
          beginRecording(XSDEditorPlugin.getXSDString("_UI_COMPLEXTYPE_NAME_CHANGE"), element);
          if (newValue.length() > 0)
          {
            // now rename any references to this type
            if (xsdSchema != null)
            {
              XSDConcreteComponent comp = xsdSchema.getCorrespondingComponent(element);
              if (comp != null && comp instanceof XSDComplexTypeDefinition && comp.getContainer().equals(xsdSchema))
              {
//                XSDComplexTypeDefinition ct = (XSDComplexTypeDefinition)comp;
//                ct.setName(newValue);
                GlobalSimpleOrComplexTypeRenamer renamer = new GlobalSimpleOrComplexTypeRenamer((XSDNamedComponent)comp, newValue);
                renamer.visitSchema(xsdSchema);
              }
            }
            element.setAttribute(XSDConstants.NAME_ATTRIBUTE, newValue);
          }
          else
          {
            element.removeAttribute(XSDConstants.NAME_ATTRIBUTE);
          }
          endRecording(element);
        }
      }
      else if (attributeName.equals(DERIVED_BY_ID))
      {
        Element contentModelElement = getDomHelper().getContentModelFromParent(element);
        String baseType = getDomHelper().getBaseType(contentModelElement);
        beginRecording(XSDEditorPlugin.getXSDString("_UI_DERIVEDBY_CHANGE"), element);
        Element derivedByElem = getDomHelper().getDerivedByElement(element);
        getDomHelper().changeDerivedByType(contentModelElement, newValue, baseType);
        endRecording(element);
      }
      else if (attributeName.equals(BASE_TYPE_ID))
      {
        String derivedBy = getDomHelper().getDerivedByName(element);
        
        SetBaseTypeAction setBaseTypeAction = new SetBaseTypeAction(XSDEditorPlugin.getXSDString("_UI_LABEL_SET_BASE_TYPE"));
        setBaseTypeAction.setXSDSchema(xsdSchema);
        setBaseTypeAction.setComplexTypeElement(element);
        setBaseTypeAction.setType(newValue);
        setBaseTypeAction.setDerivedBy(derivedBy);
        setBaseTypeAction.performAction();

//        handleBaseTypeComboChange(newValue);
        
      }
      else
      {
        if (attributeName.equals(XSDConstants.ABSTRACT_ATTRIBUTE))
        {
          beginRecording(XSDEditorPlugin.getXSDString("_UI_COMPLEXTYPE_ABSTRACT_CHANGE"), element);
        }
        else if (attributeName.equals(XSDConstants.MIXED_ATTRIBUTE))
        {
          beginRecording(XSDEditorPlugin.getXSDString("_UI_COMPLEXTYPE_MIXED_CHANGE"), element);
        }
        else if (attributeName.equals(XSDConstants.BLOCK_ATTRIBUTE))
        {
          beginRecording(XSDEditorPlugin.getXSDString("_UI_COMPLEXTYPE_BLOCK_CHANGE"), element);
        }
        else if (attributeName.equals(XSDConstants.FINAL_ATTRIBUTE))
        {
          beginRecording(XSDEditorPlugin.getXSDString("_UI_COMPLEXTYPE_FINAL_CHANGE"), element);
        }
        
        if (newValue.length() > 0)
        {
          element.setAttribute((String) id,  (String)value);
        }
        else
        {
          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)
  {
    Object parentElement = (Object)element.getParentNode();
    boolean isAnonymous = false;
    if (parentElement != null)
    {
      if (XSDDOMHelper.inputEquals(parentElement, XSDConstants.ELEMENT_ELEMENT_TAG, false))
      {
        isAnonymous = true; 
      }
    }
    return isAnonymous;
  }
  
  
//  private void handleBaseTypeComboChange(String newType)
//  {
//    String tempChoice = newType;
//    TypesHelper helper = new TypesHelper(xsdSchema);
//    if (helper.getBuiltInTypeNamesList().contains(tempChoice) ||
//        helper.getUserSimpleTypeNamesList().contains(tempChoice))
//    {
//      derivedByCombo.setText(XSDConstants.EXTENSION_ELEMENT_TAG);
//      derivedByCombo.setEnabled(false);
//    }
//    else if (helper.getUserComplexTypeNamesList().contains(tempChoice))
//     {
//      Element contentModelElement = getDomHelper().getContentModelFromParent(element);    
//      String derivedByString = getDomHelper().getDerivedByName(contentModelElement);
//      derivedByCombo.setText(derivedByString);
//      derivedByCombo.setEnabled(true); 
//    }
//    else
//     {
//      derivedByCombo.setText("");
//      derivedByCombo.setEnabled(false); 
//    }
//  }
  
}