/*******************************************************************************
 * Copyright (c) 2009, 2018 SAP AG and others.
 * 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:
 *     SAP AG - initial API and implementation
 ******************************************************************************/
package org.eclipse.ocl.examples.impactanalyzer.editor;

import java.lang.reflect.InvocationTargetException;
import java.util.Collection;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.ui.MarkerHelper;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EValidator;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.Diagnostician;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.edit.ui.EMFEditUIPlugin;
import org.eclipse.emf.edit.ui.action.ValidateAction;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.ocl.ecore.OCL;
import org.eclipse.ocl.ecore.OCLExpression;
import org.eclipse.ocl.ecore.opposites.OppositeEndFinder;
import org.eclipse.ocl.examples.impactanalyzer.ImpactAnalyzer;
import org.eclipse.ocl.examples.impactanalyzer.util.OCLFactory;
import org.eclipse.ui.PlatformUI;


/**
 * Validates a specific constraint on one or more of the context elements that are instance of the constaint's context class or a
 * subclass thereof.
 * <p>
 * 
 * There are {@link Diagnostic} objects maintained as {@link Resource#getErrors() errors} and {@link Resource#getWarnings()
 * warnings} of an EMF resource, and {@link IMarker} objects managed by {@link IResource}s and stored persistently in the
 * workspace, representing validation errors. {@link MarkerHelper} and its subclasses can turn {@link Diagnostic} objects into
 * {@link IMarker}s which form the basis for the problem view display. A {@link MarkerHelper} is used to create {@link IMarker
 * markers} from {@link Diagnostic} objects. Specializations of {@link MarkerHelper} can annotate the markers with additional
 * information stored, e.g., in {@link Diagnostic#getData()} and storing them in {@link IMarker#getAttribute(String) attributes}
 * of the marker. By default, this process is triggered in the <code>updateProblemIndication</code> method of a generated EMF
 * sample editor, where first all markers for the entire {@link ResourceSet} (this seems too broad a scope) are deleted and then
 * created again based on the {@link Diagnostic}s returned from {@link Resource#getErrors()} and {@link Resource#getWarnings()}
 * for the resources contained by the editing domain's resource set.
 * <p>
 * 
 * EMF resources, upon loading, don't perform any constraint validation. Therefore, their errors and warnings list turns out empty
 * by default. Filling those has to happen by explicitly performing a {@link ValidateAction} on selected resources or individual
 * elements. Only then will a {@link Diagnostician} be used to fetch the {@link EValidator} from the validator registry with which
 * a validation is performed on a single {@link EObject}. Such a validation run will produce {@link Diagnostic} objects which the
 * {@link ValidateAction} then converts into {@link IMarker}s again. Note that these {@link Diagnostic} objects are <em>not</em>
 * entered into the errors/warnings of the {@link Resource} on which the validation happened.
 * <p>
 * 
 * When a change {@link Notification} triggers this revalidation action, the constraint is re-evaluated on the context objects
 * determined by the {@link ImpactAnalyzer OCL Impact Analysis}. For any constraint which now evaluates to <code>true</code>, any
 * existing {@link Diagnostic} needs to be removed. FOr any constraint evaluating to <code>false</code> a {@link Diagnostic}
 * object needs to be created, and an {@link IMarker} needs to be created and displayed in the problem view.
 * <p>
 * 
 * During re-validation, the resources of other objects on which to evaluate the constraint may be loaded into the surrounding
 * editing domain's resource set. Markers are managed by a <code>MarkerManager</code> which persistently stores markers in the
 * workspace, keyed by the resources to which they belong.
 * 
 * @author Axel Uhl (D043530)
 * 
 */
public class RevalidateAction extends ValidateAction {
    private static final String MARKER_TYPE = "org.eclipse.core.resources.problemmarker";
    private static final String ELEMENT_URI = "elementuri";
    private static final String CONSTRAINT_NAME = "constraintname";
    private final Collection<EObject> contextObjects;
    private final String constraintName;
    private final OCLExpression invariant;
    private final OppositeEndFinder oppositeEndFinder;
    private final OCLFactory oclFactory;

    public RevalidateAction(String constraintName, Collection<EObject> contextObjects, OCLExpression invariant, OCLFactory oclFactory, OppositeEndFinder oppositeEndFinder) {
        super();
        this.contextObjects = contextObjects;
        this.constraintName = constraintName;
        this.invariant = invariant;
        this.oclFactory = oclFactory;
        this.oppositeEndFinder = oppositeEndFinder;
    }

    @Override
    public void run() {
        IRunnableWithProgress runnableWithProgress = new IRunnableWithProgress() {
            public void run(final IProgressMonitor progressMonitor) throws InvocationTargetException, InterruptedException {
                try {
                    validateConstraints(progressMonitor);
                } catch (CoreException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        if (eclipseResourcesUtil != null) {
            runnableWithProgress = eclipseResourcesUtil.getWorkspaceModifyOperation(runnableWithProgress);
        }

        try {
            // This runs the operation, and shows progress.
            // (It appears to be a bad thing to fork this onto another thread.)
            //
            PlatformUI.getWorkbench().getProgressService().run(/* fork */ true, /* cancelable */ true, runnableWithProgress);
        } catch (Exception exception) {
            EMFEditUIPlugin.INSTANCE.log(exception);
        }
    }

    /**
     * This simply execute the command.
     */
    private void validateConstraints(IProgressMonitor progressMonitor) throws CoreException {
        int selectionSize = contextObjects.size();
        progressMonitor.beginTask("", selectionSize);
        OCL ocl = oclFactory.createOCL(oppositeEndFinder);
        for (EObject eObject : contextObjects) {
            System.out.println("Re-validating "+constraintName+" on "+EcoreUtil.getURI(eObject));
            IFile fileForContext = getFile(eObject);
            URI eObjectURI = EcoreUtil.getURI(eObject);
            removeMarker(eObjectURI, fileForContext);
            boolean valid = (Boolean) ocl.evaluate(eObject, invariant);
            if (!valid) {
                if (fileForContext != null) {
                    IMarker marker = fileForContext.createMarker(MARKER_TYPE);
                    // TODO here's the place to talk about severities of constraint violations
                    marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
                    marker.setAttribute(IMarker.MESSAGE, "Constraint "+constraintName+" violated on "+eObject);
                    marker.setAttribute(CONSTRAINT_NAME, constraintName);
                    marker.setAttribute(ELEMENT_URI, eObjectURI.toString());
                }
            }
        }
    }

    private void removeMarker(URI eObjectURI, IFile fileForContext) throws CoreException {
        IMarker[] markers = fileForContext.findMarkers(MARKER_TYPE, /* includeSubtypes */ false, IResource.DEPTH_ZERO);
        if (markers != null) {
            for (IMarker marker : markers) {
                if (marker.getAttribute(CONSTRAINT_NAME, "").equals(constraintName) &&
                        marker.getAttribute(ELEMENT_URI, "").equals(eObjectURI.toString())) {
                    marker.delete();
                }
            }
        }
    }

    private IFile getFile(EObject eObject) {
        URI uri = EcoreUtil.getURI(eObject);
        String platformResourceString = uri.toPlatformString(true);
        return platformResourceString != null ? ResourcesPlugin.getWorkspace().getRoot()
                .getFile(new Path(platformResourceString)) : null;
    }

    protected String composeMessage(Diagnostic diagnostic, Diagnostic parentDiagnostic) {
        String message = diagnostic.getMessage();
        if (parentDiagnostic != null) {
            String parentMessage = parentDiagnostic.getMessage();
            if (parentMessage != null) {
                message = message != null ? parentMessage + ". " + message : parentMessage;
            }
        }
        return message;
    }

    protected void createMarkers(IResource resource, Diagnostic diagnostic, Diagnostic parentDiagnostic) throws CoreException {
        if (resource != null && resource.exists()) {
            IMarker marker = resource.createMarker(MARKER_TYPE);
            int severity = diagnostic.getSeverity();
            if (severity < Diagnostic.WARNING) {
                marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO);
            } else if (severity < Diagnostic.ERROR) {
                marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_WARNING);
            } else {
                marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
            }

            String message = composeMessage(diagnostic, parentDiagnostic);
            if (message != null) {
                marker.setAttribute(IMarker.MESSAGE, message);
            }
        }
    }
    
}