/*
 * Copyright (c) 2007-2010 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2015-04-20 20:58:30 +0000 (Mon, 20 Apr 2015) $' 
 * '$Revision: 33352 $'
 * 
 * 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;

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.kepler.tagging.TagEvent;

import ptolemy.actor.Actor;
import ptolemy.actor.Director;
import ptolemy.actor.FiringEvent;
import ptolemy.actor.IOPortEvent;
import ptolemy.actor.IORelation;
import ptolemy.actor.LocalClock;
import ptolemy.actor.TypedIOPort;
import ptolemy.data.StringToken;
import ptolemy.data.expr.FileParameter;
import ptolemy.data.expr.Parameter;
import ptolemy.kernel.Port;
import ptolemy.kernel.util.AbstractSettableAttribute;
import ptolemy.kernel.util.Attribute;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.kernel.util.NameDuplicationException;
import ptolemy.kernel.util.Nameable;
import ptolemy.kernel.util.NamedObj;

/** A provenance Recording that writes to a text file.
 *
 * @author Daniel Crawl
 * @version $Id: TextFileRecording.java 33352 2015-04-20 20:58:30Z crawl $
 *
 */
    
public class TextFileRecording extends Recording
{

    /** Create a new provenance recording. */
    public TextFileRecording() throws RecordingException
    {
        super();

        _dFormat = new SimpleDateFormat("HH:mm:ss");

        _needWorkflowContents(true);
    }

    /** Stop recording. This is the last method called to a 
     *  Recording instance.
     */
    @Override
    public void disconnect() throws RecordingException
    {
        //_writeOutput("disconnect.");
        _closeWriter();
    }

    // Specification
    
    /** Called before registering workflow contents. */
    @Override
    public void specificationStart() throws RecordingException
    {
        super.specificationStart();

        if(_recordSpecVal)
        {
            _writeOutput("Specification started."); 
        }
    }

    /** Called when finished registering workflow contents. */
    @Override
    public void specificationStop() throws RecordingException
    {
        super.specificationStop();

        if(_recordSpecVal)
        {
            _writeOutput("Specification stopped."); 
        }
    }

    /** Register an actor. */
    @Override
    public boolean regActor(Actor actor) throws RecordingException
    {
        if(_recordSpecVal)
        {
            _writeOutput("Actor: " + _getNameableFullName(actor));
        }
        return true;
    }

    /** Register a director. */
    @Override
    public boolean regDirector(Director director) throws RecordingException
    {
        if(_recordSpecVal)
        {
            _writeOutput("Director: " + _getNameableFullName(director));
        } 
        return true; 
    }

    /** Register a parameter. A parameter can be any <b>entity</b>
     * stored in the MoML that does not have its own
     * <code>regNNN()</code> method. This can be user-level 
     * parameters (e.g., Parameter, StringParameter, etc.) or
     * internal to Kepler (e.g., _location, semanticType000, etc.).
     * (A "parameter" corresponds to a property in the MoML).
     *
     */
    @Override
    public boolean regParameter(NamedObj parameter) throws RecordingException
    {
        if(_recordSpecVal && !(parameter instanceof LocalClock))
        {
            if(parameter instanceof AbstractSettableAttribute)
            {
                String output = "Parameter: " + _getNameableFullName(parameter) +
                    " = " + 
                    ((AbstractSettableAttribute)parameter).getValueAsString();

                if(parameter instanceof org.kepler.moml.NamedObjId)
                {
                    _writeOutput(output, false);

                    _debugWrite("Parameter: " + _getNameableFullName(parameter) +
                        " = lsid");
                }
                else
                {
                    _writeOutput(output);
                }
            }
            else
            {
                _writeOutput("Parameter: " + _getNameableFullName(parameter));
            }
        }
        return true; 
    }

    /** Register a link between two endpoints.  */
    @Override
    public boolean regLink(NamedObj endPoint1, NamedObj endPoint2)
        throws RecordingException
    {
        if(_recordSpecVal)
        {
            _writeOutput("Link: " + _getNameableFullName(endPoint1) + " <---> " + 
                _getNameableFullName(endPoint2));
        }
        return true; 
    }

    /** Register a port or portparameter.  */
    @Override
    public boolean regPort(TypedIOPort port) throws RecordingException
    {
        if(_recordSpecVal)
        {
            _writeOutput("Port: " + _getNameableFullName(port));
        }
        return true; 
    }

    /** Register a relation. */
    @Override
    public boolean regRelation(IORelation relation) throws RecordingException
    {
        if(_recordSpecVal)
        {
            _writeOutput("Relation: " + _getNameableFullName(relation));
        }
        return true; 
    }
    
    // Evolution of workflow structure.
   
    @Override
    public void evolutionStart() throws RecordingException
    {
        if(_recordSpecVal) 
        {
            _writeOutput("Evolution started.");
        }
    }

    @Override
    public void evolutionStop() throws RecordingException
    {
        if(_recordSpecVal) 
        {
            _writeOutput("Evolution stopped.");
        }
    }
 
    @Override
    public void remove(String name) throws RecordingException
    {
        if(_recordSpecVal)
        {
            _writeOutput("Removed: " + name);
        }
    }

    @Override
    public void removeLink(String endPoint1, String endPoint2)
        throws RecordingException
    {
        if(_recordSpecVal)
        {
            _writeOutput("Removed link: " + endPoint1 + " <---> " +
                endPoint2);
        }
    }
   

    /** A NamedObj was renamed. */
    @Override
    public void rename(String oldName, String newName) 
        throws RecordingException
    {
        if(_recordSpecVal) 
        {
            _writeOutput("Rename: " + oldName + " ---> " + newName);
        }
    }

    // Execution of workflow
    
    /** Record the starting of workflow execution. */
    @Override
    public void executionStart() throws RecordingException
    {
        _needWorkflowContents(false);
        _writeOutput("Execution started.");
    }

    /** Record the stopping of workflow execution. */
    @Override
    public void executionStop() throws RecordingException
    {
        _writeOutput("Execution stopped.");
    }
    
    /** An actor threw an exception.  */
    @Override
    public void executionError(Nameable source, Throwable throwable)
        throws RecordingException
    {
        if(source != null)
        {
            _writeOutput("Execution error from " + source.getFullName() +
                ": " + throwable.getMessage());
        }
        else
        {
            _writeOutput("Execution error: " + throwable.getMessage());
        }
    }

    /** Record starting an actor fire event. */
    @Override
    public void actorFire(FiringEvent event, Date timestamp) throws RecordingException
    {
        String outputStr;
        if(_containerName != null)
        {
            String eventStr = event.toString();
            Actor actor = event.getActor();
            String fullName = actor.getFullName();
            outputStr = eventStr.replaceAll(fullName, _getNameableFullName(actor));
        }
        else
        {
            outputStr = event.toString();
        }
        
        _writeOutput(outputStr, timestamp);
    }

    /** Record a port event. */
    @Override
    public void portEvent(IOPortEvent event, Date timestamp) throws RecordingException
    {
        String outputStr;
        if(_containerName != null)
        {
            String eventStr = event.toString();
            Port port = event.getPort();
            String fullName = port.getFullName();
            outputStr = eventStr.replaceAll(fullName, _getNameableFullName(port));
        }
        else
        {
            outputStr = event.toString();
        }
        
        _writeOutput(outputStr, timestamp);
    }

    /** Record a custom provenance event. */
    @Override
    public void customProvEvent(ProvenanceEvent event) throws RecordingException
    {
        _writeOutput(event.toString());
    }

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

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

        if(name.equals(TextFileRecordingParameters._recordSpecStr))
        {
            boolean oldVal = _recordSpecVal;
            _recordSpecVal = _params.getRecordSpecValue();

            // see if we now want the specfication
            if(!oldVal && _recordSpecVal)
            {
                _needWorkflowContents(true);
            }
            else if(!_recordSpecVal)
            {
                _needWorkflowContents(false);
            }
        }
        else if(name.equals(TextFileRecordingParameters._filenameStr))
        {
            _resetWriter();
        }
        else if(name.equals(TextFileRecordingParameters._alwaysFlushStr))
        {
            _alwaysFlushVal = _params.getAlwaysFlushValue();

            // if should always flush and have existing writer,
            // flush any pending output.
            if(_alwaysFlushVal && _textWriter != null)
            {
                _textWriter.flush();
            }

        }
        else if(name.equals(TextFileRecordingParameters._addTimestampStr))
        {
            _addTimestampVal = _params.getAddTimestampValue();
        }
        else
        {
            super.attributeChanged(attribute);
        }
    }
    
    /** A tag was added. */
    @Override
    public void tagAdded(TagEvent event) throws RecordingException
    {
        _writeOutput("Tag added: " + event.toString());   
    }
    
    /** A tag was removed. */
    @Override
    public void tagRemoved(TagEvent event) throws RecordingException
    {
        _writeOutput("Tag removed: " + event.toString());
    }
   
    /** Set if the output should have a timestamp. */ 
    public void setAddTimestamp(boolean addTimestamp) {
        _addTimestampVal = addTimestamp;
    }
    
    ////////////////////////////////////////////////////////////////////////
    //// protected methods                                              ////

    /** Output a string. */
    protected void _write(String str) throws RecordingException
    {
        _write(str, true);
    }

    /** Output a string. */
    protected void _write(String str, boolean outputDebug) throws RecordingException
    {
        if(_textWriter != null)
        {
            _textWriter.println(str);
            if(_alwaysFlushVal)
            {
                _textWriter.flush();
            }
        }

        if(outputDebug && _debugWriter != null)
        {
            _debugWrite(str);
        }
    }

    /** Output a string, optionally adding a timestamp. */
    protected void _writeOutput(String str) throws RecordingException
    {
        _writeOutput(str, true, null);        
    }

    /** Output a string, optionally adding a timestamp. */
    protected void _writeOutput(String str, Date timestamp) throws RecordingException
    {
        _writeOutput(str, true, timestamp);        
    }

    /** Output a string, optionally adding a timestamp. */
    protected void _writeOutput(String str, boolean outputDebug)
        throws RecordingException {
        _writeOutput(str, outputDebug, null);
    }

    /** Output a string, optionally adding a timestamp. */
    protected void _writeOutput(String str, boolean outputDebug, Date timestamp)
        throws RecordingException
    {
        if(_addTimestampVal)
        {
            Date date;
            if(timestamp == null) {
                date = new Date();
            } else {
                date = timestamp;
            }
            String dateStr = _dFormat.format(date);
            _write(dateStr + ": " + str, outputDebug);
        }
        else
        {
            _write(str, outputDebug);
        }
    }

    ////////////////////////////////////////////////////////////////////////
    //// protected classes                                              ////

    /** Configuration Parameters for TextFileRecording. */
    protected class TextFileRecordingParameters extends RecordingParameters
    {
        TextFileRecordingParameters(NamedObj no)
            throws IllegalActionException, NameDuplicationException
        {
            super(no);
            addBooleanParameter(_recordSpecStr, _recordSpecVal);
            addFileParameter(_filenameStr, "System.out");
            addBooleanParameter(_alwaysFlushStr, _alwaysFlushVal);
            addBooleanParameter(_addTimestampStr, _addTimestampVal);
        }

        /** Get the "Record Specification" check-box value. */
        boolean getRecordSpecValue() throws IllegalActionException
        {
            return getBooleanValue(_recordSpecStr);
        }

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

        /** Get "Always Flush Output" check-box value. */
        boolean getAlwaysFlushValue() throws IllegalActionException
        {
            return getBooleanValue(_alwaysFlushStr);
        }

        /** Get "Timestamp Output" check-box value. */
        boolean getAddTimestampValue() throws IllegalActionException
        {
            return getBooleanValue(_addTimestampStr);
        }

        /** Replace a Parameter. */
        @Override
        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);
        }
            
        private static final String _recordSpecStr = "Record Specification";
        private static final String _filenameStr = "Filename";
        private static final String _alwaysFlushStr = "Always Flush Output";
        private static final String _addTimestampStr = "Timestamp Output";
    }

    ////////////////////////////////////////////////////////////////////////
    //// protected variables                                            ////

    /** Whether to record workflow specification. */
    protected boolean _recordSpecVal = true;

    /** Output writer. */
    protected PrintStream _textWriter = null;
    
    /** If true, flush after writing to output. */
    protected boolean _alwaysFlushVal = false;

    /** If true, add timestamp to output. */
    protected boolean _addTimestampVal = true;

    /** Format timestamps. */
    protected SimpleDateFormat _dFormat = null;

    /** Parameters for TextFileRecording */
    protected TextFileRecordingParameters _params = null;

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

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

    /** 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;
        }

        // if we're configured to recording workflow structure,
        // tell listener to re-send the structure since the file
        // changed.
        _needWorkflowContents(_recordSpecVal);
    }

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