/*******************************************************************************
 * Copyright (C) 2017 Fondazione Bruno Kessler.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 * 
 * Contributors:
 *     Alberto Debiasi - initial API and implementation
 ******************************************************************************/
package org.polarsys.chess.contracts.contractEditor;

import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.transaction.RecordingCommand;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.papyrus.infra.widgets.editors.TreeSelectorDialog;
import org.eclipse.papyrus.uml.diagram.composite.part.Messages;
import org.eclipse.papyrus.uml.tools.providers.UMLContentProvider;
import org.eclipse.papyrus.uml.tools.providers.UMLLabelProvider;
import org.eclipse.swt.widgets.Display;
import org.eclipse.uml2.uml.Class;
import org.eclipse.uml2.uml.Constraint;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.Profile;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.Stereotype;
import org.eclipse.uml2.uml.UMLPackage;
import org.polarsys.chess.contracts.profile.chesscontract.FormalProperty;
import org.polarsys.chess.contracts.profile.chesscontract.util.ContractEntityUtil;
import org.polarsys.chess.contracts.profile.chesscontract.util.EntityUtil;
import org.polarsys.chess.service.core.model.ChessSystemModel;
import org.polarsys.chess.service.gui.utils.SelectionUtil;

import eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab;
import eu.fbk.eclipse.standardtools.utils.core.model.AbstractSystemModel;

/**
 * This is the contract editor designed for the CHESS platform. It extends the
 * ContractEditorTab that is designed to be extended and contains standard
 * methods not related to specific technologies. The only rule is that it
 * requires Eclipse based platforms.
 *
 */
public class CustomContractEditorTab extends ContractEditorTab {

	private ContractEntityUtil contractEntityUtil = ContractEntityUtil.getInstance();
	private SelectionUtil selectionUtil = SelectionUtil.getInstance();
	private EntityUtil entityUtil = EntityUtil.getInstance();

	@Override
	public Resource getResourceFromContract(Object contract) {
		return ((Class) contract).eResource();
	}

	public String getContractQualifiedName(Object contract) {
		if (contract != null) {
			return ((Class) contract).getQualifiedName();
		}
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #returnComponent(org.eclipse.jface.viewers.ISelection)
	 */
	@Override
	public Object returnComponent(ISelection selection) {

		Object selectedUmlElement = selectionUtil.getUmlSelectedObject(selection);

		if (selectedUmlElement instanceof Property) {
			if (entityUtil.isComponentInstance((Property) selectedUmlElement)) {
				Element umlClass = entityUtil.getUmlType((Property) selectedUmlElement);

				if (!contractEntityUtil.isContract(umlClass)) {
					return umlClass;
				}
			}
		} else if (selectedUmlElement instanceof Class) {
			if (!contractEntityUtil.isContract((Class) selectedUmlElement)) {
				return selectedUmlElement;
			}
		}

		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #returnContract(org.eclipse.jface.viewers.ISelection)
	 */
	@Override
	public Object returnContract(ISelection selection) {

		Object selectedUmlElement = selectionUtil.getUmlSelectedObject(selection);

		if (selectedUmlElement instanceof Property) {
			if (contractEntityUtil.isContractProperty((Property) selectedUmlElement)) {
				return entityUtil.getUmlType((Property) selectedUmlElement);
			}

			if (entityUtil.isComponentInstance((Property) selectedUmlElement)) {
				Element classType = entityUtil.getUmlType((Property) selectedUmlElement);
				if (contractEntityUtil.isContract(classType)) {
					return classType;
				}
			}
		} else if (selectedUmlElement instanceof Class) {
			if (contractEntityUtil.isContract((Class) selectedUmlElement)) {
				return selectedUmlElement;
			}
		}

		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #getContractListStr(java.lang.Object)
	 */
	@Override
	public String[] getContractListStr(Object component) {
		EList<String> contractNames = new BasicEList<String>();

		for (Property prop : ((Class) component).getAttributes()) {
			if (contractEntityUtil.isContractProperty(prop)) {
				if (prop.getType() == null) {
					contractNames.add(prop.getName() + " : <TYPE NOT DEFINED>");
				} else {
					contractNames.add(prop.getName() + " : " + prop.getType().getName());
				}
			}
		}

		String[] contractNamesArr = new String[contractNames.size()];
		return contractNames.toArray(contractNamesArr);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #extractContractFromComponent(java.lang.Object, java.lang.String)
	 */
	@Override
	public Object extractContractFromComponent(Object component, String contractName) {
		return contractEntityUtil.getUmlContract((Class) component, contractName);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #createAssumption(java.lang.Object)
	 */
	@Override
	public void createAssumption(Object contract) {
		TransactionalEditingDomain domain = TransactionUtil.getEditingDomain(contract);
		domain.getCommandStack().execute(new RecordingCommand(domain) {

			@Override
			protected void doExecute() {
		contractEntityUtil.createAssumptionToUmlContract((Class) contract);
			}});
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #browseAssumptionButtonPressed(java.lang.Object)
	 */
	@Override
	public String browseAssumptionButtonPressed(Object contract) {

		TransactionalEditingDomain domain = TransactionUtil.getEditingDomain(contract);
		domain.getCommandStack().execute(new RecordingCommand(domain) {

			@Override
			protected void doExecute() {
				Constraint assumeConstraint = selectProperty(contract);
				if (assumeConstraint != null) {
					contractEntityUtil.assignUmlConstraintAssumptionToUmlContract(assumeConstraint, (Class) contract);
				}
			}
		});
		return contractEntityUtil.getAssumeStrFromUmlContract((Class) contract);

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #createGuarantee(java.lang.Object)
	 */
	@Override
	public void createGuarantee(Object contract) {
		TransactionalEditingDomain domain = TransactionUtil.getEditingDomain(contract);
		domain.getCommandStack().execute(new RecordingCommand(domain) {

			@Override
			protected void doExecute() {
		contractEntityUtil.createGuaranteeToUmlContract((Class) contract);
			}});
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #browseGuaranteeButtonPressed(java.lang.Object)
	 */
	@Override
	public String browseGuaranteeButtonPressed(Object contract) {
		TransactionalEditingDomain domain = TransactionUtil.getEditingDomain(contract);
		domain.getCommandStack().execute(new RecordingCommand(domain) {

			@Override
			protected void doExecute() {
				Constraint guaranteeConstraint = selectProperty(contract);
				if (guaranteeConstraint != null) {
					contractEntityUtil.assignUmlConstraintGuaranteeToUmlContract(guaranteeConstraint, (Class) contract);
				}

			}
		});
		return contractEntityUtil.getGuaranteeStrFromUmlContract((Class) contract);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #guaranteeEditorchanged(java.lang.Object, java.lang.String)
	 */
	@Override
	public void guaranteeEditorchanged(Object contract, String textChanged) {
		TransactionalEditingDomain domain = TransactionUtil.getEditingDomain(contract);
		domain.getCommandStack().execute(new RecordingCommand(domain) {

			@Override
			protected void doExecute() {
		contractEntityUtil.setTextToGuaranteeOrCreateGuarantee(textChanged, (Class) contract);
			}
		});
			}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #assumptionEditorchanged(java.lang.Object, java.lang.String)
	 */
	@Override
	public void assumptionEditorchanged(Object contract, String textChanged) {
		TransactionalEditingDomain domain = TransactionUtil.getEditingDomain(contract);
		domain.getCommandStack().execute(new RecordingCommand(domain) {

			@Override
			protected void doExecute() {
		contractEntityUtil.setTextToAssumeOrCreateAssume(textChanged, (Class) contract);
			}
		});
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #getContractName(java.lang.Object)
	 */
	public String getContractName(Object contract) {
		if (contract != null) {
			return ((Class) contract).getQualifiedName();
		}
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #getAssumeStrFromContract(java.lang.Object)
	 */
	@Override
	public String getAssumeStrFromContract(Object contract) {
		return (contractEntityUtil.getAssumeStrFromUmlContract((Class) contract));
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #getAssumeQualifiedNameFromContract(java.lang.Object)
	 */
	@Override
	public String getAssumeQualifiedNameFromContract(Object contract) {
		FormalProperty assumeFormalProperty = contractEntityUtil.getAssumeFromUmlContract((Class) contract);
		
		if (assumeFormalProperty != null) {
			return assumeFormalProperty.getBase_Constraint().getQualifiedName();
		}
		else {
			return "no Assume defined";
		}
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #getGuaranteeStrFromContract(java.lang.Object)
	 */
	@Override
	public String getGuaranteeStrFromContract(Object contract) {
		return (contractEntityUtil.getGuaranteeStrFromUmlContract((Class) contract));
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #getGuaranteeQualifiedNameFromContract(java.lang.Object)
	 */
	@Override
	public String getGuaranteeQualifiedNameFromContract(Object contract) {
		FormalProperty guaranteeFormalProperty = contractEntityUtil.getGuaranteeFromUmlContract((Class) contract);
		
		if (guaranteeFormalProperty != null) {
			return guaranteeFormalProperty.getBase_Constraint().getQualifiedName();
		}
		else {
			return "no Guarantee defined";
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * eu.fbk.eclipse.standardtools.contractEditor.propertyTab.ContractEditorTab
	 * #createContractProperty(java.lang.Object, java.lang.String)
	 */
	@Override
	public void createContractProperty(Object component, String propertyName) {
		TransactionalEditingDomain domain = TransactionUtil.getEditingDomain(component);
		domain.getCommandStack().execute(new RecordingCommand(domain) {

			@Override
			protected void doExecute() {
		contractEntityUtil.createContractPropertyToUmlComponent((Class) component, propertyName);
			}});
	}

	/**
	 * It allows the user to select a formal property to be used as assumption
	 * or guarantee of a contract.
	 * 
	 * @param contract
	 *            the contract
	 * @return the formal property selected
	 */
	private Constraint selectProperty(Object contract) {
		TreeSelectorDialog dialog = new TreeSelectorDialog(Display.getDefault().getActiveShell());
		org.eclipse.uml2.uml.Package pkg = entityUtil.getToPackage((Class) contract);
		// Profile profile = null;
		Profile profile = pkg.getAppliedProfile("CHESSContract", true);
		Stereotype formalPropertyStereotype = profile.getOwnedStereotype("FormalProperty");
		UMLContentProvider provider = new UMLContentProvider(pkg,
				// contract.getOwner(),
				UMLPackage.eINSTANCE.getPackage_PackagedElement(), formalPropertyStereotype);
		dialog.setContentProvider(provider);
		dialog.setLabelProvider(new UMLLabelProvider());
		dialog.setMessage(Messages.UMLModelingAssistantProviderMessage);
		dialog.setTitle(Messages.UMLModelingAssistantProviderTitle);
		if (dialog.open() == org.eclipse.jface.window.Window.OK) {
			Object[] result = dialog.getResult();
			if (result != null && result.length > 0 && result[0] instanceof Constraint) {
				return (Constraint) result[0];
			}
		}
		return null;
	}

	@Override
	public AbstractSystemModel getSystemModel() {
		return ChessSystemModel.getInstance();
	}

}