/* OPM XML output

Copyright (c) 2009-2010 The Regents of the University of California.
All rights reserved.
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.opm;

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.io.StringWriter;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import javax.xml.bind.JAXBException;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;

import org.kepler.provenance.FireState;
import org.kepler.provenance.PortConnector;
import org.kepler.provenance.Recording;
import org.kepler.provenance.RecordingException;
import org.kepler.provenance.RecordingParameters;
import org.openprovenance.model.Artifact;
import org.openprovenance.model.ArtifactId;
import org.openprovenance.model.Artifacts;
import org.openprovenance.model.CausalDependencies;
import org.openprovenance.model.OPMFactory;
import org.openprovenance.model.OPMGraph;
import org.openprovenance.model.OPMSerialiser;
import org.openprovenance.model.OTime;
import org.openprovenance.model.ObjectFactory;
import org.openprovenance.model.Process;
import org.openprovenance.model.ProcessId;
import org.openprovenance.model.Processes;
import org.openprovenance.model.Role;
import org.openprovenance.model.Used;
import org.openprovenance.model.WasGeneratedBy;

import ptolemy.actor.Actor;
import ptolemy.actor.CompositeActor;
import ptolemy.actor.FiringEvent;
import ptolemy.actor.FiringsRecordable;
import ptolemy.actor.IOPort;
import ptolemy.actor.IOPortEvent;
import ptolemy.actor.TypedIOPort;
import ptolemy.data.StringToken;
import ptolemy.data.Token;
import ptolemy.data.expr.FileParameter;
import ptolemy.data.expr.Parameter;
import ptolemy.kernel.util.Attribute;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.kernel.util.NameDuplicationException;
import ptolemy.kernel.util.NamedObj;

/** A Recording for Open Provenance Model XML.
 *
 * @author Daniel Crawl
 * @version $Id: OpenProvenanceModelXML.java 33496 2015-06-22 20:24:20Z crawl $
 * @deprecated This recording output is no longer used. Instead, use ProvRecording.
 */
@Deprecated    
public class OpenProvenanceModelXML extends Recording
{

    /** Construct a new OpenProvenanceModelXML. */
    public OpenProvenanceModelXML() throws RecordingException
    {
        _params = null;

        _portConnector = new PortConnector<ArtifactId>();

        _fireStateTable = new LinkedHashMap<Actor, FireState<ProcessId>>();

        _tokenToArtifactIdMap = new HashMap<Token,ArtifactId>();
        _artifactCounter = 0;
        _processCounter = 0;

        _compositePortToProcessMap = new HashMap<CompositeMapKey,ProcessId>();
        _portFiringCounter = 0;

        _namedObjToRoleMap = new HashMap<NamedObj,Role>();

        _objectFactory = new ObjectFactory();
        _opmFactory = OPMFactory.getFactory();
   
        try
        {
            _opmSerialiser = new OPMSerialiser();
        }
        catch(JAXBException e)
        {
            throw new RecordingException("Unable to create new serializer: ", e);
        }
        
        try
        {
            _dataTypeFactory = DatatypeFactory.newInstance();
        }
        catch(DatatypeConfigurationException e)
        {
            throw new RecordingException("Error trying to get new DataTypeFactory: ", e); 
        }

        Artifacts artifacts = _objectFactory.createArtifacts();
        _artifactList = artifacts.getArtifact();

        Processes processes = _objectFactory.createProcesses();
        _processList = processes.getProcess();
        
        CausalDependencies depends = _objectFactory.createCausalDependencies();
        _dependList = depends.getUsedOrWasGeneratedByOrWasTriggeredBy();
        
        _graph = _objectFactory.createOPMGraph();
        _graph.setArtifacts(artifacts);
        _graph.setProcesses(processes);
        _graph.setCausalDependencies(depends);
       
        _needWorkflowContents(true);
    }

    /** React to a parameter change. */
    public void attributeChanged(Attribute attribute)
        throws IllegalActionException
    {
        
        String name = attribute.getName();

        if(name.equals(OPMRecordingParameters._filenameStr))
        {
            _resetWriter(); 
        }
        else
        {
            super.attributeChanged(attribute); 
        }

    }

    /** Register an actor. */
    public boolean regActor(Actor actor) throws RecordingException
    {
        if(actor instanceof FiringsRecordable)
        {
            FireState<ProcessId> fireState = new FireState<ProcessId>(actor, -1);
            _fireStateTable.put(actor, fireState);
        }

        return true;
    }

    /** Register a port or portparameter.  */
    public boolean regPort(TypedIOPort port) throws RecordingException
    {
        boolean retval = super.regPort(port);

        _portConnector.createConnections(port);

        return retval;
    }

    /** Record the starting of workflow execution. */
    public void executionStart() throws RecordingException
    {
        _artifactList.clear();
        _processList.clear();
        _dependList.clear();
        _namedObjToRoleMap.clear();
        _artifactCounter = 0;
        _processCounter = 0;
        _tokenToArtifactIdMap.clear();
        _compositePortToProcessMap.clear();
        _portFiringCounter = 0;
    }

    /** Record the stopping of workflow execution. */
    public void executionStop() throws RecordingException
    {
        // output serialization

        StringWriter writer = new StringWriter();

        try
        {
            String string = _opmSerialiser.serialiseOPMGraph(writer, _graph, true);

            if(_textWriter != null)
            {
                _textWriter.print(string);
            }
        }
        catch(JAXBException e)
        {
            throw new RecordingException("Error serializing graph: ", e);
        }
    }

    /** Record an actor firing. */
    public void actorFire(FiringEvent event) throws RecordingException
    {
        Actor actor = event.getActor();
        FiringEvent.FiringEventType curEventType = event.getType();
        FireState<ProcessId> fireState = _fireStateTable.get(actor);
        
        if(fireState == null)
        {
            throw new RecordingException(
                "Received actor fire event for unregistered actor: " +
                actor.getFullName());
        }

        synchronized(fireState)
        {
            // get the last type of firing start
            FiringEvent.FiringEventType lastStartType =
                fireState.getLastStartFireType();

            // see if current firing is new iteration:
            // NOTE: PN does not report iterate firings so the iteration
            // may begin with prefire if the last type of firing was not
            // iterate.
            if(curEventType == FiringEvent.BEFORE_ITERATE ||
                (curEventType == FiringEvent.BEFORE_PREFIRE &&
                lastStartType != FiringEvent.BEFORE_ITERATE))
            {
                
                // create a new process for the new firing
                org.openprovenance.model.Process process = _objectFactory.createProcess();
                _processList.add(process);
               
                process.setId("_p" + String.valueOf(_processCounter));
                _processCounter++;

                // set the process name to be the actor name and number of
                // times it has fired.
                String actorName = ((NamedObj)actor).getFullName();
                int firings = fireState.getNumberOfFirings();
                process.setValue(actorName + " fire " + firings);
                ProcessId processId = _opmFactory.newProcessId(process);

                // start the fire in the fire state.
                fireState.fireStart(curEventType, processId);

                //_debug("adding process id " + actorName + " fire " + firings);
                
                // record the parameters used.

                List<?> attributeList = ((NamedObj)actor).attributeList();
                for(int i = 0; i < attributeList.size(); i++)
                {
                    Attribute attribute = (Attribute)attributeList.get(i);
                    _createUsedForParameter(attribute, processId);
                }
                

            }
            // see if current firing is end of iteration:
            else if(curEventType == FiringEvent.AFTER_ITERATE ||
                (curEventType == FiringEvent.AFTER_POSTFIRE &&
                lastStartType == FiringEvent.BEFORE_PREFIRE))
            {
                //_debug("end firing: " + type + " for " + actor.getFullName());

                // NOTE: if the type is a AFTER_POSTFIRE and last start
                // type is BEFORE_PREFIRE, we are running in PN.
                // in this case, tell the fireState to stop firing using
                // AFTER_PREFIRE instead of AFTER_POSTFIRE, since we never
                // told the fireState about the BEFORE_POSTFIRE.
                if(curEventType == FiringEvent.AFTER_POSTFIRE)
                {
                    fireState.fireStop(FiringEvent.AFTER_PREFIRE);
                }
                else
                {
                    fireState.fireStop(curEventType);
                }
            }
        }
    }
    
    /** Record a port event. */
    public void portEvent(IOPortEvent event) throws RecordingException
    {
        TypedIOPort port = (TypedIOPort)event.getPort();
        Actor actor = (Actor)port.getContainer();
        FireState<ProcessId> fireState = _fireStateTable.get(actor);
        
        synchronized(fireState)
        {
            int eventType = event.getEventType();
            boolean recordEvent = false;
            boolean isRead = true;

            if(eventType == IOPortEvent.SEND_BEGIN)
            {
                recordEvent = true;
                isRead = false;
            }   
            else if(eventType == IOPortEvent.GET_END)
            {
                recordEvent = true;
            }

            if(recordEvent)
            {
                ProcessId processId = fireState.getCurFireId();

                if(actor instanceof CompositeActor)
                {
                    if(processId == null)
                    {
                        System.out.println("pid is null, actor = " + actor.getFullName());
                    }

                    CompositeMapKey key = new CompositeMapKey(processId, port);

                    processId = _compositePortToProcessMap.get(key);
                    if(processId == null)
                    {
                        // create a new process for the new firing
                        org.openprovenance.model.Process process = _objectFactory.createProcess();
                        _processList.add(process);
                        
                        process.setId("_p" + String.valueOf(_processCounter));
                        _processCounter++;
                        
                        String name = port.getFullName();
                        int firings = _portFiringCounter++;
                        process.setValue(name + " fire " + firings);
                        processId = _opmFactory.newProcessId(process);
 
                        _compositePortToProcessMap.put(key, processId);
                    }
                }

                if(event.getVectorLength() == IOPortEvent.SINGLETOKEN)
                {
                    _recordPortEvent(port, processId, isRead, event.getChannel(), event.getToken());
                }
                else
                {
                    Token[] tokenArray = event.getTokenArray();
                    for(int i = 0; i < tokenArray.length; i++)
                    {
                        _recordPortEvent(port, processId, isRead, event.getChannel(), tokenArray[i]);
                    }
                }
            }
        } 
    }

    /** Add Parameters for ProvenanceListener. */
    public RecordingParameters generateParameters(NamedObj no)
        throws IllegalActionException, NameDuplicationException
    {
        _params = new OPMRecordingParameters(no);
        return _params;
    }

    ////////////////////////////////////////////////////////////////////////
    //// protected methods                                              ////

    /** Record a port read or write. */
    protected void _recordPortEvent(IOPort port, ProcessId processId,
        boolean isRead, int channel, Token token)
        throws RecordingException
    {
    
        Role role = _getRole(port);

        if(isRead)
        {
            ArtifactId artifactId = _portConnector.getNextId(port, channel);
            _createNewUsed(artifactId, processId, role);
        }
        else
        {
            ArtifactId artifactId = _getArtifactId(token, true);

            WasGeneratedBy wasGeneratedBy = _objectFactory.createWasGeneratedBy();
            wasGeneratedBy.setCause(processId);
            wasGeneratedBy.setEffect(artifactId);
            wasGeneratedBy.setTime(_getCurrentOTime());
            wasGeneratedBy.setRole(role);
            _dependList.add(wasGeneratedBy);

            _portConnector.sendIdToConnections(port, channel, artifactId);
        }
    }

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

    /** Close the writer unless it is stdout or stderr. */
    private void _closeWriter()
    {
        if(_textWriter != null)
        {
            // don't close stdout or stderr
            if(!_outputName.equals("System.out") &&
                !_outputName.equals("System.err"))
            {
                _textWriter.close();
            }
            else
            {
                _textWriter.flush();
            }
        }
    }

    /** Get an existing or create a new ArtifactId for a token. */
    private ArtifactId _getArtifactId(Token token, boolean isNewToken)
    {
        ArtifactId retval = null;
        
        if(!isNewToken)
        {
            retval = _tokenToArtifactIdMap.get(token);
        }

        if(retval == null)
        {
            Artifact artifact = _objectFactory.createArtifact();
            _artifactList.add(artifact);
        
            artifact.setId("_a" + String.valueOf(_artifactCounter));
            _artifactCounter++;
            
            // if it's a string token, use stringValue so we don't
            // get the quotes.
            if(token instanceof StringToken)
            {
                artifact.setValue(((StringToken)token).stringValue());
            }
            else
            {
                artifact.setValue(token.toString());
            }

            retval = _opmFactory.newArtifactId(artifact);

            _tokenToArtifactIdMap.put(token, retval);
        }

        return retval;
    }

    private void _createNewUsed(ArtifactId artifactId, ProcessId processId, Role role)
    {
        Used used = _objectFactory.createUsed();
        _dependList.add(used);
        
        used.setCause(artifactId);
        used.setEffect(processId);
        used.setTime(_getCurrentOTime());
        used.setRole(role);
    }

    private void _createUsedForParameter(Attribute attribute, ProcessId processId)
        throws RecordingException
    {
        if( (attribute instanceof Parameter) &&
           !(attribute instanceof ptolemy.data.expr.ExpertParameter) &&
           !(attribute instanceof ptolemy.actor.gui.WindowPropertiesAttribute) &&
           !(attribute instanceof ptolemy.actor.gui.SizeAttribute) &&
           !(attribute instanceof org.kepler.sms.SemanticType))
        {
            //_debug(attribute); 
            Parameter parameter = (Parameter)attribute;
            Token token = null;

            try
            {
                token = parameter.getToken();
            }
            catch(IllegalActionException e)
            {
                throw new RecordingException("Error reading parameter token: ", e);
            }
            
            if(token != null)
            {
                Role role = _getRole(attribute);
                ArtifactId artifactId = _getArtifactId(token, false);
                _createNewUsed(artifactId, processId, role);
            }
        }
    }

    /** Get a new OTime representing the current date and time. */
    private OTime _getCurrentOTime()// throws Exception
    {
        OTime retval = _objectFactory.createOTime();
        //retval.setClockId("clock id");
        XMLGregorianCalendar cal = _dataTypeFactory.newXMLGregorianCalendar(new GregorianCalendar());
        retval.setNoEarlierThan(cal);
        retval.setNoLaterThan(cal);
        retval.setClockId("_c1");
        return retval;
    }

    /** Get a role for a NamedObj. */
    private Role _getRole(NamedObj namedObj)
    {
        Role retval = null;
        
        if((retval = _namedObjToRoleMap.get(namedObj)) == null)
        {
            retval = _objectFactory.createRole();
            _namedObjToRoleMap.put(namedObj, retval);
            retval.setValue(namedObj.getName());
        }

        return retval;
    }

    /** Reset the output writer. */
    private void _resetWriter() throws IllegalActionException
    {
        FileParameter fp = _params.getFileParameter();
        String name = ((StringToken)fp.getToken()).stringValue();

        // see if the output name has changed or was never set
        if(_outputName == null || !name.equals(_outputName))
        {
            _closeWriter();

            // see if we should write to stdout
            if(name.equals("System.out"))
            {
                _textWriter = System.out;
            }
            // see if we should write to stderr
            else if(name.equals("System.err"))
            {
                _textWriter = System.err;
            }
            else if(name.equals("NULL"))
            {
                _textWriter = null;
            }
            else
            {
                // remove possible "file:" prefix
                if(name.startsWith("file:"))
                {
                    name = name.substring("file:".length());
                }

                try
                {
                    _textWriter = new PrintStream(name);
                }
                catch(FileNotFoundException e)
                {
                    throw new IllegalActionException("Could not find file " +
                        name + " : " + e.getMessage());
                }
            }

            // save the name
            _outputName = name;
        }
    }

    ////////////////////////////////////////////////////////////////////////
    //// private classes                                                ////
   
    private static class OPMRecordingParameters extends RecordingParameters
    {
        OPMRecordingParameters(NamedObj no) throws IllegalActionException, NameDuplicationException
        {
            super(no);
            addFileParameter(_filenameStr, "System.out");
        }

        /** Replace a Parameter. */
        public void replaceParameter(String name, Parameter parameter)
            throws IllegalActionException
        {
            // if replacing the filename, close the file.
            if(name.equals(_filenameStr))
            {
                FileParameter p = (FileParameter)_params.get(_filenameStr);
                p.close();
            }

            super.replaceParameter(name, parameter);
        }

        /** Get the output FileParameter. */
        FileParameter getFileParameter() throws IllegalActionException
        {
            return (FileParameter)_params.get(_filenameStr);
        }

        private static final String _filenameStr = "Filename";
    }

    private static class CompositeMapKey
    {
        public CompositeMapKey(ProcessId processId, IOPort port)
        {
            this.processId = processId;
            this.port = port;
        }

        public int hashCode()
        {
            return processId.hashCode() + port.hashCode();
        }

        public boolean equals(Object obj)
        {
            if(!(obj instanceof CompositeMapKey))
            {
                return false;
            }
            else
            {
                CompositeMapKey other = (CompositeMapKey)obj;
                return processId.equals(other.processId) &&
                    port.equals(other.port);
            }
        }

        public ProcessId processId;
        public IOPort port;
    }

    /*
    private static class TokenInfo
    {
        public TokenInfo(ArtifactId artifactId)
        {
            _artifactId = artifactId;
        }

        public ArtifactId getArtifactId()
        {
            return _artifactId;
        }

        private ArtifactId _artifactId;
    }
    */

    ////////////////////////////////////////////////////////////////////////
    //// private variables                                              ////

    private ObjectFactory _objectFactory;
    private OPMFactory _opmFactory;
    private DatatypeFactory _dataTypeFactory;

    private OPMGraph _graph;
    private List<Artifact> _artifactList;
    private List<Process> _processList;
    private List<Object> _dependList;
        
    private OPMSerialiser _opmSerialiser;
    
    //private Map<Actor,Process>

    /** A table to map actor to its firing state object. */
    private Map<Actor, FireState<ProcessId>> _fireStateTable = null;

    private PortConnector<ArtifactId> _portConnector;

    private OPMRecordingParameters _params;

    /** Output writer. */
    private PrintStream _textWriter = null;

    /** Output name. */
    private String _outputName = null;

    private Map<NamedObj, Role> _namedObjToRoleMap;

    private int _artifactCounter;
    private int _processCounter;

    private Map<Token,ArtifactId> _tokenToArtifactIdMap;

    private Map<CompositeMapKey,ProcessId> _compositePortToProcessMap;

    private int _portFiringCounter;
}