/* Command line program and static methods to manage provenance.
 * 
 * Copyright (c) 2015 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2018-02-01 20:19:23 +0000 (Thu, 01 Feb 2018) $' 
 * '$Revision: 34655 $'
 * 
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the above
 * copyright notice and the following two paragraphs appear in all copies
 * of this software.
 *
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 * THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 * CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 * ENHANCEMENTS, OR MODIFICATIONS.
 *
 */
package org.kepler.provenance.manager;

import java.io.File;
import java.nio.file.Files;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.apache.taverna.robundle.Bundle;
import org.apache.taverna.robundle.Bundles;
import org.kepler.Kepler;
import org.kepler.kar.KAREntry;
import org.kepler.kar.KARFile;
import org.kepler.kar.SaveKAR;
import org.kepler.kar.handlers.ProvKAREntryHandler;
import org.kepler.loader.util.ParseWorkflow;
import org.kepler.objectmanager.cache.CacheManager;
import org.kepler.objectmanager.lsid.KeplerLSID;
import org.kepler.provenance.ProvenanceRecorder;
import org.kepler.provenance.QueryException;
import org.kepler.provenance.Queryable;
import org.kepler.provenance.Recording;
import org.kepler.provenance.RecordingException;
import org.kepler.provenance.prov.ProvUtilities;
import org.kepler.provenance.sql.SQLRecordingV8;
import org.kepler.util.WorkflowRun;
import org.openprovenance.prov.interop.InteropFramework.ProvFormat;

import ptolemy.kernel.ComponentEntity;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.kernel.util.NameDuplicationException;
import ptolemy.kernel.util.NamedObj;
import ptolemy.moml.MoMLParser;
import ptolemy.moml.filter.BackwardCompatibility;
import ptolemy.util.MessageHandler;

/** A utility class containing static methods and a command line
 *  interface to manange provenance.
 * 
 *  @author Daniel Crawl
 *  @version $Id: ProvenanceManager.java 34655 2018-02-01 20:19:23Z crawl $
 */
public class ProvenanceManager {

    /** Delete a run. */
    public static void deleteRun(Integer execId) throws Exception {
        try(Queryable query = _getDefaultQueryable();) {
            KeplerLSID lsid = query.getExecutionLSIDForExecution(execId);
            if(lsid == null) {
                throw new Exception("Execution id " + execId + " not found.");
            }
            List<KeplerLSID> lsids = new LinkedList<KeplerLSID>();
            lsids.add(lsid);
            deleteRuns(lsids);
        }
    }
    
    /** Delete runs. */
    public static void deleteRuns(List<KeplerLSID> execLSIDs) throws Exception {
        
        ProvenanceRecorder recorder;
        Recording recording;
        try {
            recorder = new ProvenanceRecorder();
            recording = recorder.getRecording();
        } catch (IllegalActionException | NameDuplicationException e) {
            throw new Exception("Error getting default recording interface.", e);
        }       
        
        // TODO fix for different recording types.
        if(recording instanceof SQLRecordingV8) {
            System.out.println("Removing runs: ");
            for(KeplerLSID lsid: execLSIDs) {
                    System.out.println(lsid);
            }
            ((SQLRecordingV8)recording).deleteExecutions(execLSIDs);
        } else {
            System.err.println("Cannot delete from recording type " + recording.getClass());
        }
        
        recorder.disconnect();
    }
    
    /** Export all runs to a KAR file.
     *  @param outputFileName the name of the KAR file.
     *  @param delete if true, delete the runs after being exported.
     */
    public static void exportProvenance(String outputFileName, boolean delete)
            throws Exception {        
        try(Queryable query = _getDefaultQueryable();) {
            exportProvenance(outputFileName, delete,
                    query.getExecutionLSIDs());
        }        
    }

    /** Export a set of provenance runs to a KAR file. 
     *  @param outputFileName the name of the KAR file.
     *  @param delete if true, delete each run exported.
     *  @param execId the execution id of the run to export.
     */
    public static void exportProvenance(String outputFileName, boolean delete, int execId)
            throws Exception {
        try(Queryable query = _getDefaultQueryable();) {
            KeplerLSID lsid = query.getExecutionLSIDForExecution(execId);
            if(lsid == null) {
                throw new Exception("Could not find LSID for run " + execId);
            }
            List<KeplerLSID> lsids = new LinkedList<KeplerLSID>();
            lsids.add(lsid);
            exportProvenance(outputFileName, delete, lsids);
        }        
    }
    
    /** Export a set of provenance runs to a KAR file. 
     *  @param outputFileName the name of the KAR file.
     *  @param delete if true, delete each run exported.
     *  @param runs the set of KeplerLSID runs to export. 
     */
    public static void exportProvenance(String outputFileName, boolean delete,
            List<KeplerLSID> runs) throws Exception {
        exportProvenance(outputFileName, delete, runs, "json");
    }
    
    /** Export a set of provenance runs to a KAR file. 
     *  @param outputFileName the name of the KAR file.
     *  @param delete if true, delete each run exported.
     *  @param runs the set of KeplerLSID runs to export. 
     *  @params format the prov format.
     */
    public static void exportProvenance(String outputFileName, boolean delete,
            List<KeplerLSID> runs, String format) throws Exception {

        TransferComponent component = new TransferComponent(format);
        component.setName("ProvenanceTransfer");
        component.addExecutions(runs);

        SaveKAR saveKar = new SaveKAR();
        saveKar.setFile(new File(outputFileName));
        saveKar.addSaveInitiator(component);
        
        KeplerLSID karLSID = saveKar.saveToDisk(null, null);
        // check for success
        if(karLSID == null) {
            throw new Exception("Error writing KAR.");
        }
        
        if(delete) {
            deleteRuns(runs);
        }
    }  

    /** Export a research object bundle
     * 
     */
    public static void exportROBundle(String outputFileName, KeplerLSID runLSID) throws Exception {
        
        File roBundleFile = new File(outputFileName);
        File workflowFile = File.createTempFile("workflow", ".kar");
        File provenanceFile = File.createTempFile("provenance", ".kar");
        try {
            Bundle bundle = Bundles.createBundle(roBundleFile.toPath());
     
            // add the workflow
            exportWorkflow(workflowFile.getAbsolutePath(), runLSID);            
            Files.copy(workflowFile.toPath(), bundle.getRoot().resolve("workflow.kar"));
            
            // add the prov trace
            exportProvenance(provenanceFile.getAbsolutePath(), false,
                Arrays.asList(runLSID), "json");            
            Files.copy(provenanceFile.toPath(), bundle.getRoot().resolve("provenance.kar"));

            Bundles.setMimeType(bundle, "application/zip");

            bundle.close();
            
            
        } catch(Exception e) {
            if(roBundleFile.exists() && !roBundleFile.delete()) {
                System.err.println("WARNING: could not delete " + roBundleFile.getAbsolutePath());
            }
            throw e;
        } finally {
            if(!workflowFile.delete()) {
                System.err.println("WARNING: could not delete " + workflowFile.getAbsolutePath());
            }
            if(!provenanceFile.delete()) {
                System.err.println("WARNING: could not delete " + provenanceFile.getAbsolutePath());   
            }
        }
        
    }

    /** Export a workflow to a file.
     * @param outputFileName The name of the workflow file.
     * @param runLSID The run LSID of the workflow to export.
     * @return The workflow file
     */
    public static void exportWorkflow(String outputFileName, KeplerLSID runLSID) throws Exception {

        try(Queryable queryable = _getDefaultQueryable()) {
            
            String momlStr = queryable.getMoMLForExecution(runLSID);        
            
            SaveKAR saveKAR = new SaveKAR();
            NamedObj model = ParseWorkflow.parseMoML(momlStr);        
            saveKAR.addSaveInitiator((ComponentEntity<?>)model);        
            File karFile = new File(outputFileName);
            saveKAR.setFile(karFile);
            
            KeplerLSID karLSID = saveKAR.saveToDisk(null, null);
            // check if saved successfully
            if(karLSID == null) {
                if(karFile.exists() && !karFile.delete()) {
                    System.err.println("WARNING: could not delete " +
                        karFile.getAbsolutePath());
                }
                throw new Exception("Could not create KAR.");
            }            
        }
    }
    
    /** Import provenance from a KAR file.
     *  @param inputFileName the name of the KAR file to import from.
     *  @param force if true, try to import despite missing any module
     *  dependencies. if false, and there are missing dependencies, throws
     *  an exception.
     */
    public static void importProvenance(String inputFileName, boolean force)
            throws Exception {
        
        File inputFile = new File(inputFileName);
        if(!inputFile.exists()) {
            throw new Exception("Import file does not exist: " + inputFileName);
        }
        
        try(KARFile karFile = new KARFile(inputFile);) {
        
            if(!force && !karFile.areAllModuleDependenciesSatisfied()) {
                // TODO
                throw new Exception("Module dependencies not satisfied and -force not specified.");
            }
                    
            //karFile.cacheKARContents();
            
            ProvKAREntryHandler handler = new ProvKAREntryHandler();
            for (KAREntry entry : karFile.karEntries()) {
                if (handler.handlesType(entry.getType())) {
                    System.out.println("Importing " + entry.getName());
                    handler.open(karFile, entry, null);
                }
            }
        }
    }
    
    /** List the runs. */
    public static void listRuns() throws Exception {

        // set the ontology index file so we can show tags.
        Kepler.setOntologyIndexFile();
        
        try(Queryable query = _getDefaultQueryable();) {
            Map<KeplerLSID, WorkflowRun> runs =
                query.getWorkflowRunsForExecutionLSIDs(query.getExecutionLSIDs());
            
            // TODO add:
            // duration, start/stop time
            // status: success, error (and error message)            
            System.out.println("ID, Tag(s), Workflow Name, Execution LSID");        
            for(WorkflowRun run : runs.values()) {
                
                String tags = run.getTagsAsFormattedString();
                if(tags.trim().isEmpty()) {
                    tags = "<no tags>";
                }
                
                System.out.println(run.getExecId() + ", " +
                        tags + ", " +
                        run.getWorkflowName() + ", " +
                        run.getExecLSID());
            }
        }
    }
    
    /** Program entry point. */
    public static void main(String[] args) {

        try {
            if(_parseArgs(args)) {

                if(_operation == Operation.Export ||
                    _operation == Operation.Import ||
                    _operation == Operation.Graph) {
                    System.setProperty("java.awt.headless", "true");
                    MoMLParser.setMoMLFilters(BackwardCompatibility.allFilters());
                    MessageHandler.setMessageHandler(new MessageHandler());

                    // set java properties since they may be referenced in workflows
                    // we will import/export. e.g., module.workflowdir
                    Kepler.setJavaPropertiesAndCopyModuleDirectories();
                }
                
                switch(_operation) {
                case List:
                    listRuns();
                    break;
                    
                case Delete:
                    deleteRun(_runId);
                    break;
                    
                case Export:
                case Import:
                    
                    // import/export
                    CacheManager.getInstance().addKAREntryHandler(new ProvKAREntryHandler());
                
                    if(_operation == Operation.Import) {
                        importProvenance(_inputFileName, _forceImport);
                    } else if(_exportAll) {
                        exportProvenance(_outputFileName, _deleteAfterExport);
                    } else {
                        exportProvenance(_outputFileName, _deleteAfterExport, _runId);
                    }
                    break;
                    
                case Graph:
                    ProvUtilities.writeProv(_outputFileName, _type, _runId);
                    break;
                }
            }
        } catch(Throwable t) {
            MessageHandler.error("Error managing provenance.", t);
            System.exit(1);
        }
        
        // TODO shut down the database cleanly so the program will exit
        // for now call System.exit()
        System.exit(0);
    }

    ///////////////////////////////////////////////////////////////////
    ////                         private methods                   ////

    /** Get the default queryable. */
    private static Queryable _getDefaultQueryable() throws Exception {
        
        try {
            return ProvenanceRecorder.getDefaultQueryable(null);
        } catch (QueryException | RecordingException e) {
            throw new Exception("Error getting default query interface.", e);
        }

    }
    
    /** Parse command line arguments.
     *  @return True if arguments parsed ok, false if an error
     *  and execution should stop. 
     */
    private static boolean _parseArgs(String[] args) {
        
        boolean retval = true;
        
        String runIdStr = null;
        
        int i = 0;
        for(i = 0; i < args.length; i++) {
            String arg = args[i];
            switch(arg) {
            case "-all":
                _exportAll = true;
                break;
            case "-delete":
                _deleteAfterExport = true;
                break;
            case "-force":
                _forceImport = true;
                break;                
            case "-h":
            case "-help":
            case "--help":
                _usage();
                return false;
            case "-i":
                if(i + 1 == args.length) {
                    System.err.println("ERROR: must provide input file name with -i.");
                    return false;
                }
                i++;
                _inputFileName = args[i];
                _operation = Operation.Import;
                break;
            case "-g":
                if(i + 1 == args.length) {
                    System.err.println("ERROR: must provide output file name with -g.");
                    return false;
                }
                i++;
                _outputFileName = args[i];
                _operation = Operation.Graph;
                if(_type == null) {
                    _type = "jpeg";
                }
                break;               
            case "-l":
                _operation = Operation.List;
                break;
            case "-o":
                if(i + 1 == args.length) {
                    System.err.println("ERROR: must provide output file name with -o.");
                    return false;
                }
                i++;
                _outputFileName = args[i];
                _operation = Operation.Export;
                break;
            case "-rm":
                if(i + 1 == args.length) {
                    System.err.println("ERROR: must provide number to delete with -rm.");
                    return false;
                }
                i++;
                runIdStr = args[i];
                _operation = Operation.Delete;
                break;
            case "-run":
                if(i + 1 == args.length) {
                    System.err.println("ERROR: must provide number with -run.");
                    return false;
                }
                i++;
                runIdStr = args[i];
                break;
            case "-t":
                if(i + 1 == args.length) {
                    System.err.println("ERROR: must provide type with -t.");
                    return false;
                }
                i++;
                _type = args[i];
                break;
            default:
                System.err.println("Unknown argument: " + arg);
                retval = false;
                break;
            }
        }
                
        // sanity checks
        
        if(_operation == null) {
            System.err.println("Must specify an operation.");
            retval = false;
        } else if(_exportAll && runIdStr != null) {
            System.err.println("Cannot export all (-all) and specific run (-run n).");
            retval = false;
        } else if(_operation == Operation.Export && !_exportAll && runIdStr == null) {
            System.err.println("Must specify either -all or -run n when exporting.");
            retval = false;
        } else if(_deleteAfterExport && _operation != Operation.Export) {
            System.err.println("Can only use -delete when exporting.");
            retval = false;
        } else if(_forceImport && _operation != Operation.Import) {
            System.err.println("Can only force when importing.");
            retval = false;
        } else if(_operation == Operation.Graph && runIdStr == null) {
            System.err.println("Must specify a specific run when graphing.");
            retval = false;
        } 
        
        if(_operation == Operation.Graph) {
            boolean found = false;
            for(ProvFormat type : ProvFormat.values()) {
                if(type.toString().equals(_type.toUpperCase())) {
                    found = true;
                    break;
                }
            }
            if(!found) {
                System.err.println("Valid graph output types are: ");
                for(ProvFormat type : ProvFormat.values()) {
                    System.err.print(type.toString().toLowerCase() + " " );
                }
                System.err.println();
                retval = false;
            }
        }
                
        
        if(runIdStr != null) {
            try {
                _runId = Integer.valueOf(runIdStr);
            } catch(NumberFormatException e) {
                System.err.println("ERROR: run " + runIdStr + " is not a number.");
                retval = false;
            }
            if(_runId < 0) {
                System.err.println("ERROR: run " + _runId + " must be at least 0.");
                retval = false;
            }
        }
        
        return retval;
    }
    
    /** Show command line usage. */
    private static void _usage() {
        
        System.out.println("USAGE: prov-manager [-l | -o ... | -i ... | -rm n | -g ...] [...]");
        System.out.println();
        System.out.println("-h                          show this help.");
        System.out.println("-i ...                      import from a kar.");
        System.out.println("-l                          show provenance runs.");
        System.out.println("-o ...                      export to a kar.");
        System.out.println("-rm n                       delete workflow run n.");
        System.out.println();
        System.out.println("Export provenance to a KAR file:");
        System.out.println("prov-manager -o output.kar [-all | -run n] [-delete]");
        System.out.println("-all                        export all workflows runs.");
        System.out.println("-run n                      export run n.");
        System.out.println("-delete                     delete workflow runs in database after export.");
        System.out.println();
        System.out.println("Import provenance from a KAR file:");
        System.out.println("prov-manager -i input.kar [-force]");
        System.out.println("-force                      attempt to import run(s) despite any missing module dependencies.");
        System.out.println();
        System.out.println("Generate a PROV provenance graph:");
        System.out.println("prov-manager -g output -run n [-t jpg|pdf|...]");
        System.out.println("-run n                      graph run n.");
        System.out.println("-t                          graph file type.");
    }
    
    ///////////////////////////////////////////////////////////////////
    ////                         private fields                    ////

    /** If true, delete the runs after exporting. */
    private static boolean _deleteAfterExport = false;

    /** If true, export all the provenance runs. */
    private static boolean _exportAll = false;

    /** If true, try to import the runs despite any missing module
     *  dependencies.
     */
    private static boolean _forceImport = false;
        
    /** The input file name. */
    private static String _inputFileName;

    /** The output file name. */
    private static String _outputFileName;
       
    /** The id of the run to delete, export, graph, etc. */
    private static Integer _runId;
        
    /** The types of operations. */
    private enum Operation { List, Import, Export, Graph, Delete };
    
    /** The operation to perform. */
    private static Operation _operation;
    
    /** The graph type. */
    private static String _type;
}