/*
 * Copyright (c) 2015 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2017-08-24 05:20:42 +0000 (Thu, 24 Aug 2017) $' 
 * '$Revision: 34621 $'
 * 
 * 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.loader.util;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import javax.swing.SwingUtilities;

import org.apache.commons.io.FilenameUtils;
import org.kepler.gui.KeplerIconLoader;
import org.kepler.objectmanager.library.LibraryManager;

import ptolemy.actor.CompositeActor;
import ptolemy.actor.gui.Configuration;
import ptolemy.actor.gui.ConfigurationApplication;
import ptolemy.actor.gui.Tableau;
import ptolemy.kernel.ComponentEntity;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.moml.MoMLParser;
import ptolemy.vergil.basic.BasicGraphFrame;

/** A class to automate taking screenshots of Kepler workflows.
 * 
 *  @author Daniel Crawl
 *  @version $Id: Screenshot.java 34621 2017-08-24 05:20:42Z crawl $
 */
public class Screenshot {

    /** Create a new Screenshot for a workflow with the specified output. */
    private Screenshot(File workflow, File output) {
        _workflowFile = workflow;
        _outputFile = output;
    }

    /** Create screenshots of workflows. There are three possible ways to specify
     *  the name and location of the output images:
     *  <ul>
     *  <li>If outputDir is not null, then the images are all written to this directory
     *  with the same name as the workflow.</li>
     *  <li>If outputs is not null, then the outputs are written to the files specified
     *  in outputs. There must be a file name in outputs for each workflow.</li>
     *  <li>If both outputDir and outputs is null, the outputs are written to the
     *  same directory as the workflow, with the same name as the workflow.</li>
     *  </ul>
     *  @param workflows the set of workflow filenames of which to create screenshots
     *  @param type the screenshot image type. If a set of output filenames are
     *  specified, this parameter must be null since the output filename extensions
     *  specify the image type.
     *  @param outputs A set of output filenames. If this is null, then the output
     *  directory and type must be specified. If this is not null, it must contain an
     *  output image name for each workflow.
     *  @param outputDir The output directory in which to write the screenshot images.
     *  If this is null, then the outputs must specify the output file names. Otherwise,
     *  outputs must be null.
     *  @param force If true, always create screenshot images. Otherwise, the screenshot
     *  images are only created if the output image does not exist or was last modified
     *  before the workflow file was last modified.
     *  @return A list of files containing the screenshots.
     */
    public synchronized static List<File> makeScreenshot(List<String> workflows, String type,
            List<String> outputs, String outputDir, boolean force) throws Exception {
        
        // make sure each workflow file exists
        for(String workflow : workflows) {
            File workflowFile = new File(workflow);
            if(!workflowFile.exists()) {
                throw new IllegalActionException("Workflow " + workflow + " does not exists.");
            }
        }

        // if output specified, make sure is the same number as workflows
        if(outputs != null && workflows.size() != outputs.size()) {
            throw new IllegalActionException("The number of outputs does not match the number of workflows.");
        }
        
        // error if output and directory both specified
        if(outputs != null && outputDir != null) {
            throw new IllegalActionException("Either output name or output directory can be specified but not both.");
        }

        // create directory if specified and does not exist
        if(outputDir != null) {
            File outputDirFile = new File(outputDir);
            if(!outputDirFile.isDirectory()) {
                if(!outputDirFile.mkdirs()) {
                    throw new IllegalActionException("Could not create output directory " + outputDir);
                }
            }
        }
        
        // error if type and output is specified
        if(type != null && outputs != null) {
            throw new IllegalActionException("Either output type or output name can be specified, but not both.\n"
                    + "The extension in the output name is used as the type.");
        }
        
        if(type == null && outputDir != null) {
            throw new IllegalActionException("Must specified type if output directory is specified.");
        }
        
        if(type == null && outputs == null) {
            throw new IllegalActionException("Must specify either output type or output name.");
        }
                
        // set this property to prevent Configuration._removeEntity()
        // from calling System.exit() when the workflow is closed.
        // this property is also set to true in 
        // ConfigurationApplication.closeModelWithoutSavingOrExiting(),
        // but does not appear to work for kepler.
        System.setProperty("ptolemy.ptII.doNotExit", "true");

        // Set the icon loader to load Kepler files
        MoMLParser.setIconLoader(new KeplerIconLoader());

        Set<Screenshot> screenshots = new HashSet<Screenshot>();
        
        String[] workflowArray = workflows.toArray(new String[workflows.size()]);
        String[] outputArray = null;
        if(outputs != null) {
            outputArray = outputs.toArray(new String[outputs.size()]);
        }
        
        String typeExtension = null;
        if(type != null) {
            typeExtension = type.trim().toLowerCase();
        }
        
        
        List<File> outputFiles = new LinkedList<File>();
        
        for(int i = 0; i < workflowArray.length; i++) {
        
            String workflowStr = workflowArray[i];
            File workflowFile = new File(workflowStr);
            File output;
            
            // set output
            if(outputArray != null) {
                output = new File(outputArray[i]);
            } else if(outputDir != null) {
                output = new File(outputDir, 
                        FilenameUtils.getBaseName(workflowStr) + "." + typeExtension);
            } else {
                output = new File(workflowFile.getParentFile(), 
                        FilenameUtils.getBaseName(workflowStr) + "." + typeExtension);
            }
            
            outputFiles.add(output);
            
            // if not force, check if output exists
            if(!force && output.exists() && workflowFile.lastModified() <= output.lastModified()) {
                System.out.println("Skipping screen shot for " + workflowArray[i] + " since image " +
                        output + " is newer");
                continue;
            }
            
            Screenshot screenshot = new Screenshot(workflowFile, output);
            screenshots.add(screenshot);
        }
        
        if(!screenshots.isEmpty()) {            
            
            // open the initial frame
            if(_initialFrame == null) {
                _initialFrame = _openKeplerGraphFrame(null, false);
            }   

            // make each screenshot
            for(Screenshot screenshot : screenshots) {
                screenshot._takeScreenshot();
            }
            
            // close the initial frame
            if(_initialFrame != null && _closeAllWhenDone) {
                closeAll();
            }

        }
        
        return outputFiles;
    }
    
    /** Set if should close all tableaux and shutdown after last screenshot. */
    public synchronized static void closeAllWhenDone(boolean close) {
        _closeAllWhenDone = close;
    }
    
    /** Close all tableaux, which will shutdown Kepler. */
    public synchronized static void closeAll() throws IllegalActionException {
        if(_initialFrame != null) {
            _initialFrame.dispose();
            _initialFrame = null;
        }
        Configuration.closeAllTableaux();
    }
    
    /** Take the screen shot of an actor or workflow. */
    private boolean _takeScreenshot() {
        
        final boolean success[] = new boolean[1];
        success[0] = true;
        
        if(_entity == null) {
            try {
                _entity = (ComponentEntity<?>) ParseWorkflow.parseWorkflow(_workflowFile);
            } catch (Exception e) {
                System.out.println("Error parsing " + _workflowFile + ":" + e.getMessage());
                e.printStackTrace();
                return false;                
            }
            if(_entity == null) {
                System.out.println("Could not parse " + _workflowFile);
                return false;
            }
        }
        
        BasicGraphFrame frametmp;
        try {
            frametmp = _openKeplerGraphFrame(_entity, !_isWorkflow);
        } catch (Exception e) {
            System.out.println("Could not open frame for component " +
                    _entity.getDisplayName() + ": " + e.getMessage());
            return false;
        }
        
        final BasicGraphFrame frame = frametmp;
        
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try(OutputStream outputStream = new FileOutputStream(_outputFile);) {                   
                    frame.zoomFit();
                    frame.getJGraph().exportImage(outputStream,
                            FilenameUtils.getExtension(_outputFile.getAbsolutePath()));
                    frame.close();
                } catch(Exception e) {
                    System.out.println("Error writing image: " + e.getMessage());
                    success[0] = false;
                }
            }
        };
        
        try {
            SwingUtilities.invokeAndWait(runnable);
        } catch (Exception e) {
            e.printStackTrace();
            success[0] = false;
        }
        
        return success[0];
    }
    
    /** Display an entity in a BasicGraphFrame. 
     *  @param entity the entity to display in the BasicGraphFrame.  
     *  @param placeInEmptyComposite if true, put the entity in an empty composite
     *  actor and display the contents of this composite actor in the BasicGraphFrame.
     */
    private static BasicGraphFrame _openKeplerGraphFrame(final ComponentEntity<?> entity,
            final boolean placeInEmptyComposite) throws Exception {
        
        // create an empty library since creating a KeplerGraphFrame initializes 
        // the ComponentLibraryTab, which in turns requires a library.
        LibraryManager.getInstance().buildEmptyLibrary();

        final BasicGraphFrame[] frame = new BasicGraphFrame[1];
        
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                
                CompositeActor container = null;
                if(entity == null) {
                    container = new CompositeActor();
                } else if(placeInEmptyComposite) {
                    container = new CompositeActor(entity.workspace());
                } else {
                    container = (CompositeActor) entity;
                } 

                Configuration configuration;
                
                try {
                    
                    if(entity != null && placeInEmptyComposite) {
                        entity.setContainer(container);
                    }

                    configuration = ConfigurationApplication
                            .readConfiguration(ConfigurationApplication
                                    .specToURL("ptolemy/configs/kepler/configuration.xml"));
                    Tableau tableau = configuration.openModel(container);
                    frame[0] = (BasicGraphFrame)tableau.getFrame();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };

        if(SwingUtilities.isEventDispatchThread()) {
            runnable.run();
        } else {
            SwingUtilities.invokeAndWait(runnable);
        }
        
        try {
            Thread.sleep(1000);
        } catch (Throwable ex) {
            // Ignore
        }
        
        return frame[0];
    }
      
    /** The workflow file. */
    private File _workflowFile;
    
    /** The screenshot image file. */
    private File _outputFile;
    
    /** If true, the entity is a workflow. */
    private boolean _isWorkflow = true;
    
    /** The entity to take a screenshot of. */
    private ComponentEntity<?> _entity;
    
    /** The frame used to initialize the entity library. */
    private static BasicGraphFrame _initialFrame;
    
    /** If true, close all tableaux and shutdown after last screenshot. */
    private static boolean _closeAllWhenDone = false;
}