/*******************************************************************************
 * Copyright (c) 2001, 2008 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.adt.design;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.ui.IEditorPart;
import org.eclipse.wst.xsd.ui.internal.adt.design.editparts.IHolderEditPart;
import org.eclipse.wst.xsd.ui.internal.adt.design.editparts.RootContentEditPart;
import org.eclipse.wst.xsd.ui.internal.adt.design.editparts.StructureEditPart;
import org.eclipse.wst.xsd.ui.internal.adt.design.editparts.model.IGraphElement;
import org.eclipse.wst.xsd.ui.internal.adt.design.editparts.model.IModelProxy;
import org.eclipse.wst.xsd.ui.internal.adt.editor.CommonSelectionManager;
import org.eclipse.wst.xsd.ui.internal.adt.facade.IADTObject;
import org.eclipse.wst.xsd.ui.internal.adt.facade.IField;
import org.eclipse.wst.xsd.ui.internal.adt.facade.IModel;
import org.eclipse.wst.xsd.ui.internal.adt.facade.IStructure;
import org.eclipse.wst.xsd.ui.internal.adt.outline.ADTContentOutlinePage;

public class DesignViewGraphicalViewer extends ScrollingGraphicalViewer implements ISelectionChangedListener
{
  protected ADTSelectionChangedListener internalSelectionProvider = new ADTSelectionChangedListener();
  protected InputChangeManager inputChangeManager = new InputChangeManager();

  public DesignViewGraphicalViewer(IEditorPart editor, CommonSelectionManager manager)
  {
    super();
    setContextMenu(new DesignViewContextMenuProvider(editor, this, this));
    editor.getEditorSite().registerContextMenu("org.eclipse.wst.xsd.ui.popup.graph", getContextMenu(), internalSelectionProvider, false); //$NON-NLS-1$
    
    // make the internalSelectionProvider listen to graph view selection changes
    addSelectionChangedListener(internalSelectionProvider);    
    internalSelectionProvider.addSelectionChangedListener(manager);
    manager.addSelectionChangedListener(this);  
    
    setKeyHandler(new BaseGraphicalViewerKeyHandler(this));    
  }
  
  
  // this method is called when something changes in the selection manager
  // (e.g. a selection occured from another view)
  public void selectionChanged(SelectionChangedEvent event)
  {
    Object selectedObject = ((StructuredSelection) event.getSelection()).getFirstElement();
    
    // TODO (cs) It seems like there's way more selection going on than there
    // should
    // be!! There's at least 2 selections getting fired when something is
    // selected in the
    // outline view. Are we listening to too many things?
    //
    // if (event.getSource() instanceof ADTContentOutlinePage)
    if (event.getSource() != internalSelectionProvider)
    {
      if (selectedObject instanceof IStructure)
      {
        if (((getInput() instanceof IModel) && (event.getSource() instanceof ADTContentOutlinePage)) ||
            (!(getInput() instanceof IModel)))
        {
          if (selectedObject instanceof IGraphElement)
          {
            if (((IGraphElement)selectedObject).isFocusAllowed())
            {
             setInput((IStructure)selectedObject);              
            }
          }
        }
      }
      else if (selectedObject instanceof IGraphElement)
      {
        if (((IGraphElement)selectedObject).isFocusAllowed() && ((event.getSource() instanceof ADTContentOutlinePage) ||
            (event.getSource() instanceof org.eclipse.jface.viewers.IPostSelectionProvider && !(getInput() instanceof IModel))))
        {
          setInput((IADTObject)selectedObject);              
        }
        else if (!((IGraphElement)selectedObject).isFocusAllowed())
        {
          // We encountered an object that is not a valid input to the graph viewer
          // Now find the top container that can be a valid input
          IADTObject obj = ((IGraphElement)selectedObject).getTopContainer();
          if (event.getSource() instanceof ADTContentOutlinePage)
          {
            // In this case, if the selection is originated from the outline, we should 
            // change the inputs
            if (obj != null)
              setInput (obj);
          }
          else if (event.getSource() instanceof CommonSelectionManager)
          {
            // In this case, if the selection is originated from some action, ie. adding
            // a new element, we should change the input only if the current input is the model
            // otherwise, inputs will change unexpectedly!!
            if (getInput() instanceof IModel) 
            {
              if (obj != null)
                setInput (obj);
            }
          }
          else if (event.getSource() instanceof org.eclipse.jface.viewers.IPostSelectionProvider )
          {
            // In this case, if the selection is originated from the source viewer
            // we should change the input regardless.  Test is for multiple levels
            // of anonymous types
            if (obj != null)
              setInput (obj);
          }
        }
        if (selectedObject instanceof IField) 
        {
          IField field = (IField)selectedObject;
          if ( (!field.isGlobal() && getInput() instanceof IModel) ||
               (!field.isGlobal() && !(event.getSource() instanceof CommonSelectionManager)))
          {
            IADTObject obj = ((IGraphElement)selectedObject).getTopContainer();
            if (obj != null)
              setInput (obj);
          }
          else if (field.isGlobal() && !(getInput() instanceof IModel))
          {
            setInput(field);
          }
        }
      }
      else if (selectedObject instanceof IField)
      {
        IField field = (IField)selectedObject;
        if ( (field.isGlobal() && (getInput() instanceof IModel) && (event.getSource() instanceof ADTContentOutlinePage)) ||
            ( (field.isGlobal() && !(getInput() instanceof IModel))))
        {  
          setInput(field);
        }
      }
      else if (selectedObject instanceof IModelProxy)
      {
        IModelProxy adapter = (IModelProxy)selectedObject;
        if (getInput() != adapter.getModel())
           setInput(adapter.getModel());
      }
      else if (selectedObject instanceof IModel)
      {
        if (getInput() != selectedObject)
          setInput((IModel)selectedObject);
      }
      
      EditPart editPart = getEditPart(getRootEditPart(), selectedObject);
      if (editPart != null)
        setSelection(new StructuredSelection(editPart));
    }
  }
  
  /*
   * We need to convert from edit part selections to model object selections
   */
  class ADTSelectionChangedListener implements ISelectionProvider, ISelectionChangedListener
  {
    protected List listenerList = new ArrayList();
    protected ISelection selection = new StructuredSelection();

    public void addSelectionChangedListener(ISelectionChangedListener listener)
    {
      listenerList.add(listener);
    }

    public void removeSelectionChangedListener(ISelectionChangedListener listener)
    {
      listenerList.remove(listener);
    }

    public ISelection getSelection()
    {
      return selection;
    }

    protected void notifyListeners(SelectionChangedEvent event)
    {
      for (Iterator i = listenerList.iterator(); i.hasNext();)
      {
        ISelectionChangedListener listener = (ISelectionChangedListener) i.next();
        listener.selectionChanged(event);
      }
    }

    public StructuredSelection convertSelectionFromEditPartToModel(ISelection editPartSelection)
    {
      List selectedModelObjectList = new ArrayList();
      if (editPartSelection instanceof IStructuredSelection)
      {
        for (Iterator i = ((IStructuredSelection) editPartSelection).iterator(); i.hasNext();)
        {
          Object obj = i.next();
          Object model = null;
          if (obj instanceof EditPart)
          {
            EditPart editPart = (EditPart) obj;
            model = editPart.getModel();
          }
          if (model != null)
          {
            selectedModelObjectList.add(model);
          }
        }
      }
      return new StructuredSelection(selectedModelObjectList);
    }

    public void setSelection(ISelection selection)
    {
      this.selection = selection;
    }

    public void selectionChanged(SelectionChangedEvent event)
    {
      ISelection newSelection = convertSelectionFromEditPartToModel(event.getSelection());
      this.selection = newSelection;
      SelectionChangedEvent newEvent = new SelectionChangedEvent(this, newSelection);
      notifyListeners(newEvent);
    }
  }
  
  protected EditPart getEditPart(EditPart parent, Object object)
  {
    EditPart result = null;
    for (Iterator i = parent.getChildren().iterator(); i.hasNext(); )
    {
      EditPart editPart = (EditPart)i.next();
      if (editPart.getModel() == object && !(editPart instanceof IHolderEditPart) && !(editPart instanceof RootContentEditPart))
      {  
        result = editPart;
        break;
      }
    }             
  
    if (result == null)
    { 
      for (Iterator i = parent.getChildren().iterator(); i.hasNext(); )
      {
        EditPart editPart = getEditPart((EditPart)i.next(), object);
        if (editPart != null)
        {
          // First check to see if there is a selection
          ISelection currentSelection = getSelection();
          
          // If there is a selection then we will try to select 
          // the target edit part that is one of its children
          // This is handy when you add an element to a structured edit part
          // then you want to select the element immediately and put it in
          // direct edit mode
          if (currentSelection != null)
          {
            if (currentSelection instanceof StructuredSelection)
            {
              EditPart targetStructureEditPart = (EditPart)((StructuredSelection)currentSelection).getFirstElement();
              if (targetStructureEditPart != null)
              {
                while (targetStructureEditPart != null)
                {
                  if (targetStructureEditPart instanceof StructureEditPart)
                  {
                    break;
                  }
                  targetStructureEditPart = targetStructureEditPart.getParent();
                }
              }
              EditPart potentialEditPartToSelect = editPart;
              
              while (potentialEditPartToSelect != null)
              {
                if (potentialEditPartToSelect instanceof StructureEditPart)
                {
                  break;
                }
                potentialEditPartToSelect = potentialEditPartToSelect.getParent();
              }
              
              // If we found a potential edit part to select then return it
              // OR, if there is no target found, then we should just return
              // the edit part we found
              if (potentialEditPartToSelect == targetStructureEditPart || potentialEditPartToSelect == null || targetStructureEditPart == null)
              {
                result = editPart;
                break;
              }
            }
          }
          else // Otherwise just find the first one and return
          {
            result = editPart;
            break;
          }
        }
      }            
    }
  
    return result;
  }
  
  public void setInput(IADTObject object)
  {
    RootContentEditPart rootContentEditPart = (RootContentEditPart)getRootEditPart().getContents();
    rootContentEditPart.setModel(object);
    rootContentEditPart.refresh();

    if (object != null)
    {  
      inputChangeManager.setSelection(new StructuredSelection(object));
    }
    // Select the editpart when it is set as input
    EditPart editPart = getEditPart(rootContentEditPart, object);
    if (editPart != null)
      select(editPart);
  }
  
  public IADTObject getInput()
  {
    RootContentEditPart rootContentEditPart = (RootContentEditPart)getRootEditPart().getContents();    
    return (IADTObject)rootContentEditPart.getModel();
  }
  
  public EditPart getInputEditPart()
  {
    return getRootEditPart().getContents();    
  }
  
  public void addInputChangdListener(ISelectionChangedListener listener)
  {
    inputChangeManager.addSelectionChangedListener(listener);
  }
  
  public void removeInputChangdListener(ISelectionChangedListener listener)
  {
    inputChangeManager.removeSelectionChangedListener(listener);    
  }  
  
  
  private class InputChangeManager implements ISelectionProvider
  {
    List listeners = new ArrayList();
       
    public void addSelectionChangedListener(ISelectionChangedListener listener)
    {
      if (!listeners.contains(listener))
      {  
        listeners.add(listener);
      }        
    }

    public ISelection getSelection()
    {   
      // no one should be calling this method     
      return null;
    }

    public void removeSelectionChangedListener(ISelectionChangedListener listener)
    {
      listeners.remove(listener);      
    }

    public void setSelection(ISelection selection)
    { 
      notifyListeners(selection);
    }

    void notifyListeners(ISelection selection)
    {
      List list = new ArrayList(listeners);
      for (Iterator i = list.iterator(); i.hasNext(); )
      {
        ISelectionChangedListener listener = (ISelectionChangedListener)i.next();
        listener.selectionChanged(new SelectionChangedEvent(this, selection));
      }  
    }       
  }
}