/*
 * Copyright (c) 2015 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2015-11-02 20:02:37 +0000 (Mon, 02 Nov 2015) $' 
 * '$Revision: 34199 $'
 * 
 * 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.profiling.gui;

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JViewport;
import javax.swing.SwingUtilities;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellRenderer;

import org.kepler.objectmanager.lsid.KeplerLSID;
import org.kepler.provenance.FireState;
import org.kepler.provenance.ProvenanceEnabledListener;
import org.kepler.provenance.Recording;
import org.kepler.provenance.RecordingException;
import org.kepler.provenance.SimpleFiringRecording;

import ptolemy.actor.Actor;
import ptolemy.actor.CompositeActor;
import ptolemy.actor.FiringEvent;
import ptolemy.actor.IOPort;
import ptolemy.actor.IOPortEvent;
import ptolemy.actor.TypedIOPort;
import ptolemy.actor.gui.PtolemyFrame;
import ptolemy.domains.pn.kernel.PNDirector;
import ptolemy.kernel.util.Nameable;
import ptolemy.kernel.util.NamedObj;
import ptolemy.util.MessageHandler;

/** A panel that displays actor execution information. The execution
 *  information is driven by calling methods in the _executionMonitorRecording
 *  object. This class is abstract, and subclasses must instantiate
 *  _executionMonitorRecording and set its container to be the workflow
 *  to be monitored.
 *  
 *  @see Recording
 * 
 *  @author Daniel Crawl
 *  @version $Id: ExecutionMonitorPanel.java 34199 2015-11-02 20:02:37Z crawl $
 * 
 */
public abstract class ExecutionMonitorPanel extends ViewWatchingTabPane 
    implements ProvenanceEnabledListener {

    /** Create a new ExecutionMonitorPanel with the specified name. */
    public ExecutionMonitorPanel(String name) {
        super(new GridBagLayout());
        _tabName = name;
    }
    
    /** Initialize the tab. */
    @Override
    public void initializeTab() throws Exception {
        
        super.initializeTab();
        
        _workflow = (CompositeActor) ((PtolemyFrame)_frame).getModel();
        
        _executionTable = new JTable() {
         
            @Override
            public Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
                Component component = super.prepareRenderer(renderer, row, column);
                if(row == _selectedRow) {
                    component.setBackground(Color.BLUE);
                    component.setForeground(Color.WHITE);
                } else {
                    component.setBackground(_actorsList.get(row).status.getColor());
                    component.setForeground(Color.BLACK);
                }
                Font font = component.getFont();
                component.setFont(new Font(font.getName(), font.getStyle(), FONT_SIZE));
                return component;
            }            
        };
               
        _executionTable.setPreferredScrollableViewportSize(new Dimension(500, 500));
        
        _executionTable.addMouseListener(new MouseAdapter() {
            
            @Override
            public void mousePressed(MouseEvent mouseEvent) {
                Point point = mouseEvent.getPoint();
                _selectedRow = _executionTable.rowAtPoint(point);
                
                // see if it's a double click in the error column
                if(mouseEvent.getClickCount() == 2 && 
                    _executionTable.columnAtPoint(point) == Column.Message.ordinal()) {
                    
                    // display the error message in a dialog box if not empty
                    String message = (String) _executionTableModel.getValueAt(_selectedRow, Column.Message.ordinal());
                    if(message != null && !message.trim().isEmpty()) {
                        MessageHandler.error(message);
                    }
                }
            }
            
            @Override
            public void mouseReleased(MouseEvent mouseEvent) {
                Point point = mouseEvent.getPoint();
                _selectedRow = _executionTable.rowAtPoint(point);
            }
        });

        _executionTable.setRowHeight(20);
        
        _executionTableModel = new ExecutionMonitorTableModel();
        _executionTable.setModel(_executionTableModel);
        
        _executionTable.setAutoCreateRowSorter(true);
        
        _initColumnSizes();
                
        _initContextMenu();
        
        JScrollPane scrollPane = new JScrollPane(_executionTable);
        
        scrollPane.setColumnHeader(new JViewport() {
            
            @Override
            public Dimension getPreferredSize() {
                Dimension dimension = super.getPreferredSize();
                dimension.height = 30;
                return dimension;
            }
            
        });

        scrollPane.getViewport().setBackground(Color.WHITE);

        JTableHeader header = _executionTable.getTableHeader();
        Font headerFont = header.getFont();
        header.setFont(new Font(headerFont.getName(), headerFont.getStyle(), FONT_SIZE));

        _replayButton = new JButton("Replay");
        _replayButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                _replay();
            }
        });
        _replayButton.setEnabled(false);

        JButton configureButton = new JButton("Configure");
        configureButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JDialog dialog = 
                        new ExecutionPanelConfigureDialog(ExecutionMonitorPanel.this,
                                _isRunning.get());
                dialog.pack();
                dialog.setVisible(true);
            }
        });
        
        _statusLabel = new JLabel("");
        
        GridBagConstraints c = new GridBagConstraints();
        c.anchor = GridBagConstraints.LINE_START;

        c.weightx = 1;
        c.weighty = 1;        
        c.gridx = 0;
        c.gridy = 0;
        c.gridwidth = 3;
        c.fill = GridBagConstraints.BOTH;
        add(scrollPane, c);

        c.weightx = 0;
        c.weighty = 0;
        c.fill = GridBagConstraints.NONE;

        c.gridy = 1;
        c.gridwidth = 1;
        add(_replayButton, c);
        
        c.gridx = 1;
        add(configureButton, c);
        
        c.gridx = 2;
        c.gridwidth = GridBagConstraints.REMAINDER;
        c.insets = new Insets(0, 10, 0, 0);
        add(_statusLabel, c);

        setBackground(Color.WHITE);   
    }

    /** Clean up resources since panel is being closed. */
    @Override
    public void removeNotify() {
        super.removeNotify();
        _actorsInfo.clear();
        _actorsList.clear();
        _executionMonitorRecording = null;
    }
    
    /** This method is called when provenance is enabled or disabled.
     * @param enabled True if provenance is enabled.
     */
    @Override
    public void toggle(final boolean enabled) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                if(enabled) {
                    _statusLabel.setText("");
                } else {
                    _statusLabel.setText("Turn on provenance to monitor execution.");
                }
            }
        });
    }

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

    /** Get the ActorInfo for the selected row in the table. If no
     *  row is selected, returns null.
     */
    protected ActorInfo _getSelectedRowInfo() {
        if(_selectedRow > 0) {
            return _actorsList.get(_selectedRow);
        }
        return null;
    }
    
    /** Initialize the pop up menu for the execution table. */
    protected void _initContextMenu() {    
        _executionTableContextMenu = new JPopupMenu();
        _executionTable.setComponentPopupMenu(_executionTableContextMenu);        
    }

    /** Replay an execution. */
    abstract protected void _replay();
    
    ///////////////////////////////////////////////////////////////////
    ////                       protected variables                 ////

    /** The workflow object. */
    protected CompositeActor _workflow;
    
    /** The recording class that updates the table. */
    protected ExecutionMonitorRecording _executionMonitorRecording;

    /** Status label at the bottom of the table. */
    protected JLabel _statusLabel;

    /** If true, the current time can be used to calculate the elapsed
     *  execution time of an actor.
     */
    protected boolean _useCurrentTimeForElapsed = true;

    /** Context menu for execution table. */
    protected JPopupMenu _executionTableContextMenu;
    
    ///////////////////////////////////////////////////////////////////
    ////                  package protected methods                ////

    /** Get if executions for an actor should be separate rows. */
    boolean getSeparateActorExecutions() {
        return _separateActorExecutions;
    }
    
    /** Get if executions for composite actors should be shown. */
    boolean getShowCompositeActorExecutions() {
        return _showCompositeActorExecutions;
    }
    
    /** Get the frequency to update the table. */ 
    int getUpdateDelay() {
        return _updateFrequency;
    }
    
    /** Set if executions for an actor should be separate rows. */
    void setSeparateActorExecutions(boolean separate) {
        _separateActorExecutions = separate;
    }

    /** Set if executions for composite actors should be shown. */
    void setShowCompositeActorExecutions(boolean show) {
        _showCompositeActorExecutions = show;
    }
    
    /** Set the frequency to update the table. */ 
    void setUpdateDelay(int delay) {
        _updateFrequency = delay;
    }
    
    ///////////////////////////////////////////////////////////////////
    ////                       private methods                     ////
    
    /** Set column width in the execution table. */
    private void _initColumnSizes() {
        
        _executionTable.getColumnModel()
            .getColumn(Column.Actor.ordinal())
            .setPreferredWidth(400);
        
        _executionTable.getColumnModel()
            .getColumn(Column.ElapsedTime.ordinal())
            .setPreferredWidth(100);

        _executionTable.getColumnModel()
            .getColumn(Column.ExecutionNumber.ordinal())
            .setMaxWidth(55);

        _executionTable.getColumnModel()
            .getColumn(Column.Start.ordinal())
            .setPreferredWidth(150);
        
        _executionTable.getColumnModel()
            .getColumn(Column.End.ordinal())
            .setPreferredWidth(150);

        _executionTable.getColumnModel()
            .getColumn(Column.Message.ordinal())
            .setPreferredWidth(350);
    }
        
    ///////////////////////////////////////////////////////////////////
    ////                       inner classes                       ////

    /** Table model for the execution table. */
    private class ExecutionMonitorTableModel extends AbstractTableModel {
        
        /** Get the class of the value in the column. The class type
         *  is used to correctly sort the column.
         */
        @Override
        public Class<?> getColumnClass(int col) {
            Class<?> clazz = Column.values()[col].getColumnClass();
            if(clazz != null) {
                return clazz;
            }
            return Object.class;
        }
        
        /** Get the number of rows. */
        @Override
        public int getRowCount() {
            return _actorsList.size();
        }

        /** Get the number of columns. */
        @Override
        public int getColumnCount() {
            return Column.values().length;
        }

        /** Get the column header name. */
        @Override
        public String getColumnName(int col) {
            return Column.values()[col].getName();
        }

        /** Get the value at a row and column. */
        @Override
        public Object getValueAt(int rowIndex, int columnIndex) {
            ActorInfo info = _actorsList.get(rowIndex);
            synchronized(info) {
                return info.getColumn(columnIndex);
            }
        }
    }
    
    /** A class to monitor workflow execution by receiving provenance events. */
    protected class ExecutionMonitorRecording extends SimpleFiringRecording<Integer> {

        public ExecutionMonitorRecording() throws RecordingException {
            super();
        }

        /** Record an actor firing. */
        @Override
        public void actorFire(FiringEvent event, Date timestamp) throws RecordingException
        {
            Actor actor = event.getActor();
            
            //System.out.println(event);
                        
            // TODO if show composite actor executions turned on
            // during workflow execution, actor info below is null and
            // leads to NPE.
            if(actor instanceof CompositeActor &&
                    !_showCompositeActorExecutions) {
                return;
            }
            
            FiringEvent.FiringEventType curEventType = event.getType();
            FireState<Integer> fireState = _fireStateTable.get(actor);
            
            if(fireState == null) {
                System.err.println("WARNING: received actor fire event" +
                        " for unregistered actor: " + actor.getFullName());
                return;
                /*
                throw new RecordingException(
                    "Received actor fire event for unregistered actor: " +
                    actor.getFullName());
                */
            }

            String actorName = actor.getName(_recordingWorkflow);
            ActorInfo info = _actorsInfo.get(actorName);
            
            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)) {
                    
                    int firing = fireState.getNumberOfFirings() + 1;
                    fireState.fireStart(curEventType, firing);

                    boolean newActorInfo = false;
                    if(info == null || 
                            (_separateActorExecutions && firing > 0)) {
                        info = new ActorInfo(actorName);
                        info.useCurrentTimeForElapsed = _useCurrentTimeForElapsed;
                        newActorInfo = true;
                    }
                    
                    synchronized(info) {
                        info.firing = firing;
                        info.status = ActorStatus.Running;
                        if(timestamp == null) {
                            info.start = new Date();
                        } else {
                            info.start = timestamp;
                        }
    
                        if(newActorInfo) {
                            _actorsInfo.put(actorName, info);
                            _actorsList.add(info);
                        }
                    }
                    
                    /*
                    SwingUtilities.invokeLater(new Runnable() {
                        @Override
                        public void run() {
                            _executionTableModel.fireTableDataChanged();
                        }
                    });
                    */
                }
                // see if current firing is end of iteration:
                else if(curEventType == FiringEvent.AFTER_ITERATE ||
                    (curEventType == FiringEvent.AFTER_POSTFIRE &&
                    lastStartType == FiringEvent.BEFORE_PREFIRE)) {
                    // 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);
                    }
                    
                    synchronized(info) {
                        info.status = ActorStatus.Done;
                        if(timestamp == null) {
                            info.end = new Date();
                        } else {
                            info.end = timestamp;
                        }
                    }
                    
                    /*
                    SwingUtilities.invokeLater(new Runnable() {
                        @Override
                        public void run() {
                            _executionTableModel.fireTableDataChanged();
                        }
                    });
                    */
                }
            }
        }

        /** The workflow had an error.
        *
        * @param source The source of the error. This may be null.
        * @param throwable The error.
        */
        @Override
        public void executionError(Nameable source, Throwable throwable)
            throws RecordingException
        {
            _isFinished.set(true);
            
            if(source instanceof Actor) {
                ActorInfo info;
                if(source == _recordingWorkflow) {
                    info = _actorsInfo.get("Workflow");
                    if(info == null) {
                        info = new ActorInfo("Workflow");
                        info.useCurrentTimeForElapsed = _useCurrentTimeForElapsed;
                        info.status = ActorStatus.Running;
                        info.start = new Date();
                        info.firing = 1;
                        
                        _actorsInfo.put("Workflow", info);
                        _actorsList.add(info);
                    }
                } else {
                    String actorName = ((Actor)source).getName(_recordingWorkflow);
                    info = _actorsInfo.get(actorName);
                    if(info == null) {
                        info = new ActorInfo(actorName);
                        info.useCurrentTimeForElapsed = _useCurrentTimeForElapsed;
                        _actorsInfo.put(actorName, info);
                        _actorsList.add(info);
                    }
                }
                
                synchronized(info) {
                    info.status = ActorStatus.Error;
                    info.message = throwable.getMessage();
                }
                
                SwingUtilities.invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        _executionTableModel.fireTableDataChanged();
                    }
                });
            }
        }

        /** Record the starting of workflow execution. */
        @Override
        public void executionStart(KeplerLSID executionLSID, Date timestamp) throws RecordingException
        {           
            _isFinished.set(false);

            // create a row in the execution table for the workflow
            ActorInfo info = new ActorInfo("Workflow");
            info.useCurrentTimeForElapsed = _useCurrentTimeForElapsed;
            info.status = ActorStatus.Running;
            if(timestamp == null) {
                info.start = new Date();
            } else {
                info.start = timestamp;
            }
            info.firing = 1;
            
            _actorsInfo.put("Workflow", info);
            _actorsList.add(info);
            
            _isRunning.set(true);
            
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    _statusLabel.setText("Running.");
                    _executionTableModel.fireTableDataChanged();
                }
            });
            
            // create a thread to periodically update the execution table
            _updateThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while(!_isFinished.get()) {
                        synchronized(_updateLock) {
                            try {
                                _updateLock.wait(_updateFrequency);
                            } catch (InterruptedException e) {
                                MessageHandler.error("Interrupted while waiting for update lock.", e);;
                            }
                            SwingUtilities.invokeLater(new Runnable() {
                                @Override
                                public void run() {
                                    _executionTableModel.fireTableDataChanged();
                                }
                            });
                        }
                    }
                }
            });
            _updateThread.start();
        }

        /** Record the stopping of workflow execution. */
        @Override
        public void executionStop(KeplerLSID executionLSID, Date timestamp) throws RecordingException
        {
            _isFinished.set(true);

            // stop all the actors.
            synchronized(_actorsInfo) {
                for(ActorInfo info : _actorsInfo.values()) {
                    synchronized(info) {
                        if(info.status == ActorStatus.Running ||
                                info.status == ActorStatus.Waiting) {
                            info.status = ActorStatus.Done;
                            if(info.status != ActorStatus.Waiting) {
                                if(timestamp == null) {
                                    info.end = new Date();
                                } else {
                                    info.end = timestamp;
                                }
                            }
                        }
                    }
                }
            }
                        
            // wake up the updater thread and wait until it finishes.
            synchronized(_updateLock) {
                _updateLock.notify();
            }
            
            try {
                _updateThread.join();
            } catch (InterruptedException e) {
                MessageHandler.error("Error joining update thread.", e);
            }
            
            _isRunning.set(false);

            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    _statusLabel.setText("Done.");
                    _executionTableModel.fireTableDataChanged();
                }
            });
            
            _blockingPorts.clear();
            
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    _replayButton.setEnabled(true);
                }
            });
            
        }
        
        /** Record a port event. */
        @Override
        public void portEvent(IOPortEvent event, Date timestamp) throws RecordingException
        {
            String actorName = _blockingPorts.get(event.getPort());
            ActorInfo info;
            
            // if actor name is not null, then reading the port blocks
            // actor execution.
            if(actorName != null) {
                info = _actorsInfo.get(actorName);
                
                // info is null if we are not showing composite
                // actor executions and the port is contained by
                // a composite actor.
                if(info != null) {

                    switch(event.getEventType()) {
                    case IOPortEvent.GET_BEGIN:
                        synchronized(info) {
                            info.status = ActorStatus.Waiting;
                        }
                        //System.out.println("waiting " + info._name);
                        //System.out.flush();
                        /*
                        SwingUtilities.invokeLater(new Runnable() {
                            @Override
                            public void run() {
                                _executionTableModel.fireTableDataChanged();
                            }
                        });
                        */
                        break;
                    case IOPortEvent.GET_END:
                        synchronized(info) {
                            info.status = ActorStatus.Running;
                        }
                        //System.out.println("running " + info._name);
                        //System.out.flush();
                        /*
                        SwingUtilities.invokeLater(new Runnable() {
                            @Override
                            public void run() {
                                _executionTableModel.fireTableDataChanged();
                            }
                        });
                        */
                        break;
                    default:
                        // do nothing
                        break;
                    }
                }
            }
        }
                                        
        /** Register a port. */
        @Override 
        public boolean regPort(TypedIOPort port) {
            
            // add the port to the set of blocking ports if the port
            // is an input port and the executive director is PN.
            // we check the executive director since if the actor is
            // a composite actor, we want the outside director.
            if(port.isInput() &&
                    (port.getContainer() instanceof Actor) &&
                    ((Actor)port.getContainer()).getExecutiveDirector() instanceof PNDirector) {                
                _blockingPorts.put(port, ((Actor)port.getContainer()).getName(_recordingWorkflow));
                //System.out.println("blocking ports added " + port.getFullName());
            }
            return false;
        }
        
        /** Clear data structures before starting. */
        @Override
        public void specificationStart() throws RecordingException {
            super.specificationStart();
            _actorsInfo.clear();
            _actorsList.clear();
            _blockingPorts.clear();
            _recordingWorkflow = _recorderContainer.toplevel();
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    _replayButton.setEnabled(false);
                }
            });
        }
        
        /** True when the workflow finishes. */
        private final AtomicBoolean _isFinished = new AtomicBoolean(false);
                        
        /** A map of ports to actor names for input ports that block. */
        private final Map<IOPort, String> _blockingPorts =
                Collections.synchronizedMap(new HashMap<IOPort, String>());
        
        /** A thread that periodically updates the execution table. */
        private Thread _updateThread;
        
        /** A lock for the update thread. */
        private final Object _updateLock = new Object();
        
        /** The workflow. */
        private NamedObj _recordingWorkflow;
    }
    
    /** A utility class to hold information about a single
     *  execution of an actor.
     */
    protected static class ActorInfo {
        
        /** Create a new ActorInfo with an actor's name. */
        public ActorInfo(String name) {
            this.name = name;
        }
        
        /** Get the object for a column in the execution table. */
        public Object getColumn(int index) {
            switch(Column.values()[index]) {
            case Actor:
                //System.out.println("name = " + _name);
                //System.out.flush();
                return name;
            case ElapsedTime:
                if(status == ActorStatus.Done || status == ActorStatus.Error) {
                    if(end == null || start == null) {
                        return "-";
                    }
                    return String.format("%.2f",
                        Double.valueOf(end.getTime() - start.getTime()) / _MILLI_SEC_IN_SEC);
                } else if(start != null && useCurrentTimeForElapsed) {
                    return String.format("%.2f",
                        Double.valueOf(new Date().getTime() - start.getTime()) / _MILLI_SEC_IN_SEC);
                } else {
                    return "-";
                }
            case End:
                if(end == null) {
                    return "-";
                }
                return _dateFormat.format(end);
            case ExecutionNumber:
                return firing;
            case Message:
                return message;
            /*
            case Status:
                //System.out.println("status = " + status);
                //System.out.flush();
                return status;
            */
            case Start:
                if(start == null) {
                    return "-";
                }
                return _dateFormat.format(start);
            default:
                System.out.println("WARNING: ActorInfo.getColumn for unknown index: " + index);
                return null;
            }
        }
        
        @Override
        public String toString() {
            return name + " " + status.name();
        }
        
        /** The time that execution started. */
        //public long startTime = -1;
        
        /** The time that execution stopped. */
        //public long endTime = -1;
        
        /** The timestamp that execution started. */
        public Date start;

        /** The timestamp that execution end. */
        public Date end;
        
        /** The current firing number of the actor. */
        public int firing = -1;
        
        /** The execution status. */
        public ActorStatus status = ActorStatus.NotRun;
        
        /** An optional execution message */
        public String message = "";
        
        /** If true, the current time can be used to calculate the elapsed
         *  execution time of an actor.
         */
        public boolean useCurrentTimeForElapsed;
        
        /** The fully-qualified name of the actor (with no leading period.) */
        public String name;
    }
    
    /** The columns in the execution table. */
    private enum Column { 
        Actor("Actor"),
        ElapsedTime("Elapsed", Integer.class),
        ExecutionNumber("Num", Integer.class),
        Start("Start"),
        End("End"),
        //Status("Status"),
        Message("Message");
    
        Column(String name) {
            _name = name;
            _class = String.class;
        }
        
        Column(String name, Class<?> clazz) {
            _name = name;
            _class = clazz;
        }
        
        /** Get the class of the value in the column. */
        public Class<?> getColumnClass() {
            return _class;
        }
        
        /** Get the name of the column */
        public String getName() {
            return _name;
        }
        
        /** The column name. */
        private String _name;
        
        /** The column class type. */
        private Class<?> _class;
        
    };
    
    /** The actor execution status. */
    private enum ActorStatus { 
        Done,
        Error,
        Running,
        NotRun,
        Waiting;
    
        /** Get the color for the status. */
        public Color getColor() {
            switch(this) {
            case Done:
                return Color.LIGHT_GRAY;
            case Error:
                return Color.RED;
            case NotRun:
                return Color.WHITE;
            case Running:
                return Color.GREEN;
            case Waiting:
                return Color.YELLOW;
            default:
                return Color.WHITE;
            }
        }
    
    };
    
    ///////////////////////////////////////////////////////////////////
    ////                       private variables                   ////
    
    /** If true, provenance is turned on. */
    //private boolean _provenanceEnabled;
    
    /** The execution table. */
    private JTable _executionTable;
        
    /** The execution table model. */
    private AbstractTableModel _executionTableModel;
        
    private final Map<String,ActorInfo> _actorsInfo = 
            Collections.synchronizedMap(new HashMap<String,ActorInfo>());
    
    private final List<ActorInfo> _actorsList =
            Collections.synchronizedList(new ArrayList<ActorInfo>());
    
    /** If true, a new row is created for each actor firing in the execution table. */
    private boolean _separateActorExecutions = true;

    /** If true, a new row is created in the execution table for
     *  each composite actor firing.
     */
    private boolean _showCompositeActorExecutions = false;

    /** Index of selected row in the execution table. */
    private int _selectedRow = -1;
    
    /** How often (in milliseconds) to update the execution table. */
    private int _updateFrequency = 5000;
    
    /** Timestamp format for execution table. */
    private final static DateFormat _dateFormat = new SimpleDateFormat("hh:mm:ss.S");
    
    /** Execution table font size for cell and column header. */
    public final static int FONT_SIZE = 14;
        
    /** Number of milliseconds in one second. */
    private final static double _MILLI_SEC_IN_SEC = 1000.0;
    
    /** Button for replay. */
    private JButton _replayButton;    
    
    /** True when the workflow is executing. */
    private AtomicBoolean _isRunning = new AtomicBoolean(false);
    
}