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

import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.views.contentoutline.ContentOutlinePage;
import org.eclipse.wst.xsd.ui.internal.actions.OpenSchemaAction;
import org.eclipse.wst.xsd.ui.internal.provider.CategoryAdapter;
import org.eclipse.xsd.XSDConcreteComponent;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDSchemaDirective;
import org.w3c.dom.Element;

public class XSDContentOutlinePage extends ContentOutlinePage
{
  protected XSDEditor xsdEditor;
  protected int level = 0;
  protected Object model;
  protected ITreeContentProvider contentProvider;
  protected ILabelProvider labelProvider;
  protected XSDSelectionManager selectionManager;
  protected SelectionManagerSelectionChangeListener selectionManagerSelectionChangeListener = new SelectionManagerSelectionChangeListener();
  protected TreeSelectionChangeListener treeSelectionChangeListener = new TreeSelectionChangeListener();
  XSDTextEditor xsdTextEditor;
  XSDMenuListener menuListener;

  /**
   *  
   */
  public XSDContentOutlinePage(XSDTextEditor xsdTextEditor)
  {
    super();
    this.xsdTextEditor = xsdTextEditor;
  }

  public void setModel(Object newModel)
  {
    model = newModel;
  }

  public void setContentProvider(ITreeContentProvider contentProvider)
  {
    this.contentProvider = contentProvider;
  }

  public void setLabelProvider(ILabelProvider labelProvider)
  {
    this.labelProvider = labelProvider;
  }

  // expose
  public TreeViewer getTreeViewer()
  {
    return super.getTreeViewer();
  }

  public void createControl(Composite parent)
  {
    super.createControl(parent);
    getTreeViewer().setContentProvider(contentProvider);
    getTreeViewer().setLabelProvider(labelProvider);
    getTreeViewer().setInput(model);
    getTreeViewer().addSelectionChangedListener(this);
    MenuManager menuManager = new MenuManager("#popup");//$NON-NLS-1$
    menuManager.setRemoveAllWhenShown(true);
    Menu menu = menuManager.createContextMenu(getTreeViewer().getControl());
    getTreeViewer().getControl().setMenu(menu);
    menuListener = new XSDMenuListener(xsdTextEditor.getXSDEditor().getSelectionManager());
//  menuListener.setSelectionProvider(getTreeViewer());
    menuManager.addMenuListener(menuListener);
    setSelectionManager(xsdTextEditor.getXSDEditor().getSelectionManager());
    // cs... why are we doing this from the outline view?
    //
    //xsdTextEditor.getXSDEditor().getSelectionManager().setSelection(new
    // StructuredSelection(xsdTextEditor.getXSDSchema()));
    XSDKeyListener keyListener = new XSDKeyListener(getTreeViewer(), menuListener);
    getTreeViewer().getControl().addKeyListener(keyListener);
    // drill down from outline view
    getTreeViewer().getControl().addMouseListener(new MouseAdapter()
    {
      public void mouseDoubleClick(MouseEvent e)
      {
        ISelection iSelection = getTreeViewer().getSelection();
        if (iSelection instanceof StructuredSelection)
        {
          StructuredSelection selection = (StructuredSelection)iSelection;
          Object obj = selection.getFirstElement();
          if (obj instanceof XSDConcreteComponent)
          {
            XSDConcreteComponent comp = (XSDConcreteComponent)obj;
            if (comp.getContainer() instanceof XSDSchema)
            {
              xsdTextEditor.getXSDEditor().getGraphViewer().setInput(obj);
            }
          }
        }

      }
    });
  }
  class XSDKeyListener extends KeyAdapter
  {
    TreeViewer viewer;
    XSDMenuListener menuListener;

    public XSDKeyListener(TreeViewer viewer, XSDMenuListener menuListener)
    {
      super();
      this.viewer = viewer;
      this.menuListener = menuListener;
    }

    /**
     * @see org.eclipse.swt.events.KeyAdapter#keyReleased(KeyEvent)
     */
    public void keyReleased(KeyEvent e)
    {
      if (e.character == SWT.DEL)
      {
        menuListener.getDeleteAction().run();
      }
      else if (e.keyCode == SWT.F3) // open editor on any
                                    // include/import/redefine
      {
        if (e.widget instanceof Tree)
        {
          Tree tree = (Tree) e.widget;
          TreeItem[] selection = tree.getSelection();
          if (selection.length > 0)
          {
            if (selection[0].getData() instanceof XSDSchemaDirective)
            {
              XSDSchemaDirective comp = (XSDSchemaDirective) selection[0].getData();
              OpenSchemaAction openSchema = new OpenSchemaAction(XSDEditorPlugin.getXSDString("_UI_ACTION_OPEN_SCHEMA"), comp);
              openSchema.run();
            }
          }
        }
      }
    }
  }

  public void setExpandToLevel(int i)
  {
    level = i;
  }

  public void setInput(Object value)
  {
    getTreeViewer().setInput(value);
    getTreeViewer().expandToLevel(level);
  }

  //	public ISelection getSelection()
  //	{
  //		if (getTreeViewer() == null)
  //			return StructuredSelection.EMPTY;
  //		return getTreeViewer().getSelection();
  //	}
  public void setSelectionManager(XSDSelectionManager newSelectionManager)
  {
    TreeViewer treeViewer = getTreeViewer();
    // disconnect from old one
    if (selectionManager != null)
    {
      selectionManager.removeSelectionChangedListener(selectionManagerSelectionChangeListener);
      treeViewer.removeSelectionChangedListener(treeSelectionChangeListener);
    }
    selectionManager = newSelectionManager;
    // connect to new one
    if (selectionManager != null)
    {
      selectionManager.addSelectionChangedListener(selectionManagerSelectionChangeListener);
      treeViewer.addSelectionChangedListener(treeSelectionChangeListener);
    }
  }
  class SelectionManagerSelectionChangeListener implements ISelectionChangedListener
  {
    public void selectionChanged(SelectionChangedEvent event)
    {
      if (event.getSelectionProvider() != getTreeViewer())
      {
        getTreeViewer().setSelection(event.getSelection(), true);
      }
    }
  }
  class TreeSelectionChangeListener implements ISelectionChangedListener
  {
    public void selectionChanged(SelectionChangedEvent event)
    {
      if (selectionManager != null)
      {
        ISelection selection = event.getSelection();
        if (selection instanceof IStructuredSelection)
        {
          IStructuredSelection structuredSelection = (IStructuredSelection) selection;
          Object o = structuredSelection.getFirstElement();
          // TODO ...
          // we need to implement a selectionManagerMapping extension point
          // so that extensions can specify how they'd like to map view objects
          // to selection objects
          //                                        
          if (o instanceof Element)
          {
            try
            {
              Object modelObject = xsdTextEditor.getXSDSchema().getCorrespondingComponent((Element) o);
              if (modelObject != null)
              {
                o = modelObject;
              }
            }
            catch (Exception e)
            {
            }
          }
          else if (o instanceof CategoryAdapter)
          {
            // todo... we need to ensure we eliminate the propagation 
            // of 'view' specific objects into the SelectionManager.                     
            // We need to do some work to ensure all views utilize the 'Category' model object  
            // so we can get rid of this CategoryAdapter class.
//             CategoryAdapter adapter = (CategoryAdapter) o;
//             o = adapter.getXSDSchema();
          }
          if (o != null)
          {
            selectionManager.setSelection(new StructuredSelection(o), getTreeViewer());
//          selectionManager.selectionChanged(new SelectionChangedEvent(getTreeViewer(),new StructuredSelection(o)));
          }
          else
          {
            //            selectionManager.setSelection(new StructuredSelection(),
            // getTreeViewer());
          }
        }
      }
    }
  }
  FilterAction referenceAction, inheritedAction;

  public void setActionBars(IActionBars actionBars)
  {
    super.setActionBars(actionBars);
    // Uncomment to add sort action
    //    SortAction sortAction = new SortAction();
    //
    //    actionBars.getToolBarManager().add(sortAction);
    //    sortAction.setChecked(false);
    referenceAction = new FilterAction(new ReferenceFilter("Reference Content"), XSDEditorPlugin.getXSDString("_UI_OUTLINE_SHOW_REFERENCES"), ImageDescriptor.createFromFile(XSDEditorPlugin
        .getPlugin().getClass(), "icons/XSDElementRef.gif"));
    boolean initialRef = xsdTextEditor.getXSDModelAdapterFactory().getShowReferences();
    referenceAction.setChecked(initialRef);
    inheritedAction = new FilterAction(new ReferenceFilter("Inherited Content"), XSDEditorPlugin.getXSDString("_UI_OUTLINE_SHOW_INHERITED"), ImageDescriptor.createFromFile(XSDEditorPlugin.getPlugin()
        .getClass(), "icons/XSDComplexContent.gif"));
    boolean initialInherited = xsdTextEditor.getXSDModelAdapterFactory().getShowReferences();
    IMenuManager menu = actionBars.getMenuManager();
    menu.add(referenceAction);
    menu.add(inheritedAction);
  }

  private void updateActions(Action current)
  {
    if (referenceAction.isChecked())
    {
      xsdTextEditor.getXSDModelAdapterFactory().setShowReferences(true);
    }
    else
    {
      xsdTextEditor.getXSDModelAdapterFactory().setShowReferences(false);
    }
    if (inheritedAction.isChecked())
    {
      xsdTextEditor.getXSDModelAdapterFactory().setShowInherited(true);
    }
    else
    {
      xsdTextEditor.getXSDModelAdapterFactory().setShowInherited(false);
    }
  }
  private Sorter sorter = new Sorter();
  public class Sorter extends org.eclipse.jface.viewers.ViewerSorter
  {
  }
  public class SortAction extends Action
  {
    public SortAction()
    {
      super("Sort", ImageDescriptor.createFromFile(XSDEditorPlugin.getPlugin().getClass(), "icons/sort.gif"));
    }

    public void run()
    {
      getTreeViewer().getControl().setVisible(false);
      Object[] expandedElements = getTreeViewer().getExpandedElements();
      getTreeViewer().setSorter(isChecked() ? sorter : null);
      Object input = getTreeViewer().getInput();
      getTreeViewer().setInput(input);
      getTreeViewer().setExpandedElements(expandedElements);
      getTreeViewer().getControl().setVisible(true);
    }

    public void setChecked(boolean checked)
    {
      super.setChecked(checked);
      setToolTipText(checked ? XSDEditorPlugin.getXSDString("_UI_OUTLINE_DO_NOT_SORT") : XSDEditorPlugin.getXSDString("_UI_OUTLINE_SORT"));
    }
  }
  public class FilterAction extends Action
  {
    ViewerFilter filter;

    public FilterAction(ViewerFilter filter, String label, ImageDescriptor image)
    {
      super(label, image);
      this.filter = filter;
      setChecked(false);
    }

    public void run()
    {
      updateActions(this);
      if (isChecked())
      {
        getTreeViewer().resetFilters();
        getTreeViewer().addFilter(filter);
      }
      else
      {
        getTreeViewer().removeFilter(filter);
      }
    }
  }
  class ReferenceFilter extends ViewerFilter // Dummy filter
  {
    public ReferenceFilter(String elementTag)
    {
      this.elementTag = elementTag;
    }
    protected String elementTag;

    public boolean select(Viewer viewer, Object parentElement, Object element)
    {
      return true;
    }
  }
}