/*
 * Copyright (c) 2010 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: barseghian $'
 * '$Date: 2013-01-15 21:38:31 +0000 (Tue, 15 Jan 2013) $' 
 * '$Revision: 31329 $'
 * 
 * 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.kar.handlers;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import javax.swing.JLabel;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.kepler.gui.state.ReportingStateChangeEvent;
import org.kepler.gui.state.StateChangeMonitor;
import org.kepler.kar.KAREntry;
import org.kepler.kar.KAREntryHandler;
import org.kepler.kar.KAREntryHandlerFactory;
import org.kepler.kar.KARFile;
import org.kepler.moml.NamedObjId;
import org.kepler.moml.NamedObjIdReferralList;
import org.kepler.objectmanager.ObjectManager;
import org.kepler.objectmanager.cache.CacheManager;
import org.kepler.objectmanager.cache.CacheObject;
import org.kepler.objectmanager.cache.ReportLayoutCacheObject;
import org.kepler.objectmanager.lsid.KeplerLSID;
import org.kepler.provenance.Queryable;
import org.kepler.reporting.rio.ReportInstance;
import org.kepler.reporting.rio.fop.ReportRenderer;
import org.kepler.reporting.rio.util.ProvenanceUtil;
import org.kepler.reporting.roml.ReportLayout;
import org.kepler.util.WorkflowRun;
import org.kepler.workflow.WorkflowManager;
import org.kepler.workflowrunmanager.WorkflowRunManager;
import org.kepler.workflowrunmanager.WorkflowRunManagerManager;

import ptolemy.actor.gui.TableauFrame;
import ptolemy.kernel.CompositeEntity;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.kernel.util.NameDuplicationException;
import ptolemy.kernel.util.NamedObj;

/**
 * @author Ben Leinfelder
 * 
 */
public class ReportLayoutKAREntryHandler implements KAREntryHandler {

        private static final Log log = LogFactory.getLog(ReportLayoutKAREntryHandler.class.getName());
        private static final boolean isDebugging = log.isDebugEnabled();


        public ReportLayoutKAREntryHandler() {
        }

        /**
         * Method for backwards compatibility with KAR version 1.0 KAR version 2.0
         * uses the binary class name as the type.
         * 
         * @see org.kepler.kar.KAREntryHandler#getTypeName()
         */
        public String getTypeName() {
                return ReportLayout.class.getName();
        }

        public boolean handlesType(String typeName) {

                //try string based comparison
                if (typeName.equals(ReportLayout.class.getName())) {
                        return true;
                }
                if (typeName.equals(ReportInstance.class.getName())) {
                        return true;
                }
//              if (typeName.equals(WorkflowRun.class.getName())) {
//                      return true;
//              }
                return false;
        }

        /*
         * (non-Javadoc)
         * 
         * @see org.kepler.kar.KAREntryHandler#initialize()
         */
        public void initialize() {
                if (isDebugging) {
                        log.debug("initialize()");
                }
        }
        
        public boolean open(KARFile karFile, KAREntry entry, TableauFrame tableauFrame) throws Exception {
                // look up the LSID for the entry, do we need it?
                KeplerLSID reportLsid = entry.getLSID();
                CacheManager cm = CacheManager.getInstance();
                ReportLayoutCacheObject rlco = (ReportLayoutCacheObject) cm.getObject(reportLsid);
                ReportLayout rl = null;
                rlco = null; // force the read from the karfile BRL, 2009/12/14
                if (rlco == null){ // try to get it out of the karFile
                        rl = ReportRenderer.convertXML2Report(karFile.getInputStream(entry));
                }
                else{
                        rl = (ReportLayout) rlco.getObject();
                }
                
                KeplerLSID workflowLsid = rl.getWorkflowLSID();
                
                // the tableauFrame passed in is the old window - the one from
                // which the open action was invoked. We want the newest
                TableauFrame tf = WorkflowManager.getRankingTableauFrame();
                WorkflowManager.getInstance().getWorkflow(tf, workflowLsid).addReportLayout(tf, rl);
                
                //try to refresh the UI
                NamedObj namedObj = ObjectManager.getInstance().getObjectRevision(workflowLsid);
                JLabel dummyComponent = new JLabel();
                ReportingStateChangeEvent event = new ReportingStateChangeEvent(dummyComponent, ReportingStateChangeEvent.REPORT_LAYOUT_CHANGED, namedObj);
                StateChangeMonitor.getInstance().notifyStateChange(event);
                dummyComponent = null;
                
                return true;
        }

        /*
         * (non-Javadoc)
         * 
         * @see org.kepler.kar.KAREntryHandler#open(java.util.jar.JarEntry)
         */
        public CacheObject cache(KARFile karFile, KAREntry entry) throws Exception {
                if (isDebugging) {
                        log.debug("cache(" + karFile.toString() + "," + entry.toString() + ")");
                }
                
                // look up the LSID for the entry, do we need it?
                KeplerLSID reportLsid = entry.getLSID();
                
                // reportLsid.getRevision()
                
                //create the reportLayout object
                InputStream is = karFile.getInputStream(entry);
                ReportLayout rl = ReportRenderer.convertXML2Report(is);

                // giving both e.g. RIO.1.xml and Unnamed1_ROML.xml name "roml" like below 
                // seems to cause bug#4969. instead use entry.getName() so they're different.
                //ReportLayoutCacheObject rlco = new ReportLayoutCacheObject("roml", reportLsid);
                ReportLayoutCacheObject rlco = new ReportLayoutCacheObject(entry.getName(), reportLsid);
                rlco.setReportLayout(rl);
                //rlco.write();
                if (rlco == null) {
                        log.error("ReportLayoutCacheObject is null");
                }
                
                //set in the manager
                ///KeplerLSID workflowLsid = rl.getWorkflowLSID();
                
//              WorkflowManager wm = WorkflowManager.getInstance();
//              Workflow wf = wm.getWorkflow(workflowLsid);
//              List<ReportLayout> layouts = wf.getReportLayouts();
//              layouts.clear();
//              layouts.add(rl);
                
                // cache object for reporting
                return rlco;

        }

        /*
         * (non-Javadoc)
         * 
         * @see
         * org.kepler.kar.KAREntryHandler#save(org.kepler.objectmanager.lsid.KeplerLSID
         * )
         */
        public Hashtable<KAREntry, InputStream> save(Vector<KeplerLSID> lsids, KeplerLSID karLsid,
                        TableauFrame tableauFrame)
                throws Exception {
                if (isDebugging) log.debug("save("+lsids.toString()+", karLSID:" +karLsid.toString()+")");
                
                WorkflowRunManagerManager wrmm = WorkflowRunManagerManager.getInstance();
                WorkflowRunManager wrm = wrmm.getWRM(tableauFrame);
                
                Hashtable<KAREntry, InputStream> items = new Hashtable<KAREntry, InputStream>();

                for ( KeplerLSID lsid : lsids ) {
                        // determine what we are saving, and call the appropriate method
                        // no longer using OM to get the run here, Nov 03, 2010.
                        NamedObj nObj = wrm.getRun(lsid);
                        if (nObj == null){
                                //log.debug("current status of ObjectManager");
                                //ObjectManager.getInstance().printDebugInfo();
                                log.debug("WorkflowRunManager.getRun("+lsid+") returned null, try to get from ObjectManager.getInstance().getObjectRevision("+lsid+")");
                                nObj = ObjectManager.getInstance().getObjectRevision(lsid);
                        }
                        if (nObj == null){
                                log.debug("nObj == null");
                        }
                        if (nObj instanceof WorkflowRun) {
                                log.debug("nObj instanceof WorkflowRun");
                                WorkflowRun run = (WorkflowRun) nObj;
                                Hashtable<KAREntry,InputStream> wfRunLayouts = saveWorkflowRun(run, karLsid, tableauFrame);
                                items.putAll(wfRunLayouts);
                        } else if (nObj instanceof CompositeEntity) {
                                log.debug("nObj instanceof CompositeEntity");
                                // Must avoid putting both ROMLs into the KAR when it's a run-KAR since they 
                                // (atm - r24489) both have the same LSID, and can therefore otherwise end 
                                // up with the ROML that does not dependsOn the run in the KAR.
                                if (wrm.getSelectedRunsForSave() == null || wrm.getSelectedRunsForSave().isEmpty()){
                                        log.debug("calling saveReportLayout("+lsid+")");
                                        Hashtable<KAREntry,InputStream> workflowLayouts = saveReportLayout(lsid);
                                        items.putAll(workflowLayouts);
                                }
                        }
                }
                return items;
                
        }
        
        /**
         * This method is intended for serializing Layouts that have been saved 
         * with a particular workflow execution. It DOES use provenance for looking it up
         * @param run
         * @return
         * @throws Exception
         */
        private Hashtable<KAREntry, InputStream> saveWorkflowRun(WorkflowRun run, KeplerLSID karLsid, 
                        TableauFrame tableauFrame) throws Exception {
                
                Hashtable<KAREntry, InputStream> items = new Hashtable<KAREntry, InputStream>();
                
                if (run == null) {
                        log.debug("WorkflowRun is null");
                        return null;
                }
                
                // Get the layout item[s] for the run
                Hashtable<KAREntry, InputStream> layoutItems = this.getReportLayoutForWorkflowRun(run, tableauFrame);
                items.putAll(layoutItems);
                
                return items;
        }
        

        /**
         * This is intended to be used when serializing a ROML along with its MOML
         * This method does NOT use provenance to retrieve any information
         * @param lsid for the Workflow (not the report layout)
         * @return
         * @throws Exception
         */
        private Hashtable<KAREntry, InputStream> saveReportLayout(KeplerLSID lsid)
                        throws Exception {
                
                log.debug("saveReportLayout(" + lsid + ")");

                Hashtable<KAREntry, InputStream> items = new Hashtable<KAREntry, InputStream>();

                // Get the workflow from the object manager
                NamedObj nObj = ObjectManager.getInstance().getObjectRevision(lsid);
                if (nObj == null) {
                        // there is no guarantee that ObjectManager will return an object for an lsid
                        throw new Exception("Object not found.");
                }
                
                String workflowName = nObj.getName();
                
                ReportLayout reportLayout = null;
                KeplerLSID reportLayoutLsid = null;

                try {
                        // if we don't have a layout for this current LSID,
                        // then we need to look up the last LSID used to link them up
                        if (!WorkflowManager.getInstance().workflowExists(lsid)) {
                                log.debug("workflow/layout does not exist for LSID=" + lsid);
                                // use the last entry in the derived from list to find the most recent one
                                NamedObjIdReferralList nObjIdList = NamedObjId.getIDListAttributeFor(nObj);
                                List<KeplerLSID> referrals = nObjIdList.getReferrals();
                                if (referrals != null && referrals.size() > 0) {
                                        KeplerLSID oldLsid = referrals.get(0);
                                        log.debug("looking up layout using older revision, oldLSID=" + oldLsid);

                                        // look up the report layout - using old LSID
                                        //TODO change to just passing in tableauFrame?
                                        TableauFrame tf = WorkflowManager.getRankingTableauFrame();
                                        reportLayout = WorkflowManager.getInstance().getWorkflow(tf, oldLsid).getReportLayout(tf);
                                }
                        } else {
                                // look up the report layout - lsid should be golden now
                                TableauFrame tf = WorkflowManager.getRankingTableauFrame();
                                reportLayout = WorkflowManager.getInstance().getWorkflow(tf, lsid).getReportLayout(tf); 
                        }
                        
                        // if reportLayout is null just return
                        if (reportLayout == null || reportLayout.isBlank()){
                                log.warn("reportLayout is null or blank, not saving an entry to KAR");
                                return items;
                        }
                        
                        // synch the LSID on the layout before saving
                        reportLayout.setWorkflowLSID(lsid);
                }
                
                
                catch (Exception e) {
                        log.error("Could not set LSID for ReportLayout: " + e.getMessage());
                }

                // Get the ROML as xml 
                File xml = File.createTempFile("roml", ".xml");
                xml.deleteOnExit();
                ReportRenderer.convertReport2XML(reportLayout, xml);
                
                // make an entry for the roml
                String entryName = workflowName + "_ROML.xml";
                log.debug(entryName);
                
                // Make an entry for the layout
                KAREntry entry = new KAREntry(entryName);
                
                // Set the LSID/type for the reportLayout entry
                entry.setLSID(reportLayout.getLsid());
                // reportLayout.getClass().getName() can return a ReportInstance on KAR open, refer to class
                // instead of object
                //entry.setType(reportLayout.getClass().getName());
                entry.setType(ReportLayout.class.getName());
                entry.addLsidDependency(reportLayout.getWorkflowLSID());

                log.debug("adding entry to KAR: " + entryName);

                items.put(
                                entry, 
                                new FileInputStream(xml));
                
                return items;

        }

        private Hashtable<KAREntry, InputStream> getReportLayoutForWorkflowRun(WorkflowRun run,
                        TableauFrame tableauFrame) {
                
                Hashtable<KAREntry, InputStream> items = new Hashtable<KAREntry, InputStream>();
                
                // Get a queryable for the workflow that ran
                Queryable queryable = null;
                try {
                        queryable = ProvenanceUtil.getQueryable(run.getWorkflowLSID(), tableauFrame);
                } catch (Exception e3) {
                        log.error("could not find queryable for the workflow: " + run.getWorkflowLSID());
                        e3.printStackTrace();
                }
                
                // Get the report layout from provenance
                ReportLayout reportLayout = null;
                byte[] romlXML = null;
                Map<String, String> metadataMap = new HashMap<String, String>();
                metadataMap.put("type", ReportLayout.class.getName());
                List<byte[]> dataList = null;
                try {
                        dataList = queryable.getAssociatedDataForExecution(
                                                        run.getExecId(), 
                                                        metadataMap, 
                                                        false);
                        if (dataList != null && !dataList.isEmpty()) {
                                romlXML = dataList.get(0);
                                // only constructing this to get the layout LSID
                                reportLayout = ReportRenderer.convertXML2Report(new ByteArrayInputStream(romlXML));
                        }
                        else {
                                log.warn("no data file found for reportLayout, run= " + run.getExecId());
                        }
                } catch (Exception e2) {
                        log.error("error looking up report layout XML: " + e2.getMessage());
                        e2.printStackTrace();
                }
        
                if (reportLayout == null) {
                        return items;
                }
                
                // Add the ROML XML
                log.debug("Adding ReportLayout: " + reportLayout);
                KAREntry entryROML= new KAREntry("ROML." + run.getExecId() + ".xml");
                try {
                        entryROML.setLSID( reportLayout.getLsid() );
                        entryROML.setType( ReportLayout.class.getName() );
                        entryROML.addLsidDependency( reportLayout.getWorkflowLSID() );
                        entryROML.addLsidDependency( run.getExecLSID() );
                        items.put(entryROML, new ByteArrayInputStream(romlXML));
                } catch (Exception e1) {
                        log.error("error adding ROML XML entry: " + e1.getMessage());
                        e1.printStackTrace();
                }
                
                return items;
        }

        /**
         * A factory that creates a KAREntryHandler object.
         * 
         *@author aaron
         */
        public static class Factory extends KAREntryHandlerFactory {
                /**
                 * Create a factory with the given name and container.
                 * 
                 *@param container
                 *            The container.
                 *@param name
                 *            The name of the entity.
                 *@exception IllegalActionException
                 *                If the container is incompatible with this attribute.
                 *@exception NameDuplicationException
                 *                If the name coincides with an attribute already in the
                 *                container.
                 */
                public Factory(NamedObj container, String name)
                                throws IllegalActionException, NameDuplicationException {
                        super(container, name);
                }

                /**
                 * Create a library pane that displays the given library of actors.
                 * 
                 * @return A new LibraryPaneTab that displays the library
                 */
                public KAREntryHandler createKAREntryHandler() {
                        if (isDebugging)
                                log.debug("createKAREntryHandler()");
                        ReportLayoutKAREntryHandler rlkeh = new ReportLayoutKAREntryHandler();
                        return rlkeh;
                }
        }

}