/*******************************************************************************
 * Copyright (c) 2008, 2012 IBM Corporation, University of Stuttgart (IAAS) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation, University of Stuttgart (IAAS) - initial API and implementation
 *******************************************************************************/

package org.eclipse.bpel.apache.ode.deploy.ui.editors;

import java.io.IOException;
import java.util.Collections;
import java.util.EventObject;
import java.util.HashMap;
import java.util.Vector;

import org.eclipse.bpel.apache.ode.deploy.model.dd.DocumentRoot;
import org.eclipse.bpel.apache.ode.deploy.model.dd.ProcessType;
import org.eclipse.bpel.apache.ode.deploy.model.dd.TDeployment;
import org.eclipse.bpel.apache.ode.deploy.model.dd.util.ddResourceFactoryImpl;
import org.eclipse.bpel.apache.ode.deploy.ui.messages.ODEDeployUIMessages;
import org.eclipse.bpel.apache.ode.deploy.ui.pages.ProcessPage;
import org.eclipse.bpel.apache.ode.deploy.ui.util.DeployUtils;
import org.eclipse.bpel.model.BPELFactory;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceVisitor;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.emf.common.command.BasicCommandStack;
import org.eclipse.emf.common.command.CommandStackListener;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.domain.IEditingDomainProvider;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.ui.util.EditUIUtil;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.forms.editor.FormEditor;

/**
 * A multipage editor for Apache ODE deployment descriptors.
 * 
 * @author Tammo van Lessen (IAAS)
 * @author Simon Moser (IBM)
 */
public class ODEDeployMultiPageEditor extends FormEditor implements IEditingDomainProvider {

	private boolean readOnly = false;
	// https://jira.jboss.org/jira/browse/JBIDE-6230
	// if BPEL processes were added or deleted, DD model is not in sync and needs to be saved 
	private boolean modelInSync = true;
	protected TDeployment deployDescriptor = null;	
	
	protected AdapterFactoryEditingDomain editingDomain;
	protected ComposedAdapterFactory adapterFactory;

	
	/**
	 * Creates a multi-page editor example.
	 */
	public ODEDeployMultiPageEditor() {
		super();
		initializeEditingDomain();
	}
	
	/**
	 * Saves the deployment descriptor
	 */
	public void doSave(IProgressMonitor monitor) {
		commitPages(true);
		saveDeploymentDescriptor();
		((BasicCommandStack)editingDomain.getCommandStack()).saveIsDone();
		modelInSync = true;
		firePropertyChange(IEditorPart.PROP_DIRTY);
	}
	
	/**
	 * SaveAs is not supported.
	 */
	public void doSaveAs() {
		throw new UnsupportedOperationException(ODEDeployUIMessages.ODEDeployEditor_No_SaveAs);
	}
	
	/**
	 * The implementation of this method checks that the input is an 
	 * instance of <code>IFileEditorInput</code> and creates the data model.
	 */
	public void init(IEditorSite site, IEditorInput editorInput) throws PartInitException {
		super.init(site, editorInput);
		setPartName(editorInput.getName());
		
		if (!(editorInput instanceof IFileEditorInput)) {
			throw new PartInitException(ODEDeployUIMessages.ODEDeployEditor_InvalidInput);
		}
		
		createModel();
	}

	public boolean isSaveAsAllowed() {
		return false;
	}

	public void saveDeploymentDescriptor() {
		try {			
			// Bugzilla 320545:
			// editor will be "read only" if there are no BPEL resources to process
			if (!readOnly)
			deployDescriptor.eResource().save(null);
		} 
		catch (IOException e1) {
			e1.printStackTrace();
		}
	}
	
	protected org.eclipse.bpel.model.Process loadBPEL(IFile bpelFile) {
		IPath fullProcessPath = bpelFile.getFullPath();
		URI uri = URI.createPlatformResourceURI(fullProcessPath.toString(), false);
		Resource bpelResource = editingDomain.getResourceSet().getResource(uri, true);

		try {
			bpelResource.load(Collections.EMPTY_MAP);
			EList<EObject> contents = bpelResource.getContents();
			if (!contents.isEmpty()) {
				return (org.eclipse.bpel.model.Process) contents.get(0);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;

	}

	@Override
	protected void addPages() {		
		try {
			for (ProcessType pt : deployDescriptor.getProcess()) {
				addPage(new ProcessPage(this, pt));
			}
		} 
		catch (PartInitException e) {
			// ~
		}
	}
	
	public TDeployment getDeploymentModel(){
		return deployDescriptor;
	}

	protected void initializeEditingDomain() {
		adapterFactory = new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE);

		// Create the command stack that will notify this editor as commands are executed.
		BasicCommandStack commandStack = new BasicCommandStack();

		// Add a listener to set the most recent command's affected objects to be the selection of the viewer with focus.
		commandStack.addCommandStackListener
			(new CommandStackListener() {
				 public void commandStackChanged(final EventObject event) {
					 getContainer().getDisplay().asyncExec
						 (new Runnable() {
							  public void run() {
								  editorDirtyStateChanged();
							  }
						  });
				 }
			 });

		// Create the editing domain with a special command stack.
		editingDomain = new AdapterFactoryEditingDomain(adapterFactory, commandStack, new HashMap<Resource, Boolean>());
	}

	public EditingDomain getEditingDomain() {
		return editingDomain;
	}

	@Override
	public boolean isDirty() {
		return !readOnly && // Bugzilla 320545:
			(
					((BasicCommandStack) editingDomain.getCommandStack()).isSaveNeeded() ||
					!modelInSync
			);
	}
	
	@Override
	public void setFocus() {
		if (getActivePage() != -1 && getControl(getActivePage()) != null) {
			getControl(getActivePage()).setFocus();
		}
	}
	
	protected void createModel() throws PartInitException {
		URI resourceURI = EditUIUtil.getURI(getEditorInput());
		Resource resource = null;

		ddResourceFactoryImpl fac = new ddResourceFactoryImpl();
		resource = fac.createResource(resourceURI);
		editingDomain.getResourceSet().getResources().add(resource);
		try {
			resource.load(Collections.EMPTY_MAP);
			
			EList<EObject> contents = resource.getContents();
			if (!contents.isEmpty() && contents.get(0) instanceof DocumentRoot) {
				deployDescriptor = ((DocumentRoot) contents.get(0)).getDeploy();
				
				populateModel();
			}
		} catch (CoreException e) {
			throw new PartInitException(e.getStatus());
		} catch (IOException e) {
			throw new PartInitException(e.getMessage(), e);
		}
		if (deployDescriptor.getProcess().isEmpty()) {
			// https://jira.jboss.org/jira/browse/JBIDE-6006
			// add a process stub to DD so the editor doesn't crash
			org.eclipse.bpel.model.Process p = BPELFactory.eINSTANCE.createProcess();
			p.setName(ODEDeployUIMessages.ODEDeployEditor_NO_PROCESSES_FOUND);
			ProcessType pt = DeployUtils.createProcessStub(p);
			deployDescriptor.getProcess().add(pt);
			// set model
			pt.setModel(p);
			readOnly = true; // can't save editor anyway
			modelInSync = true; // so it might as well be in sync
		}
	}

	public void populateModel() throws CoreException {
		final Vector<ProcessType> processesFound = new Vector<ProcessType>();
		((IFileEditorInput)getEditorInput()).getFile().getProject().accept(new IResourceVisitor() {
			public boolean visit(IResource bpelfile) throws CoreException {
				// Bugzilla 320545:
				if (DeployUtils.isBPELFile(bpelfile)) {
					org.eclipse.bpel.model.Process p = DeployUtils.loadBPEL((IFile)bpelfile, editingDomain.getResourceSet());
					if (p != null) {
						// add process to DD unless it is not already there.
						ProcessType pt = DeployUtils.findProcessTypeInDD(p, deployDescriptor); 
						if (pt == null) {
							pt = DeployUtils.createProcessStub(p);
							deployDescriptor.getProcess().add(pt);
							modelInSync = false; // need to do a save
						}
						// set model
						pt.setModel(p);
						
						processesFound.add(pt);
					}
				}
				return true;
			}
		});
		// Bugzilla 320545:
		// figure out which BPEL processes are missing from the workspace
		// and remove them from the DD model
		Vector<ProcessType> processesToDelete = new Vector<ProcessType>();
		for(ProcessType pt : deployDescriptor.getProcess())
		{
			if (!processesFound.contains(pt))
				processesToDelete.add(pt);
		}
		if ( processesToDelete.size()>0)
		{
			deployDescriptor.getProcess().removeAll(processesToDelete);
			modelInSync = false; // need to do a save
		}
	}
}