/*
 * Copyright (c) 2008-2010 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: berkley $'
 * '$Date: 2010-04-28 00:12:36 +0000 (Wed, 28 Apr 2010) $' 
 * '$Revision: 24000 $'
 * 
 * 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.util.HashMap;
import java.util.Map;

import ptolemy.actor.Actor;
import ptolemy.actor.FiringEvent;

/**
 *
 * A utility class to keep track of an actor's firing.
 *
 * @author Daniel Crawl
 * @version $Id: FireState.java 24000 2010-04-28 00:12:36Z berkley $
 *
 */
    
public class FireState<FireIdType>
{
    /** Construct a FireState with an actor and its id. */
    public FireState(Actor actor, int id)
    {
        _actor = actor;
        _actorId = id;
        _typesIndicesMap = new HashMap<String,FireIdType>();
        _portLastAccess = PortAccessType.Uninitialized;
        
        _currentFireType = null;
        _lastStartFireType = null;

        _firings = 0;
    }

    /** Get the actor. */
    public Actor getActor()
    {
        return _actor;
    }

    /** Get the actor's id. */
    public int getActorId()
    {
        return _actorId;
    }

    
    /** Record the start of a firing for this actor. 
     *
     * @param type type of firing.
     * @param fireId fire id.
     * 
     */
    public void fireStart(FiringEvent.FiringEventType type, FireIdType fireId)
    {
        _typesIndicesMap.put(type.getTypeName(), fireId);

        /*
        _debug("fire started " + _getName() + " " + type.getTypeName() + 
            " -> " + fireId);
        */

        // record the type if not rw
        if(type.isStart() && type != FiringEvent.BEFORE_RW_FIRE)
        {
            _currentFireType = type;
            _lastStartFireType = type;
        }
    }

    /** Record the stop of a firing, and get the fire index 
     *  for a type of fire. 
     *
     *  @param type the current type of fire that running
     *  @return the firing id
     */
    public FireIdType fireStop(FiringEvent.FiringEventType type)
    {
        //_debug("fire stopped " + _getName() + " " + type.getTypeName());

        FireIdType retval = _typesIndicesMap.remove(type.getTypeName());

        // if not rw, remove last fire type.
        if(! type.isStart() && type != FiringEvent.AFTER_RW_FIRE)
        {
            _currentFireType = null;
            _lastStartFireType = type;
        }

        _firings++;

        return retval;
    }

    /** Get the current (non-rw) firing index. */
    public FireIdType getCurFireId()
    {
        return getCurFireId(false);
    }

    /** Get the current firing index.
     *
     * @param wantRWFireId If true, return current rw fire id, else
     * return current non-rw fire id. In the latter case, it returns
     * the id of the most recent prefire, fire, or postfire to start.
     * If none of those three types of fire are currently running,
     * it returns the id of the currently "iterate" firing. If no
     * "iterate" is currently running, returns UNKNOWN_FIRE_ID.
     */
    public FireIdType getCurFireId(boolean wantRWFireId)
    {
        FireIdType retval = null;

        // see if we should return rw fire id.
        if(wantRWFireId)
        {
            retval = _typesIndicesMap.get(FiringEvent.BEFORE_RW_FIRE.getTypeName());
            //_Debug(_getName() + " rw fire id: " + id);
        }
        else if(_currentFireType != null)
        {
            retval = _typesIndicesMap.get(_currentFireType.getTypeName());
            //_Debug(_getName() + " " + _currentFireType + " id: " + id);
        }

        return retval;
    }

    /** Get the last starting firing type seen. */
    public FiringEvent.FiringEventType getLastStartFireType()
    {
        return _lastStartFireType;
    }

    /** Get the expected firing type for stopping the firing iteration. */
    public FiringEvent.FiringEventType getNextStopFiringType()
        throws RecordingException
    {
        FiringEvent.FiringEventType retval = null;
       
        // see if firing iteration started with iterate
        if(_currentFireType == FiringEvent.BEFORE_ITERATE)
        {
            retval = FiringEvent.AFTER_ITERATE;
        }
        // see if it started with prefire or postfire
        else if(_currentFireType == FiringEvent.BEFORE_PREFIRE ||
            _currentFireType == FiringEvent.BEFORE_POSTFIRE)
        {
            retval = FiringEvent.AFTER_POSTFIRE;
        }
        else if(_currentFireType == FiringEvent.BEFORE_FIRE)
        {
            retval = FiringEvent.AFTER_FIRE;
        }
        else if(_currentFireType != null)
        {
            throw new RecordingException("ERROR: unexpected current fire " +
                "type: " + _currentFireType + " for actor " +
                _actor.getFullName());
        }

        return retval;
    }

    /** Return the number of firings seen. The number is incremented each
     *  time fireStop() is called.
     */
    public int getNumberOfFirings()
    {
        return _firings; 
    }

    /** Get the last port access for the actor. */
    public PortAccessType getPortLastAccess()
    {
        return _portLastAccess;
    }

    /** Set the last port access for the actor. */
    public void setPortLastAccess(PortAccessType type)
    {
        _portLastAccess = type;
    }

    ////////////////////////////////////////////////////////////////////////
    //// public variables

    /** The types of port accesses. */
    public enum PortAccessType
    {
        Read,
        Write,
        Uninitialized
    };

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

    /** Get the full name of the actor. */
    private String _getName()
    {
        return _actor.getFullName();
    }

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

    /** The actor. */
    private Actor _actor;

    /** The actor id. */
    private int _actorId;

    /** A mapping of firing types to fire indices. */
    private Map<String,FireIdType> _typesIndicesMap;

    /** The type of firing currently executing. */
    private FiringEvent.FiringEventType _currentFireType;
    
    /** The type of starting firing last seen. */
    private FiringEvent.FiringEventType _lastStartFireType;

    /** The last kind of access to a port contained by this actor. */
    private PortAccessType _portLastAccess;

    /** The number of firings. */
    private int _firings;
}