/*******************************************************************************
 * Copyright (c) 2016, 2018 EfficiOS Inc., Alexandre Montplaisir 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
 *******************************************************************************/

package org.eclipse.tracecompass.internal.tmf.ui.project.handlers;

import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.TreeSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.tracecompass.internal.tmf.ui.Activator;
import org.eclipse.tracecompass.internal.tmf.ui.project.operations.NewExperimentOperation;
import org.eclipse.tracecompass.internal.tmf.ui.project.operations.TmfWorkspaceModifyOperation;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
import org.eclipse.tracecompass.statesystem.core.snapshot.StateSnapshot;
import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
import org.eclipse.tracecompass.tmf.core.component.ITmfEventProvider;
import org.eclipse.tracecompass.tmf.core.project.model.TmfTraceType;
import org.eclipse.tracecompass.tmf.core.project.model.TraceTypeHelper;
import org.eclipse.tracecompass.tmf.core.statesystem.ITmfAnalysisModuleWithStateSystems;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.core.trace.trim.ITmfTrimmableTrace;
import org.eclipse.tracecompass.tmf.ui.project.model.ITmfProjectModelElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfCommonProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfExperimentFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfOpenTraceHelper;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfProjectRegistry;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceElement;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceFolder;
import org.eclipse.tracecompass.tmf.ui.project.model.TmfTraceTypeUIUtils;
import org.eclipse.tracecompass.tmf.ui.project.model.TraceUtils;
import org.eclipse.tracecompass.tmf.ui.project.wizards.TrimTraceDialog;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.handlers.HandlerUtil;
import org.eclipse.ui.handlers.IHandlerService;

import com.google.common.collect.Lists;

/**
 * Handler for the Trace Trim operation.
 *
 * @author Alexandre Montplaisir
 */
@NonNullByDefault
public class TrimTraceHandler extends AbstractHandler {

    private static final class TraceToTrim {
        private ITmfTrace fTrace;
        private @Nullable ITmfTrimmableTrace fTrimmable;
        private Path fDestinationPath;
        private Collection<TraceToTrim> fChildren = new ArrayList<>();
        private TmfCommonProjectElement fElement;
        private @Nullable IFolder fFolder = null;
        private @Nullable ITmfProjectModelElement fDestElement = null;
        private TmfCommonProjectElement fSourceElement;

        public static @Nullable TraceToTrim create(TmfCommonProjectElement element, Path destination) {
            ITmfTrace trace = element.getTrace();
            if (trace != null) {
                return new TraceToTrim(trace, element, element, destination);
            }
            if (element instanceof TmfTraceElement) {
                TmfTraceElement traceElement = (TmfTraceElement) element;
                trace = traceElement.getTrace();

                if (trace != null) {
                    return new TraceToTrim(trace, element, element, destination);
                }
            }
            return null;
        }

        private static final @Nullable TraceToTrim create(TraceToTrim parent, TmfTraceElement traceElement) {
            TmfTraceElement elementUnderTraceFolder = traceElement.getElementUnderTraceFolder();
            ITmfTrace trace = traceElement.getTrace();
            if (trace != null) {
                List<String> elems = new ArrayList<>();
                ITmfProjectModelElement tempTraceElement = elementUnderTraceFolder;
                while (tempTraceElement != null) {
                    elems.add(Objects.requireNonNull(tempTraceElement.getName()));
                    tempTraceElement = tempTraceElement.getParent();
                }
                TraceTypeHelper traceType = TmfTraceType.getTraceType(elementUnderTraceFolder.getTraceType());
                String end = elems.remove(0);
                elems = Lists.reverse(elems);
                TmfTraceFolder tracesFolder = elementUnderTraceFolder.getProject().getTracesFolder();
                if (tracesFolder == null) {
                    return null;
                }
                IFolder folder = tracesFolder.getResource();
                // remove project name
                elems.remove(0);
                // remove "Traces"
                elems.set(0, String.valueOf(parent.fDestinationPath.getFileName()));
                for (String elem : elems) {
                    folder = folder.getFolder(elem);
                    if (!folder.exists()) {
                        try {
                            folder.create(true, true, new NullProgressMonitor());
                        } catch (CoreException e) {
                            return null;
                        }
                    }
                }
                folder = folder.getFolder(end);
                if (!traceType.isDirectoryTraceType() && !folder.exists()) {
                    try {
                        folder.create(true, true, new NullProgressMonitor());
                        folder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
                    } catch (CoreException e) {
                        return null;
                    }
                }
                TmfTraceElement te = new TmfTraceElement(elementUnderTraceFolder.getName(), folder, tracesFolder) {
                    @Override
                    public String getTraceType() {
                        return String.valueOf(traceElement.getTraceType());
                    }

                    @Override
                    public void refreshTraceType() {
                        // Do nothing, we have the tracetype above
                    }

                    @Override
                    public IResource[] getSupplementaryResources() {
                        return traceElement.getSupplementaryResources();
                    }
                };
                return new TraceToTrim(trace, elementUnderTraceFolder, te, (new File(te.getName())).toPath());
            }
            return null;
        }

        public TraceToTrim(ITmfTrace trace, TmfCommonProjectElement sourceElement, TmfCommonProjectElement element, Path destination) {
            fTrace = trace;
            fSourceElement = sourceElement;
            fElement = element;
            if (trace instanceof ITmfTrimmableTrace) {
                fTrimmable = (ITmfTrimmableTrace) trace;
            } else {
                fTrimmable = null;
            }
            fFolder = (IFolder) element.getResource();
            // Note: getParent.getLocation is almost never a link. The
            // folder.getLocation may be a link.
            fDestinationPath = fFolder != null ? fFolder.getParent().getLocation().append(destination.toString()).toFile().toPath() : destination;
            // go through children
            for (TmfTraceElement childElement : element.getTraces()) {
                TraceToTrim create = TraceToTrim.create(this, childElement);
                if (create != null) {
                    fChildren.add(create);
                }
            }
        }

        public IStatus trim(TmfTimeRange tr, IProgressMonitor mon) {
            if (mon.isCanceled()) {
                return Status.CANCEL_STATUS;
            }
            SubMonitor monitor = SubMonitor.convert(mon, 3);
            List<@NonNull ITmfAnalysisModuleWithStateSystems> statesystemModules = new ArrayList<>();
            for (IAnalysisModule module : fTrace.getAnalysisModules()) {
                if (module instanceof ITmfAnalysisModuleWithStateSystems) {
                    statesystemModules.add((ITmfAnalysisModuleWithStateSystems) module);
                }
            }
            monitor.worked(1);
            long snapshotTime = tr.getStartTime().toNanos();
            /*
             * Perform the trace-specific trim operation. This should create the
             * trace file(s) in the destination path.
             */
            Path returnPath = fDestinationPath;
            if (fTrimmable != null) {
                try {
                    returnPath = fTrimmable.trim(tr, returnPath, monitor);
                } catch (CoreException e) {
                    return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "An error occurred writing the state systems snapshots", e); //$NON-NLS-1$
                }
            }
            if (returnPath == null) {
                return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Failed to trim trace. " + fTrimmable); //$NON-NLS-1$
            }
            if (monitor.isCanceled()) {
                return Status.CANCEL_STATUS;
            }
            monitor.worked(1);
            SubMonitor ssMon = SubMonitor.convert(mon, statesystemModules.size());
            /* Write the snapshot files in the new trace's location. */
            try {
                for (ITmfAnalysisModuleWithStateSystems module : statesystemModules) {
                    ssMon.split(1);
                    Map<String, Integer> versions = module.getProviderVersions();
                    Iterable<ITmfStateSystem> sss = module.getStateSystems();
                    for (ITmfStateSystem ss : sss) {
                        Integer version = versions.get(ss.getSSID());
                        long currentEndTime = ss.getCurrentEndTime();
                        if (snapshotTime <= currentEndTime && version != null) {
                            StateSnapshot snapshot = new StateSnapshot(ss, Math.max(snapshotTime, ss.getStartTime()), Math.min(currentEndTime, tr.getEndTime().toNanos()), version);
                            snapshot.write(returnPath);
                        }
                    }
                }

            } catch (IOException e) {
                return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "An error occurred writing the state systems snapshots", e); //$NON-NLS-1$
            }
            for (TraceToTrim child : fChildren) {
                IStatus status = child.trim(tr, monitor);
                if (!status.isOK()) {
                    return status;
                }
            }
            return Status.OK_STATUS;
        }

        public IStatus importTrace(IProgressMonitor monitor) {
            try {
                IFolder folder = fFolder;
                if (folder == null) {
                    return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Folder is null"); //$NON-NLS-1$
                }
                ITmfProjectModelElement destElement;
                for (TraceToTrim child : fChildren) {
                    IStatus status = child.importTrace(monitor);
                    if (!status.isOK()) {
                        return status;
                    }
                }

                TraceTypeHelper traceTypeHelper = TmfTraceType.getTraceType(fElement.getTraceType());
                if (fElement instanceof TmfExperimentElement) {
                    TmfExperimentElement experimentElement = (TmfExperimentElement) fElement;
                    // create an experiment
                    TmfExperimentFolder experimentsFolder = experimentElement.getProject().getExperimentsFolder();
                    if (experimentsFolder == null) {
                        return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Error getting experiment folder"); //$NON-NLS-1$
                    }
                    List<TmfTraceElement> children = new ArrayList<>();
                    for (TraceToTrim child : fChildren) {
                        ITmfProjectModelElement childDest = child.fDestElement;
                        if (childDest instanceof TmfTraceElement) {
                            children.add((TmfTraceElement) childDest);
                        }
                    }

                    String name = fDestinationPath.getFileName().toString();
                    if (name == null) {
                        return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "could not create element"); //$NON-NLS-1$
                    }
                    NewExperimentOperation newExperimentOperation = new NewExperimentOperation(experimentsFolder, name, null, children);
                    newExperimentOperation.run(monitor);
                    experimentsFolder.refresh();
                    destElement = experimentsFolder.getChild(name);
                    if (destElement == null) {
                        return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "could not create element"); //$NON-NLS-1$
                    }
                    TmfTraceTypeUIUtils.setTraceType(destElement.getResource(), traceTypeHelper);
                    if (destElement instanceof TmfExperimentElement) {
                        TmfExperimentElement expElement = (TmfExperimentElement) destElement;
                        for (TraceToTrim child : fChildren) {
                            ITmfProjectModelElement childDest = child.fDestElement;
                            if (childDest instanceof TmfTraceElement && expElement.getChild(childDest.getName()) == null) {
                                expElement.addTrace((TmfTraceElement) childDest, false);
                            }
                        }
                        fSourceElement.copySupplementaryFolder(destElement.getName());
                        destElement.refresh();
                        fDestElement = destElement;
                    }

                } else if (fElement instanceof TmfTraceElement) {
                    // create a trace
                    String path = (traceTypeHelper.isDirectoryTraceType() ? fDestinationPath : fDestinationPath.getParent()).toAbsolutePath().toString();
                    IPath destinationPath = org.eclipse.core.runtime.Path.fromOSString(path);
                    IResource traceResource = null;
                    String lastSegment = destinationPath.lastSegment();
                    IContainer tempFolder = folder.getParent();
                    tempFolder.refreshLocal(IResource.DEPTH_INFINITE, monitor);
                    // Look for a common parent. In case the folders are oddly
                    // configured.
                    while (tempFolder != null && traceResource == null) {
                        traceResource = tempFolder.findMember(lastSegment);
                        tempFolder = tempFolder.getParent();
                    }
                    if (traceResource == null) {
                        return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Error finding common parent"); //$NON-NLS-1$
                    }
                    IStatus ret = TmfTraceTypeUIUtils.setTraceType(traceResource, traceTypeHelper);
                    if (!ret.isOK()) {
                        return ret;
                    }
                    ITmfProjectModelElement findElement = TmfProjectRegistry.findElement(traceResource, true);
                    if (findElement instanceof TmfCommonProjectElement) {
                        fSourceElement.copySupplementaryFolder(((TmfCommonProjectElement) findElement).getElementPath());
                    }
                    fDestElement = findElement;
                }
            } catch (CoreException e) {
                return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Error creating link", e); //$NON-NLS-1$
            }
            if (monitor.isCanceled()) {
                return Status.CANCEL_STATUS;
            }
            return Status.OK_STATUS;
        }

        public void open() {
            if (fDestElement instanceof TmfCommonProjectElement) {
                TmfOpenTraceHelper.openTraceFromElement((TmfCommonProjectElement) fDestElement);
            }
        }

        public void createDir() throws IOException {
            if (fElement instanceof TmfExperimentElement) {
                for (TraceToTrim child : fChildren) {
                    child.createDir();
                }
            } else {
                fDestinationPath.toAbsolutePath().toFile().mkdirs();
            }
        }
    }

    /**
     * Can this trace be trimmed?
     *
     * @param element
     *            the element to test
     * @return <code>true</code> if the trace or all its children can be
     *         trimmed.
     */
    private static boolean isValid(@Nullable Object element) {
        if (element instanceof ITmfTrimmableTrace) {
            return true;
        }
        if (!(element instanceof ITmfTrace)) {
            return false;
        }
        ITmfTrace trace = (ITmfTrace) element;
        if (trace.getChildren().isEmpty()) {
            return false;
        }
        for (ITmfEventProvider child : trace.getChildren()) {
            if (!isValid(child)) {
                return false;
            }
        }
        return true;
    }

    @Override
    public boolean isEnabled() {
        IWorkbench workbench = PlatformUI.getWorkbench();
        if (workbench == null) {
            return false;
        }
        @SuppressWarnings("null")
        IHandlerService service = workbench.getService(IHandlerService.class);
        // we need the current state, and the map, but the command and the
        // trigger are
        // not necessary for getCurrentSelection
        ExecutionEvent executionEvent = new ExecutionEvent(null, Collections.emptyMap(), null, service.getCurrentState());
        final Object element = HandlerUtil.getCurrentSelection(executionEvent);

        if (!(element instanceof TreeSelection)) {
            return false;
        }
        /*
         * plugin.xml should have done type/count verification already
         */
        Object firstElement = ((TreeSelection) element).getFirstElement();
        ITmfTrace trace = null;
        if (firstElement instanceof TmfCommonProjectElement) {
            TmfCommonProjectElement traceElem = (TmfCommonProjectElement) firstElement;
            if (traceElem instanceof TmfTraceElement) {
                traceElem = ((TmfTraceElement) traceElem).getElementUnderTraceFolder();
            }
            trace = traceElem.getTrace();
        }
        if (trace == null || !isValid(trace)) {
            return false;
        }

        /* Only enable the action if a time range is currently selected */
        TmfTraceManager tm = TmfTraceManager.getInstance();
        TmfTimeRange selectionRange = tm.getTraceContext(trace).getSelectionRange();
        return !(selectionRange.getStartTime().equals(selectionRange.getEndTime()));
    }

    @Override
    public @Nullable Object execute(@Nullable ExecutionEvent event) throws ExecutionException {
        ISelection selection = HandlerUtil.getCurrentSelectionChecked(event);
        Object firstElement = ((IStructuredSelection) selection).getFirstElement();
        final TmfCommonProjectElement traceElem = (firstElement instanceof TmfTraceElement) ?
                ((TmfTraceElement) firstElement).getElementUnderTraceFolder() : (TmfCommonProjectElement) firstElement;

        ITmfTrace trace = traceElem.getTrace();

        if (trace == null || !isValid(trace)) {
            /* That trace is not currently opened */
            return null;
        }

        /* Retrieve the current time range */
        final Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
        TmfTraceManager tm = TmfTraceManager.getInstance();
        TmfTimeRange timeRange = tm.getTraceContext(trace).getSelectionRange();
        if (Objects.equals(timeRange.getStartTime(), timeRange.getEndTime())) {
            MessageDialog.openError(shell, Messages.TrimTraces_InvalidTimeRange_DialogTitle, Messages.TrimTraces_InvalidTimeRange_DialogText);
            return null;
        }

        /* Ensure the time range is in the right direction */
        final TmfTimeRange tr = ((timeRange.getStartTime().compareTo(timeRange.getEndTime()) > 0) ? new TmfTimeRange(timeRange.getEndTime(), timeRange.getStartTime()) : timeRange);

        /*
         * Pop a dialog asking the user to select a parent directory for the new
         * trace.
         */
        TrimTraceDialog dialog = new TrimTraceDialog(shell, traceElem);
        if (dialog.open() != Window.OK) {
            return null;
        }
        Object result = dialog.getFirstResult();
        if (result == null) {
            /* Dialog was cancelled, take no further action. */
            return null;
        }

        /* Verify that the selected path is valid and writeable */
        final Path destinationPath = checkNotNull(Paths.get(result.toString()));

        if (destinationPath.toFile().exists()) {
            MessageDialog.openError(shell, Messages.TrimTraces_InvalidDirectory_DialogTitle, Messages.TrimTraces_InvalidDirectory_DialogText);
            return null;
        }
        TraceToTrim toTrim = TraceToTrim.create(traceElem, destinationPath);
        if (toTrim == null) {
            return null;
        }
        try {
            toTrim.createDir();
        } catch (IOException e) {
            /* Should not happen since we have checked permissions, etc. */
            throw new ExecutionException(e.getMessage(), e);
        }

        TmfWorkspaceModifyOperation trimOperation = new TmfWorkspaceModifyOperation() {
            @Override
            public void execute(@Nullable IProgressMonitor monitor) throws CoreException {
                SubMonitor mon = SubMonitor.convert(monitor, 2);

                toTrim.trim(tr, mon);
                /*
                 * Import the new trace into the current project, at the
                 * top-level.
                 */
                TmfProjectElement currentProjectElement = traceElem.getProject();
                TmfTraceFolder traceFolder = currentProjectElement.getTracesFolder();
                toTrim.importTrace(mon);
                if (mon.isCanceled()) {
                    return;
                }
                if (traceFolder != null) {
                    Display.getDefault().asyncExec(toTrim::open);
                } else {
                    Activator.getDefault().logWarning("Trace folder does not exist: " + toTrim.fDestinationPath); //$NON-NLS-1$
                }
            }
        };

        try {
            PlatformUI.getWorkbench().getProgressService().run(true, true, trimOperation);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (InvocationTargetException e) {
            TraceUtils.displayErrorMsg(Messages.TrimTraceHandler_failMsg, e.getMessage(), e);
        }

        return null;
    }

}