/*****************************************************************************
 * Copyright (c) 2010 Atos Origin.
 *
 *    
 * 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:
 *  Vincent Hemery (Atos Origin}) {vincent.hemery@atosorigin.com} - Initial API and implementation
 *
 *****************************************************************************/
package org.topcased.requirement.bundle.papyrus.services;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.common.util.WrappedException;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.transaction.RollbackException;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.EditPartViewer;
import org.eclipse.gef.editparts.AbstractGraphicalEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.ConnectionEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;
import org.eclipse.gmf.runtime.diagram.ui.editparts.GraphicalEditPart;
import org.eclipse.gmf.runtime.diagram.ui.parts.DiagramEditor;
import org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramGraphicalViewer;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.osgi.util.NLS;
import org.eclipse.papyrus.core.editor.IMultiDiagramEditor;
import org.eclipse.papyrus.core.modelsetquery.ModelSetQuery;
import org.eclipse.papyrus.core.utils.EditorUtils;
import org.eclipse.papyrus.diagram.common.util.DiagramEditPartsUtil;
import org.eclipse.papyrus.resource.IModel;
import org.eclipse.papyrus.resource.ModelSet;
import org.eclipse.papyrus.resource.uml.UmlModel;
import org.eclipse.papyrus.sasheditor.contentprovider.IPageMngr;
import org.eclipse.papyrus.sasheditor.editor.AbstractMultiPageSashEditor;
import org.eclipse.papyrus.sasheditor.editor.ISashWindowsContainer;
import org.eclipse.ui.IEditorPart;
import org.topcased.requirement.bundle.papyrus.Activator;
import org.topcased.requirement.bundle.papyrus.internal.Messages;
import org.topcased.requirement.bundle.papyrus.resource.RequirementModel;
import org.topcased.requirement.core.extensions.IEditorServices;
import org.topcased.requirement.core.views.AbstractRequirementPage;

/**
 * This class provides services for using requirements with the papyrus core editor. It is intended to be used only by
 * extension point org.topcased.requirement.core.supportingEditors.
 * 
 * @author vhemery
 */
public class PapyrusEditorServices implements IEditorServices
{
[...]


    /**
     * Get the currently active Papyrus diagram editor.
     * 
     * @return the editor part or null.
     */
    public IEditorPart getActiveEditor()
    {
        return EditorUtils.getMultiDiagramEditor();
    }
[...]

    /**
     * Sets the selection state for the editor to reveal the position of the given EObject.<br>
     * It searches in the different diagrams the occurrences of the EObject and ask the user to select the destination
     * if the given EObject has several graphical representation.
     * 
     * @param editor the editor or null for currently active one
     * @param listOfEObjects list of eobjects to select
     * @param openDiagramIfNeeded if true, when the object is not in current active diagram, a representing diagram will
     *        open
     */
    public void gotoEObjects(IEditorPart editor, List<EObject> listOfEObjects, boolean openDiagramIfNeeded)
    {
        if (editor == null)
        {
            editor = getActiveEditor();
        }
        if (editor instanceof IMultiDiagramEditor)
        {
            List<EditPart> editPartsToSelect = new ArrayList<EditPart>(listOfEObjects.size());
            // find appropriate viewer and edit parts to select
            EditPartViewer currentViewer = getGraphicalViewer(editor);
            Map< ? , ? > currentRegistry = currentViewer.getEditPartRegistry();
            if (openDiagramIfNeeded)
            {
                /*
                 * Reference diagrams which represent these elements to know the best one (with most represented
                 * elements)
                 */
                Map<Diagram, Integer> numberOfRepresentedElementsByDiagram = new HashMap<Diagram, Integer>();
                for (EObject toSelect : listOfEObjects)
                {
                    Set<Diagram> diagramsRepresentingThisObject = new HashSet<Diagram>();
                    List< ? > views = DiagramEditPartsUtil.getEObjectViews(toSelect);
                    for (Object view : views)
                    {
                        if (view instanceof View && !(view instanceof Diagram))
                        {
                            Diagram diagram = ((View) view).getDiagram();
                            // test if a representation has already been counted for this diagram
                            if (!diagramsRepresentingThisObject.contains(diagram))
                            {
                                // the element is represented in this diagram
                                diagramsRepresentingThisObject.add(diagram);
                                if (!numberOfRepresentedElementsByDiagram.containsKey(diagram))
                                {
                                    numberOfRepresentedElementsByDiagram.put(diagram, 0);
                                }
                                Integer num = numberOfRepresentedElementsByDiagram.get(diagram);
                                numberOfRepresentedElementsByDiagram.put(diagram, num + 1);
                            }
                        }
                    }
                }
                // find diagram where the largest number of elements are available
                Diagram bestDiagram = null;
                int numberOfRepresented = 0;
                for (Entry<Diagram, Integer> entry : numberOfRepresentedElementsByDiagram.entrySet())
                {
                    if (entry.getValue() > numberOfRepresented)
                    {
                        // take better diagram
                        bestDiagram = entry.getKey();
                        numberOfRepresented = entry.getValue();
                    }
                    else if (entry.getValue() == numberOfRepresented)
                    {
                        // take the currently opened diagram if it is as good
                        if (currentRegistry.get(entry.getKey()) != null)
                        {
                            bestDiagram = entry.getKey();
                        }
                    }
                }
                // change active diagram if necessary
                if (bestDiagram != null && currentRegistry.get(bestDiagram) == null)
                {
                    Object pageMngr = editor.getAdapter(IPageMngr.class);
                    if (pageMngr instanceof IPageMngr)
                    {
                        IPageMngr pageManager = (IPageMngr) pageMngr;
                        if (pageManager.isOpen(bestDiagram))
                        {
                            // bring to top
                            pageManager.closePage(bestDiagram);
                            pageManager.openPage(bestDiagram);
                        }
                        else
                        {
                            // open
                            pageManager.openPage(bestDiagram);
                        }
                    }
                    currentViewer = getGraphicalViewer(editor);
                    currentRegistry = currentViewer.getEditPartRegistry();
                }
            }
            // select edit parts in the current viewer
            for (EObject toSelect : listOfEObjects)
            {
                List< ? > views = DiagramEditPartsUtil.getEObjectViews(toSelect);
                for (Object view : views)
                {
                    if (currentRegistry.containsKey(view))
                    {
                        Object part = currentRegistry.get(view);
                        if (part instanceof EditPart)
                        {
                            editPartsToSelect.add((EditPart) part);
                        }
                    }
                }
            }
            // select edit parts if selection has to change
            if (!(editPartsToSelect.containsAll(currentViewer.getSelectedEditParts()) && currentViewer.getSelectedEditParts().contains(editPartsToSelect)))
            {
                boolean firstSelectedPartInViewer = true;
                for (EditPart editPart : editPartsToSelect)
                {
                    if (firstSelectedPartInViewer)
                    {
                        currentViewer.select(editPart);
                        firstSelectedPartInViewer = false;
                    }
                    else
                    {
                        currentViewer.appendSelection(editPart);
                    }
                }
            }
        }
    }
[...]

    /**
     * Get the graphical viewer of the editor.
     * 
     * @param editor the editor or null for currently active one
     * @return the graphical viewer.
     */
    public EditPartViewer getGraphicalViewer(IEditorPart editor)
    {
        if (editor == null)
        {
            editor = getActiveEditor();
        }
        if (editor instanceof IMultiDiagramEditor)
        {
            Object viewer = editor.getAdapter(IDiagramGraphicalViewer.class);
            if (viewer instanceof EditPartViewer)
            {
                return (EditPartViewer) viewer;
            }
        }
        return null;
    }
[...]
}

                EObject model = null;
	
		try {
					
			// Get root element
			model = UmlUtils.getUmlModel().lookupRoot();
			} catch (org.eclipse.papyrus.resource.NotFoundException e) {
			e.printStackTrace();
		}
		
		// Get the model package
		final org.eclipse.uml2.uml.Package modelpackage = (org.eclipse.uml2.uml.Package) model;

		// Add new elements to the model
		TransactionalEditingDomain ted = TransactionUtil.getEditingDomain(model);
		ted.getCommandStack().execute(new RecordingCommand(ted) {
			
			EList<Element> elementsInModel;
			EList<Element> elementsInComponent;
			Component c;
			Port p;
			Interface newItf;
			Stereotype s;
			
			protected void doExecute() {
				
				String text = "";
					
				elementsInModel = modelpackage.allOwnedElements();
				
				/*
				 * Get all the components in the model.
				 */
				
				for (int i=0; i<elementsInModel.size(); i++) {
					if (elementsInModel.get(i).eClass().getName().compareTo("Component") == 0) {
						c = (Component) elementsInModel.get(i);
						text = text + "Component: " + c.getName() + System.getProperty("line.separator");
						/*
						 * For each component, get all the ports (stereotyped).
						 */
						elementsInComponent = c.getOwnedElements();
						for (int j=0; j<elementsInComponent.size(); j++) {
							if (elementsInComponent.get(j).eClass().getName().compareTo("Port") == 0) {
								p = (Port) elementsInComponent.get(j);
								text = text + "      Port: " + p.getName() + System.getProperty("line.separator");
								/*
								 * For each port, generate a new Interface, stereotyped with the same
								 * stereotype as the port.
								 * Rename the port from [name] to [_name].
								 * Associate the new interface to its corresponding port
								 * by typing the port with the new interface
								 * (port.setType(newInterface)).
								 */
								newItf = c.createOwnedInterface(p.getName());
								p.setName("_" + p.getName());
								s = p.getAppliedStereotypes().get(0);
								newItf.applyStereotype(s);
								p.setType(newItf);
								
								text = text + "      New inteface: " + newItf.getName() + System.getProperty("line.separator");
							}
						}
					}
				}
				JOptionPane.showMessageDialog(null, text);				
			}
		});
		
		/*
		 * Generate the Class diagram containing all the newly created
		 * interfaces.
		 */
		
		DropObjectsRequest dropObjectsRequest = new DropObjectsRequest();
		ArrayList list = new ArrayList();
		EList<Element> elementsInModel = modelpackage.allOwnedElements();
		for (int i=0; i<elementsInModel.size(); i++) {
			if (elementsInModel.get(i).eClass().getName().compareTo("Interface") == 0)
				list.add((org.eclipse.uml2.uml.Element)elementsInModel.get(i));
		}
		dropObjectsRequest.setObjects(list);
		dropObjectsRequest.setLocation(new Point(20,100));
		Command commandDrop = getDiagramEditPart().getCommand(dropObjectsRequest);
		
		((UmlClassDiagramForMultiEditor) EditorUtils.getMultiDiagramEditor().getActiveEditor()).getDiagram();
		
		getDiagramEditPart().getDiagramEditDomain().getDiagramCommandStack().execute(commandDrop);

                /*
		 *  Add a new initial node to the model
		 */
		// get transactional editing domain
		TransactionalEditingDomain transactionalEditingDomain = null;
		try {
			ServicesRegistry serviceRegistry = ServiceUtilsForActionHandlers
					.getInstance().getServiceRegistry();
			transactionalEditingDomain = ServiceUtils.getInstance()
					.getTransactionalEditingDomain(serviceRegistry);
		} catch (ServiceException e) {
			e.printStackTrace();
		}

		// get activity
		TreeIterator<Notifier> allContents = transactionalEditingDomain
				.getResourceSet().getAllContents();
		Activity activity = null;
		while (allContents.hasNext()) {
			Notifier not = allContents.next();

			if (not instanceof Activity) {
				activity = (Activity) not;
			}
		}

		// create new initial node
		InitialNode element = UMLFactory.eINSTANCE.createInitialNode();
		element.setName("InitialNode123");

		// add initial node to activity
		transactionalEditingDomain.getCommandStack().execute(
				SetCommand.create(transactionalEditingDomain, element,
						UMLPackage.eINSTANCE.getActivityNode_Activity(),
						activity));
		

		/*
		 * Visualize initial node
		 */
		DropObjectsRequest dropObjectsRequest = new DropObjectsRequest();
		ArrayList<Element> list = new ArrayList<Element>();
		EObject model = null;

		try {
			// Get root element
			model = UmlUtils.getUmlModel().lookupRoot();
		} catch (org.eclipse.papyrus.resource.NotFoundException e) {
			e.printStackTrace();
		}
		// Get the model package
		final org.eclipse.uml2.uml.Package modelpackage = (org.eclipse.uml2.uml.Package) model;

		// find all initial nodes and add them to the list
		EList<Element> elementsInModel = modelpackage.allOwnedElements();
		for (int i = 0; i < elementsInModel.size(); i++) {
			if (elementsInModel.get(i).eClass().getName()
					.compareTo("InitialNode") == 0) {
				list.add((org.eclipse.uml2.uml.Element) elementsInModel.get(i));
			}
		}
		dropObjectsRequest.setObjects(list);
		dropObjectsRequest.setLocation(new Point(20, 100));

		// get the currently opened editor
		IEditorPart editorPart = PlatformUI.getWorkbench()
				.getActiveWorkbenchWindow().getActivePage().getActiveEditor();
		ServicesRegistry serviceRegistry = (ServicesRegistry) editorPart
				.getAdapter(ServicesRegistry.class);
		DiagramEditor diagramEditor = null;
		try {
			diagramEditor = (DiagramEditor) ServiceUtils.getInstance()
					.getNestedActiveIEditorPart(serviceRegistry);
		} catch (ServiceException e) {
			e.printStackTrace();
		} catch (ClassCastException e) {
			e.printStackTrace();
		}
		DiagramEditPart diagramEditPart = diagramEditor.getDiagramEditPart();
		
		// create and execute command to drop the initial nodes
		Command commandDrop = diagramEditPart.getCommand(dropObjectsRequest);
		diagramEditPart.getDiagramEditDomain().getDiagramCommandStack()
				.execute(commandDrop);