package org.eclipse.epf.diagramming.base.util;

import java.io.File;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.operations.OperationHistoryFactory;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.common.util.URI;
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.command.CopyCommand.Helper;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.impl.InternalTransactionalEditingDomain;
import org.eclipse.epf.common.CommonPlugin;
import org.eclipse.epf.diagram.core.bridge.ActivityDiagramAdapter;
import org.eclipse.epf.diagram.core.part.DiagramEditorInput;
import org.eclipse.epf.diagram.core.part.DiagramEditorInputProxy;
import org.eclipse.epf.diagram.core.part.DiagramFileEditorInputProxy;
import org.eclipse.epf.diagramming.base.commands.CreateDiagramCommand;
import org.eclipse.epf.diagramming.base.persistence.DiagramFileCreatorEx;
import org.eclipse.epf.diagramming.base.persistence.DiagramService;
import org.eclipse.epf.diagramming.base.persistence.IDiagramService;
import org.eclipse.epf.diagramming.part.EPFDiagramEditorPlugin;
import org.eclipse.epf.diagramming.part.UMLDiagramFileCreator;
import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.library.edit.process.BreakdownElementWrapperItemProvider;
import org.eclipse.epf.library.edit.process.command.ActivityDropCommand;
import org.eclipse.epf.library.edit.util.IDiagramManager;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.persistence.MethodLibraryPersister;
import org.eclipse.epf.persistence.MultiFileSaveUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.CapabilityPattern;
import org.eclipse.epf.uma.DeliveryProcess;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.util.UmaUtil;
import org.eclipse.gmf.runtime.common.core.command.CommandResult;
import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;
import org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramWorkbenchPart;
import org.eclipse.gmf.runtime.diagram.ui.resources.editor.ide.util.IDEEditorUtil;
import org.eclipse.gmf.runtime.diagram.ui.resources.editor.parts.DiagramDocumentEditor;
import org.eclipse.gmf.runtime.diagram.ui.resources.editor.util.DiagramFileCreator;
import org.eclipse.gmf.runtime.diagram.ui.resources.editor.util.EditorUtil;
import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand;
import org.eclipse.gmf.runtime.emf.core.GMFEditingDomainFactory;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.jface.operation.IRunnableContext;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorDescriptor;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.ide.IDE;


/**
 * 
 * @author Shashidhar Kannoori
 * @author Shilpa Toraskar
 * @author Phong Nguyen Le
 */
public class DiagramEditorUtil extends IDEEditorUtil {

	public static final String kind = "AD";
	public static final String default_file_name = "diagram";
	public static final String create_diagram_label = "Create diagram and model";
	private static final String AD_EDITOR_ID = "org.eclipse.epf.diagramming.part.DiagramEditorID"; //$NON-NLS-1$

	private static String getEditorId(int diagramType) {
		switch(diagramType) {
		case IDiagramManager.ACTIVITY_DIAGRAM:
			return AD_EDITOR_ID;
		}
		return null;
	}
	
	public static IEditorPart openDiagramEditor(IWorkbenchPage page, DiagramEditorInput input, IProgressMonitor progressMonitor) {
		DiagramEditorInputProxy diagramFileEditorInput = new DiagramEditorInputProxy(input, EPFDiagramEditorPlugin.DIAGRAM_PREFERENCES_HINT);

		IEditorPart editorPart = null;
		try {
			editorPart = page.openEditor(diagramFileEditorInput, getEditorId(input.getDiagramType()), true);
		} catch (PartInitException e) {
			CommonPlugin.getDefault().getLogger().logError(e);
		}

		// initialize the diagram by synchronizing it with library data
		//
		if(editorPart instanceof IDiagramWorkbenchPart) {
			DiagramEditPart editPart = ((IDiagramWorkbenchPart)editorPart).getDiagramEditPart();
			((DiagramDocumentEditor)editorPart).getDocumentProvider().setCanSaveDocument(diagramFileEditorInput);
			initialize((Diagram) editPart.getModel(), diagramFileEditorInput);
		}
		return editorPart;
	}

	/**
	 * To open a diagram and create a file.
	 * @written
	 */
	public static void openDiagramEditor(IWorkbenchPage page, IEditorInput input){
		
		MethodElement process = (MethodElement)((DiagramEditorInput)input).getMethodElement();
		IPath containerPath = getContainerPath(process);
		
		createAndOpenDiagram(
				UMLDiagramFileCreator.getInstance(), containerPath, default_file_name,
				EditorUtil.getInitialContents(), kind, page, new NullProgressMonitor(),
				true, false, input);
	}
	
	
	/**
	 * @generated
	 */
	public static final IFile createAndOpenDiagram(
			DiagramFileCreator diagramFileCreator, IPath containerPath,
			String fileName, InputStream initialContents, String kind,
			IWorkbenchPage page, IProgressMonitor progressMonitor,
			boolean openEditor, boolean saveDiagram, IEditorInput input) {
		
		IFile diagramFile = getFile(fileName, input, diagramFileCreator) ;
		if(diagramFile == null){
			diagramFile = createNewDiagramFile(
				diagramFileCreator, containerPath, fileName, initialContents,
				kind, page.getWorkbenchWindow().getShell(), progressMonitor, input);
		}else{
			
		}
		
//		DiagramFileEditorInput diagramFileEditorInput = new DiagramFileEditorInput(
//				diagramFile, (DiagramEditorInput)input);
		DiagramFileEditorInputProxy diagramFileEditorInput = new DiagramFileEditorInputProxy(
				diagramFile, (DiagramEditorInput)input, null);
		
		if (diagramFile != null && openEditor) {
			IEditorPart editorPart = doOpenDiagramEditor(diagramFileEditorInput, page, saveDiagram, progressMonitor);
			
			// initialize the diagram by synchronizing it with library data
			//
			if(editorPart instanceof IDiagramWorkbenchPart) {
				DiagramEditPart editPart = ((IDiagramWorkbenchPart)editorPart).getDiagramEditPart();
				initialize((Diagram) editPart.getModel(), diagramFileEditorInput);
			}
			// remove the dirty flag
			//
//			if(editorPart instanceof IDocumentEditor) {
//				IDocumentProvider dp = ((IDocumentEditor)editorPart).getDocumentProvider();
//				if(dp instanceof DiagramEditorDocumentProvider) {
//					((DiagramEditorDocumentProvider)dp).unsetCanSaveDocument(editorPart.getEditorInput());
//				}
//			}
		}
		return diagramFile;
	}
	
	private static void initialize(Diagram model, DiagramFileEditorInputProxy diagramFileEditorInput) {
		BreakdownElementWrapperItemProvider wrapper = diagramFileEditorInput.getDiagramEditorInput().getWrapper();
		ActivityDiagramAdapter adapter = wrapper != null ?
				new ActivityDiagramAdapter(wrapper) : 
					new ActivityDiagramAdapter((Activity)diagramFileEditorInput.getDiagramEditorInput().getMethodElement());
		adapter.setEditingDomain((InternalTransactionalEditingDomain) diagramFileEditorInput.getEditingDomain());
		adapter.setSuppression(diagramFileEditorInput.getDiagramEditorInput().getSuppression());
		adapter.setView(model);
		model.getElement().eAdapters().add(adapter);
		adapter.populateDiagram();
	}


	/**
	 * <p>
	 * This method should be called within a workspace modify operation since it creates resources.
	 * </p>
	 * @modified
	 * @return the created file resource, or <code>null</code> if the file was not created
	 */
	public static final IFile createNewDiagramFile(
			DiagramFileCreator diagramFileCreator, IPath containerFullPath,
			String fileName, InputStream initialContents, String kind,
			Shell shell, IProgressMonitor progressMonitor, IEditorInput input) {
		progressMonitor.beginTask("Creating notation diagram and model file", 4); //$NON-NLS-1$
		final IProgressMonitor subProgressMonitor = new SubProgressMonitor(
				progressMonitor, 1);
		final IFile diagramFile = diagramFileCreator.createNewFile(
				containerFullPath, fileName, initialContents, shell,
				new IRunnableContext() {
					public void run(boolean fork, boolean cancelable,
							IRunnableWithProgress runnable)
							throws InvocationTargetException,
							InterruptedException {
						runnable.run(subProgressMonitor);
					}
				});
		
		createDiagramContent(diagramFile, progressMonitor, input);
		return diagramFile;
	}
	
	/**
	 * Creates a diagram file content - GMF notation Diagram and UML Activity,
	 * UMA bridge.
	 * 
	 */
	public static boolean createDiagramContent(IFile diagramFile, IProgressMonitor progressMonitor, IEditorInput input) {

		TransactionalEditingDomain editingDomain = GMFEditingDomainFactory.INSTANCE
				.createEditingDomain();
		ResourceSet resourceSet = editingDomain.getResourceSet();
		final Resource diagramResource = resourceSet
				.createResource(URI.createPlatformResourceURI(diagramFile
						.getFullPath().toString()));
		List affectedFiles = new ArrayList();
		affectedFiles.add(diagramFile);
		CreateDiagramCommand command = new CreateDiagramCommand(editingDomain,
				"Creating diagram and model", affectedFiles, input,
				diagramResource, kind);
		try {
			OperationHistoryFactory.getOperationHistory().execute(command,
					new SubProgressMonitor(progressMonitor, 1), null);
		} catch (ExecutionException e) {
			EPFDiagramEditorPlugin.getInstance().logError(
					"Unable to create model and diagram", e); //$NON-NLS-1$
			return false;
		}
		return true;
	}
	
	/**
	 * Creates a diagram file content - GMF notation Diagram and UML Activity,
	 * UMA bridge.
	 * 
	 */
	public static boolean createDiagramContent(TransactionalEditingDomain editingDomain,
			IFile diagramFile, IProgressMonitor progressMonitor, IEditorInput input,
			Resource resource) {

//		TransactionalEditingDomain editingDomain = GMFEditingDomainFactory.INSTANCE
//				.createEditingDomain();
//		ResourceSet resourceSet = editingDomain.getResourceSet();
//		final Resource diagramResource = resourceSet
//				.createResource(URI.createPlatformResourceURI(diagramFile
//						.getFullPath().toString()));
		List affectedFiles = new ArrayList();
		affectedFiles.add(diagramFile);
		CreateDiagramCommand command = new CreateDiagramCommand(editingDomain,
				"Creating diagram and model", affectedFiles, input,
				resource, kind);
		try {
			OperationHistoryFactory.getOperationHistory().execute(command,
					new SubProgressMonitor(progressMonitor, 1), null);
		} catch (ExecutionException e) {
			EPFDiagramEditorPlugin.getInstance().logError(
					"Unable to create model and diagram", e); //$NON-NLS-1$
			return false;
		}
		return true;
	}
	/**
	 * @written
	 */
	public static IPath getContainerPath(){
		IPath path = EditorUtil.getDefaultDiagramPath(null, null);
		if (path == null) {
				IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
				IProject[] projects = root.getProjects();

				path = root.getFullPath();

				for (int i = 0; i < projects.length; ++i) {
					IProject project = projects[i];

					if (project.isOpen()) {
						path = project.getFullPath();
						break;
					}
				}
		}
		return path;
	}
	
	/**
	 * Opens the diagram in an IEditorPart
	 *  
	 * @param file IFile that contains the diagram
	 * @param dWindow the workbench window
	 * @param saveDiagram true to save the diagram after opening, false to not
	 * save it.
	 * @param progressMonitor used when opening the diagram.
	 * For now, it is only used when the diagram is being saved after opening.
	 *  
	 * @return DiagramEditPart for the diagram opened in an IEditorPart.
	 */
	public static final DiagramEditPart openDiagramEditor(IFileEditorInput input,
			IWorkbenchPage page, boolean saveDiagram,
			IProgressMonitor progressMonitor) {
		IEditorPart editorPart = doOpenDiagramEditor(input, page, saveDiagram, progressMonitor);
		if(editorPart instanceof IDiagramWorkbenchPart) {
			return ((IDiagramWorkbenchPart)editorPart).getDiagramEditPart();
		}
		return null;
	}
	
	public static final IEditorPart doOpenDiagramEditor(IFileEditorInput input,
			IWorkbenchPage page, boolean saveDiagram,
			IProgressMonitor progressMonitor) {
		IEditorPart editorPart = null;
		try {
			//IWorkbenchPage page = dWindow.getActivePage();
			IEditorPart parent = page.getActiveEditor();
			if (page != null) {
				editorPart = openEditor(page, input, true,true);
				if(editorPart != null && parent != null){
					// set the parent.
				}
				// set Active page editor as parent.
				if (saveDiagram)
					editorPart.doSave(progressMonitor);
			}
			input.getFile().refreshLocal(IResource.DEPTH_ZERO, null);
			return editorPart;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}
	
	/**
     * Opens an editor on the given file resource.  This method will attempt to
	 * resolve the editor based on content-type bindings as well as traditional
	 * name/extension bindings if <code>determineContentType</code> is
	 * <code>true</code>.
     * <p>
     * If the page already has an editor open on the target object then that
     * editor is brought to front; otherwise, a new editor is opened. If
     * <code>activate == true</code> the editor will be activated.
     * <p>
     * @param page
     *            the page in which the editor will be opened
     * @param input
     *            the editor input
     * @param activate
     * 			  if <code>true</code> the editor will be activated
     * @param determineContentType
     * 			  attempt to resolve the content type for this file
     * @return an open editor or <code>null</code> if an external editor was
     *         opened
     * @exception PartInitException
     *                if the editor could not be initialized
     * @see org.eclipse.ui.IWorkbenchPage#openEditor(org.eclipse.ui.IEditorInput,
     *      String, boolean)
     * @since 3.1
     */
	public static IEditorPart openEditor(IWorkbenchPage page, IFileEditorInput input,
            boolean activate, boolean determineContentType) throws PartInitException {
        //sanity checks
        if (page == null) {
			throw new IllegalArgumentException();
		}

        // open the editor on the file
        IEditorDescriptor editorDesc = IDE.getEditorDescriptor(input.getFile(), determineContentType);
        return page.openEditor(input, editorDesc.getId(),
                activate);
    }
	
	/**
	 * Check whether file exists or not.
	 * @param szFileName
	 * @param input
	 * @param diagramFileCreator
	 * @return
	 */
	public static IFile getFile(String szFileName, IEditorInput input, DiagramFileCreator diagramFileCreator){
		
		MethodElement e = ((DiagramEditorInput)input).getMethodElement();
		Process srcProc = TngUtil.getOwningProcess((BreakdownElement) e);
		
		IPath containerPath = getContainerPath(e);
		String szNewFileName = szFileName;		
		IPath filePath = containerPath.append(diagramFileCreator.appendExtensionToFileName(szNewFileName));
//		IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
//		if(workspaceRoot.exists(filePath)){
//			IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(filePath);
//			if(file.exists()){
//				return null;
//			}
//		}
		File libDirs = new File(LibraryService.getInstance().getCurrentMethodLibraryPath());
		String diagramPath = libDirs.getAbsolutePath() + File.separator
								+ MethodLibraryPersister.getElementPath(srcProc)
								+ File.separator + srcProc.getName() + File.separator
								+ "diagram.xmi";
		File filex = new File(diagramPath);
		if(filex.exists()){
			return ResourcesPlugin.getWorkspace().getRoot().getFile(filePath);
		}
		return null;
	}
	
	/**
	 * 
	 * 
	 * @param proc
	 * @return
	 * @custom
	 */
	public static IPath getContainerPath(MethodElement e) {

		Process proc = TngUtil.getOwningProcess(e);
		// TODO handle the Wrapper Elements.
		
		if (proc instanceof Process) {
			MethodPlugin plugin = UmaUtil.getMethodPlugin(proc);

			String relativeDir;

			if (proc instanceof CapabilityPattern) {
				relativeDir = MultiFileSaveUtil.CAPABILITY_PATTERN_PATH;
			} else if (proc instanceof DeliveryProcess) {
				relativeDir = MultiFileSaveUtil.DELIVERY_PROCESS_PATH;
			} else {
				relativeDir = ""; //$NON-NLS-1$
			}

			IPath workspacePath = EditorUtil.getDefaultDiagramPath(null, null);
			if (workspacePath == null) {
				IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
				IProject[] projects = root.getProjects();

				workspacePath = root.getFullPath();

				for (int i = 0; i < projects.length; ++i) {
					IProject project = projects[i];

					if (project.isOpen()) {
						workspacePath = project.getFullPath();
						break;
					}
				}
			}

			String libDir = workspacePath.toString();
			String pluginDir = libDir + File.separator + plugin.getName();
			String diagramDir = pluginDir + File.separator + relativeDir
					+ File.separator + proc.getName() + File.separator;
			//System.out.println("Print: " + diagramDir);
			Path path = new Path(diagramDir);
			return path;

			//	 return workspacePath;
		} else
			return null;
	} 

	/**
	 * Check whether file exists or not.
	 * @param szFileName
	 * @param input
	 * @param diagramFileCreator
	 * @return
	 */
	public static IFile getFile(String szFileName, BreakdownElement e, DiagramFileCreator diagramFileCreator){
		
		Process srcProc = TngUtil.getOwningProcess((BreakdownElement) e);
		
		IPath containerPath = getContainerPath(e);
		String szNewFileName = szFileName;		
		IPath filePath = containerPath.append(diagramFileCreator.appendExtensionToFileName(szNewFileName));
//		IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
//		if(workspaceRoot.exists(filePath)){
//			IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(filePath);
//			if(file.exists()){
//				return null;
//			}
//		}
		File libDirs = new File(LibraryService.getInstance().getCurrentMethodLibraryPath());
		String diagramPath = libDirs.getAbsolutePath() + File.separator
								+ MethodLibraryPersister.getElementPath(srcProc)
								+ File.separator + srcProc.getName() + File.separator
								+ "diagram.xmi";
		File filex = new File(diagramPath);
		if(filex.exists()){
			return ResourcesPlugin.getWorkspace().getRoot().getFile(filePath);
		}
		return null;
	}
	
	/**
	 * This method should moved to LibraryEdit or Use NestedCommands using extension.
	 * @param command2
	 */
	protected void copyDiagrams(ActivityDropCommand command2) {
		// TODO Auto-generated method stub
		TransactionalEditingDomain domain = IDiagramService.eInstance.createEditingDomain();
		Helper copyHelper = new Helper();
		Helper copiedHelper = command2.getActivityHandler().getCopyHelper();
		Set keys = copiedHelper.keySet();
		CompoundCommand command = new CompoundCommand(CompoundCommand.MERGE_COMMAND_ALL);
		
		for (Iterator iter = keys.iterator(); iter.hasNext();) {
			EObject key = (EObject) iter.next();
			EObject entry = (EObject)copiedHelper.get(key);
			if(entry instanceof Activity && key instanceof Activity){
				Activity act = (Activity)entry;
				//TODO: Handle different diagrams.
				Diagram diagram = IDiagramService.eInstance.getDiagram((Activity)key, DiagramService.AD_kind, 
						false, new NullProgressMonitor());
				if(diagram != null){
//					CopyDiagramElementCommand cmd = new CopyDiagramElementCommand(
//							domain,diagram.getElement(),copyHelper,act );
//					command.append(cmd);
				}
			}
		}
		try{
			command.execute();
			Process p = command2.getActivityHandler().getTargetProcess();
			// Need to move this code to different place.
//			p.getBr
			IFile file = DiagramEditorUtil.getFile(default_file_name, (BreakdownElement)p, DiagramFileCreatorEx.getInstance());
			if(file == null){
				file = createNewDiagramFile(DiagramFileCreatorEx.getInstance(), p, Display.getCurrent().getActiveShell(), 
						new NullProgressMonitor());
			}
			Set xKeys = copyHelper.keySet();
			for (Iterator iter = xKeys.iterator(); iter.hasNext();) {
				EObject element = (EObject) iter.next();
				if(element instanceof Diagram){
					
				}
			}
			List affectedFiles = new ArrayList();
			affectedFiles.add(file);
			AbstractTransactionalCommand cmd = new AbstractTransactionalCommand(
					domain, "copy diagrams", affectedFiles) {
			
				protected CommandResult doExecuteWithResult(IProgressMonitor monitor,
						IAdaptable info) throws ExecutionException {
					return null;
				}
			
			};
			
			
		}catch(Exception e){
			
		}
		finally{
			command.dispose();
		}
	}

	/**
	 * <p>
	 * This method should be called within a workspace modify operation since it creates resources.
	 * </p>
	 * @modified
	 * @return the created file resource, or <code>null</code> if the file was not created
	 */
	public static final IFile createNewDiagramFile(
			DiagramFileCreatorEx diagramFileCreator, BreakdownElement element, 
			Shell shell, IProgressMonitor progressMonitor ) {
		
		final IPath containerPath = getContainerPath(element);
		final String diagramFileName = DiagramFileCreatorEx.default_diagram_file;
		progressMonitor.beginTask("Creating notation diagram and model file", 4); //$NON-NLS-1$
		final IProgressMonitor subProgressMonitor = new SubProgressMonitor(
				progressMonitor, 1);
		final IFile diagramFile = diagramFileCreator.createNewFile(
				containerPath, diagramFileName, 
				getInitialContents(), shell,
				new IRunnableContext() {
					public void run(boolean fork, boolean cancelable,
							IRunnableWithProgress runnable)
							throws InvocationTargetException,
							InterruptedException {
						runnable.run(subProgressMonitor);
					}
				});
		
		//createDiagramContent(diagramFile, progressMonitor, input);
		progressMonitor.done();
		return diagramFile;
	}
}