/*******************************************************************************
 * Copyright (c) 2001, 2015 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.utils;

import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.wst.common.uriresolver.internal.util.URIHelper;
import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
import org.eclipse.wst.sse.ui.StructuredTextEditor;
import org.eclipse.wst.xsd.ui.internal.common.actions.OpenInNewEditor;
import org.eclipse.wst.xsd.ui.internal.editor.InternalXSDMultiPageEditor;
import org.eclipse.wst.xsd.ui.internal.editor.XSDEditorPlugin;
import org.eclipse.xsd.XSDAttributeDeclaration;
import org.eclipse.xsd.XSDAttributeGroupDefinition;
import org.eclipse.xsd.XSDConcreteComponent;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDIdentityConstraintDefinition;
import org.eclipse.xsd.XSDModelGroupDefinition;
import org.eclipse.xsd.XSDNamedComponent;
import org.eclipse.xsd.XSDSchema;
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.Attr;
import org.w3c.dom.Node;


// issue (cs) can we remove this?
//
public class OpenOnSelectionHelper
{
  
  protected StructuredTextEditor textEditor;
  protected XSDSchema xsdSchema;

 
  public OpenOnSelectionHelper(StructuredTextEditor textEditor, XSDSchema xsdSchema)
  {
  	this.textEditor = textEditor;
  	this.xsdSchema = xsdSchema;
  }
  

  boolean lastResult;
  
  public static void openXSDEditor(XSDSchema schema)
  {
    IEditorInput editorInput = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor().getEditorInput();
    
    OpenInNewEditor.openXSDEditor(editorInput, schema, schema);    
   
  }
  
  public static void openXSDEditor(String schemaLocation)
  {
    IPath schemaPath = new Path(schemaLocation);
		final IFile schemaFile = ResourcesPlugin.getWorkspace().getRoot().getFile(schemaPath);
	
		Display.getDefault().asyncExec(new Runnable()
		{
			/**
			 * @see java.lang.Runnable#run()
			 */
			public void run()
			{
				final IWorkbenchWindow workbenchWindow = XSDEditorPlugin.getPlugin().getWorkbench().getActiveWorkbenchWindow();
				if (workbenchWindow != null)
				{
					try
					{
					  workbenchWindow.getActivePage().openEditor(new FileEditorInput(schemaFile), XSDEditorPlugin.EDITOR_ID);
					}
					catch (PartInitException initEx)
					{
					  initEx.printStackTrace();
					}
					catch(Exception e)
					{
					  e.printStackTrace();
					}
				}          
			}
		});
  }
  
  protected boolean revealObject(final XSDConcreteComponent component)
  {
    if (component.getRootContainer().equals(xsdSchema))
    {
      Node element = component.getElement();
      if (element instanceof IndexedRegion)
      {
        IndexedRegion indexNode = (IndexedRegion) element;
        textEditor.getTextViewer().setRangeIndication(indexNode.getStartOffset(), indexNode.getEndOffset() - indexNode.getStartOffset(), true);
        return true;
      }
      return false;
    }
    else
    {
      lastResult = false;
      if (component.getSchema() != null)
      {
				String schemaLocation = URIHelper.removePlatformResourceProtocol(component.getSchema().getSchemaLocation());
        IPath schemaPath = new Path(schemaLocation);
				final IFile schemaFile = ResourcesPlugin.getWorkspace().getRoot().getFile(schemaPath);
        Display.getDefault().syncExec(new Runnable()
        {
	        /**
	         * @see java.lang.Runnable#run()
	         */
	        public void run()
	        {
		        final IWorkbenchWindow workbenchWindow = XSDEditorPlugin.getPlugin().getWorkbench().getActiveWorkbenchWindow();
		        if (workbenchWindow != null)
		        {
							try
							{
								IEditorPart editorPart = workbenchWindow.getActivePage().openEditor(new FileEditorInput(schemaFile), XSDEditorPlugin.PLUGIN_ID);
								if (editorPart instanceof InternalXSDMultiPageEditor)
								{
									((InternalXSDMultiPageEditor)editorPart).openOnGlobalReference(component);
									lastResult = true;
								}
							}
							catch (PartInitException initEx)
							{
							}
						}          
					}
				});
      }
      return lastResult;
    }
  }
  
  public XSDNamedComponent openOnGlobalReference(XSDConcreteComponent comp)
  {
    XSDSchema schema = xsdSchema;
    String name = null;
    String namespace = null;
    if (comp instanceof XSDNamedComponent)
    {
      name = ((XSDNamedComponent) comp).getName();
      namespace = ((XSDNamedComponent) comp).getTargetNamespace();
    }
    if (name == null)
    {
      // For Anonymous types, just show the element
      if (comp instanceof XSDTypeDefinition)
      {
        XSDTypeDefinition type = (XSDTypeDefinition) comp;
        comp = type.getContainer();
        if (comp instanceof XSDNamedComponent)
        {
          name = ((XSDNamedComponent) comp).getName();
          namespace = ((XSDNamedComponent) comp).getTargetNamespace();
        }
      }
    }
    
    if (schema == null || name == null)
    {
      return null;
    }

    List objects = null;    
    if (comp instanceof XSDElementDeclaration)
    {
      objects = schema.getElementDeclarations();
    }
    else if (comp instanceof XSDTypeDefinition)
    {
      objects = schema.getTypeDefinitions();
    }
    else if (comp instanceof XSDAttributeGroupDefinition)
    {
      objects = schema.getAttributeGroupDefinitions();
    }
    else if (comp instanceof XSDIdentityConstraintDefinition)
    {
      objects = schema.getIdentityConstraintDefinitions();
    }
    else if (comp instanceof XSDModelGroupDefinition)
    {
      objects = schema.getModelGroupDefinitions();
    }
    else if (comp instanceof XSDAttributeDeclaration)
    {
      objects = schema.getAttributeDeclarations();
    }

	if (objects != null)
	{
		if (namespace != null)
		{
			// First, look for a namespace and name match
			for (Iterator iter = objects.iterator(); iter.hasNext();)
			{
				XSDNamedComponent namedComp = (XSDNamedComponent) iter.next();
				String targetNamespace = namedComp.getTargetNamespace();
				if (namedComp.getName().equals(name) && targetNamespace != null && targetNamespace.equals(namespace))
				{
					revealObject(namedComp);
					return namedComp;
				}
			}
		}

		// Next, look for just a name match
		for (Iterator iter = objects.iterator(); iter.hasNext();)
		{
			XSDNamedComponent namedComp = (XSDNamedComponent) iter.next();
			if (namedComp.getName().equals(name))
			{
				revealObject(namedComp);
				return namedComp;
			}
		}
	}
    return null;
  }
  
  public boolean openOnSelection()
  {
    List selectedNodes = null;
    ISelection selection = textEditor.getSelectionProvider().getSelection();
    if (selection instanceof IStructuredSelection) {
      selectedNodes = ((IStructuredSelection) selection).toList();
    }

    if (selectedNodes != null && !selectedNodes.isEmpty())
    {
      for (Iterator i = selectedNodes.iterator(); i.hasNext();)
      {
        Object obj = i.next();
        if (xsdSchema != null)
        {
          XSDConcreteComponent xsdComp = xsdSchema.getCorrespondingComponent((Node)obj);
          XSDConcreteComponent objectToReveal = null;

          if (xsdComp instanceof XSDElementDeclaration)
          {
            XSDElementDeclaration elementDecl = (XSDElementDeclaration) xsdComp;
            if (elementDecl.isElementDeclarationReference())
            {
              objectToReveal = elementDecl.getResolvedElementDeclaration();
            }
            else
            {
              XSDConcreteComponent typeDef = null;
              if (elementDecl.getAnonymousTypeDefinition() == null)
              {
                typeDef = elementDecl.getTypeDefinition();
              }
              
              XSDConcreteComponent subGroupAffiliation = elementDecl.getSubstitutionGroupAffiliation();
              
              if (typeDef != null && subGroupAffiliation != null)
              {
                // we have 2 things we can navigate to, if the cursor is anywhere on the substitution attribute
                // then jump to that, otherwise just go to the typeDef.
                if (obj instanceof Attr && ((Attr)obj).getLocalName().equals(XSDConstants.SUBSTITUTIONGROUP_ATTRIBUTE))
                {
                  objectToReveal = subGroupAffiliation;
                }
                else
                {
                  // try to reveal the type now.  On success, then we return true.
                  // if we fail, set the substitution group as the object to reveal as a backup plan.
                  if (revealObject(typeDef))
                  {
                    return true;
                  }
                  else
                  {
                    objectToReveal = subGroupAffiliation;
                  }
                }
              }
              else
              {
                // one or more of these is null.  If the typeDef is non-null, use it.  Otherwise
                // try and use the substitution group
                objectToReveal = typeDef != null ? typeDef : subGroupAffiliation;
              }
            }
          }
          else if (xsdComp instanceof XSDModelGroupDefinition)
          {
            XSDModelGroupDefinition elementDecl = (XSDModelGroupDefinition) xsdComp;
            if (elementDecl.isModelGroupDefinitionReference())
            {
              objectToReveal = elementDecl.getResolvedModelGroupDefinition();
            }
          }
          else if (xsdComp instanceof XSDAttributeDeclaration)
          {
            XSDAttributeDeclaration attrDecl = (XSDAttributeDeclaration) xsdComp;
            if (attrDecl.isAttributeDeclarationReference())
            {
              objectToReveal = attrDecl.getResolvedAttributeDeclaration();
            }
            else if (attrDecl.getAnonymousTypeDefinition() == null)
            {
              objectToReveal = attrDecl.getTypeDefinition();
            }              
          }
          else if (xsdComp instanceof XSDAttributeGroupDefinition)
          {
            XSDAttributeGroupDefinition attrGroupDef = (XSDAttributeGroupDefinition) xsdComp;
            if (attrGroupDef.isAttributeGroupDefinitionReference())
            {
              objectToReveal = attrGroupDef.getResolvedAttributeGroupDefinition();
            }
          }
          else if (xsdComp instanceof XSDIdentityConstraintDefinition)
          {
            XSDIdentityConstraintDefinition idConstraintDef = (XSDIdentityConstraintDefinition) xsdComp;
            if (idConstraintDef.getReferencedKey() != null)
            {
              objectToReveal = idConstraintDef.getReferencedKey();
            }
          }
          else if (xsdComp instanceof XSDSimpleTypeDefinition)
          {
            XSDSimpleTypeDefinition typeDef = (XSDSimpleTypeDefinition) xsdComp;
            objectToReveal = typeDef.getItemTypeDefinition();
            if (objectToReveal == null)
            {
              // if itemType attribute is not set, then check for memberType
              List memberTypes = typeDef.getMemberTypeDefinitions();
              if (memberTypes != null && memberTypes.size() > 0)
              {
                objectToReveal = (XSDConcreteComponent)memberTypes.get(0);
              }              
            }
          }
          else if (xsdComp instanceof XSDTypeDefinition)
          {
            XSDTypeDefinition typeDef = (XSDTypeDefinition) xsdComp;
            objectToReveal = typeDef.getBaseType();
          }
          else if (xsdComp instanceof XSDSchemaDirective)
          {
          	XSDSchemaDirective directive = (XSDSchemaDirective) xsdComp;
//						String schemaLocation = URIHelper.removePlatformResourceProtocol(directive.getResolvedSchema().getSchemaLocation());
//						openXSDEditor(schemaLocation);
//						return false;
            objectToReveal = directive.getResolvedSchema();						          	          	
          }

          // now reveal the object if this isn't null
          if (objectToReveal != null)
          {
            return revealObject(objectToReveal);
          }
        }
      }
    }
    return false;
  }

}