/*
 * Copyright (c) 2009-2010 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2015-08-19 23:46:56 +0000 (Wed, 19 Aug 2015) $' 
 * '$Revision: 33599 $'
 * 
 * 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.gui.frame;

import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.kepler.gui.state.StateChangeEvent;
import org.kepler.gui.state.StateChangeListener;
import org.kepler.gui.state.StateChangeMonitor;

import ptolemy.actor.CompositeActor;
import ptolemy.actor.gui.PtolemyEffigy;
import ptolemy.actor.lib.hoc.MultiCompositeActor;
import ptolemy.actor.lib.hoc.Refinement;
import ptolemy.gui.ComponentDialog;
import ptolemy.gui.Query;
import ptolemy.kernel.CompositeEntity;
import ptolemy.kernel.Port;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.kernel.util.NameDuplicationException;
import ptolemy.kernel.util.Nameable;
import ptolemy.kernel.util.NamedObj;
import ptolemy.kernel.util.Workspace;
import ptolemy.moml.LibraryAttribute;
import ptolemy.moml.MoMLChangeRequest;
import ptolemy.util.MessageHandler;
import ptolemy.util.StringUtilities;
import ptolemy.vergil.toolbox.FigureAction;

//////////////////////////////////////////////////////////////////////////
//// MultiCompositeTableau

/** An editor tableau for MultiCompositeActors.
 * 
 @author Daniel Crawl, Possibly based on CaseGraphTableau by Edward A. Lee.
 @version $Id: MultiCompositeTableau.java 33599 2015-08-19 23:46:56Z crawl $
 */
public abstract class MultiCompositeTableau extends TabbedKeplerGraphTableau implements StateChangeListener {
    /** Create a new multicomposite editor tableau with the specified
     *  container and name.
     *  @param container The container.
     *  @param name The name.
     *  @exception IllegalActionException If the model associated with
     *   the container effigy is not an instance of CompositeEntity.
     *  @exception NameDuplicationException If the container already
     *   contains an object with the specified name.
     */
    public MultiCompositeTableau(PtolemyEffigy container, String name)
            throws IllegalActionException, NameDuplicationException {
        this(container, name, null);
    }

    /** Create a new multicomposite editor tableau with the specified
     *  container, name, and default library.
     *  @param container The container.
     *  @param name The name.
     *  @param defaultLibrary The default library, or null to not specify one.
     *  @exception IllegalActionException If the model associated with
     *   the container effigy is not an instance of CompositeEntity.
     *  @exception NameDuplicationException If the container already
     *   contains an object with the specified name.
     */
    public MultiCompositeTableau(PtolemyEffigy container, String name,
            LibraryAttribute defaultLibrary) throws IllegalActionException,
            NameDuplicationException {
        super(container, name);
    }

    ///////////////////////////////////////////////////////////////////
    ////                         public methods                    ////

    /** Clone the object into the specified workspace. */
    @Override
    public Object clone(Workspace workspace) throws CloneNotSupportedException {
        MultiCompositeTableau newObject = (MultiCompositeTableau) super.clone(workspace);
        newObject._multiCompositeActor = null;
        return newObject;
    }
    
    @Override
    public void createGraphFrame(CompositeEntity model,
           LibraryAttribute defaultLibrary)
    {
       TabbedKeplerGraphFrame frame = null;

       frame = _addCompositeToExistingFrame(model, defaultLibrary);
       _createdNewFrame = false;
               
       _configureFrame(frame, model);
       
    }

    /** React to changes in the selected tab in a TabbedKeplerGraphFrame. */
    @Override
    public void handleStateChange(StateChangeEvent event) {
        
        if(event instanceof TabbedKeplerGraphFrameEvent) {
            
            TabbedKeplerGraphFrameEvent frameEvent = (TabbedKeplerGraphFrameEvent)event;
            
            // see if the event is from the frame that this tableau created
            // and the event is for a tab change.
            if(frameEvent.getFrame() == _frame &&
                    frameEvent.getChangedState().equals(TabbedKeplerGraphFrameEvent.CHANGE_TAB)) {
                
                NamedObj model = frameEvent.getReference();
                
                boolean multiCompositeIsNowSelected = 
                        (model == _multiCompositeActor ||
                        model.getContainer() == _multiCompositeActor);
                
                // see if the tab containing our MultiCompositeActor is now selected
                if(!_multiCompositeIsSelected && multiCompositeIsNowSelected) {
                    _multiCompositeSelected(true);
                }
                // see if the tab containing our MultiCompositeActor was selected
                // and now is not selected.
                else if(_multiCompositeIsSelected && !multiCompositeIsNowSelected) {
                    _multiCompositeSelected(false);
                }
            }
        }
    }
    
    /** Set the container for this tableau. If the tab for the MultiCompositeActor
     *  is closed, the container will be null. In this case, stop listening for
     *  tab changes, and the tab for the MultiCompositeActor is no longer selected.
     */
    @Override
    public void setContainer(CompositeEntity container) throws IllegalActionException, NameDuplicationException {
        
        // see if the graph was closed.
        if(container == null) {
            
            // stop listening for when the graph's tab is selected
            StateChangeMonitor.getInstance().
                removeStateChangeListener(TabbedKeplerGraphFrameEvent.CHANGE_TAB, this);
            
            // see if the graph is currently selected
            if(_multiCompositeIsSelected) {
                _multiCompositeSelected(false);
            }
        }
        
        super.setContainer(container);
    }

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


    /** Configure the frame for the opened multi composite model. */
    @Override
    protected void _configureFrame(TabbedKeplerGraphFrame frame, CompositeEntity model) {

        super._configureFrame(frame, model);
        
        _multiCompositeActor = model;
        _frame = frame;
        
        // listen for state change events so we know then the tab is changed.
        StateChangeMonitor.getInstance().
            addStateChangeListener(TabbedKeplerGraphFrameEvent.CHANGE_TAB, this);
        
        // the tab has just been created and is selected for the multi composite
        _multiCompositeSelected(true);
    }

    
    /** This method is called whenever the tab containing the MultiCompositeActor
     *  is selected or unselected in the frame.
     */
    protected void _multiCompositeSelected(boolean isSelected) {
        _multiCompositeIsSelected = isSelected;
    }

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

    /** The frame displaying the MultiCompositeActor. */
    protected TabbedKeplerGraphFrame _frame;

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

    /** The MultiCompositeActor associated with this tableau. */
    private CompositeEntity _multiCompositeActor;

    /** If true, the tab displaying the MultiCompositeActor is selected. */
    private boolean _multiCompositeIsSelected;
      
    ///////////////////////////////////////////////////////////////////
    ////                         inner classes                     ////

    /** Class implementing the Add Refinement menu command. */
    public abstract class AddRefinementAction extends FigureAction {

        /** Create an action. 
         * @param title the window title
         * @param refinementTypeName the type of sub-workflow to add
         * @param nameQuery the string displayed in the dialog
         */
        public AddRefinementAction(String title, String refinementTypeName,
                String nameQuery) {
            super(title);
            _title = title;
            _refinementTypeName = refinementTypeName;
            _nameQuery = nameQuery;
            putValue(MNEMONIC_KEY, Integer.valueOf(KeyEvent.VK_A));
        }

        ///////////////////////////////////////////////////////////////////////////////
        ////                            public methods                             ////

        /** Perform the action. */
        @Override
        public void actionPerformed(ActionEvent e) {
            super.actionPerformed(e);
            // Dialog to ask for a refinement name.
            Query query = new Query();
            query.addLine(_refinementTypeName, _nameQuery, "");
            ComponentDialog dialog = new ComponentDialog(_frame,
                    _title, query);
            if (dialog.buttonPressed().equals("OK")) {
                final String pattern = query.getStringValue(_refinementTypeName);
                // NOTE: We do not use a TransitionRefinement because we don't
                // want the sibling input ports that come with output ports.
                
                // FIXME: refinementClassName() should be a method of MultiCompositeActor
                //String refinementClassName = _case.refinementClassName();
                String refinementClassName = "ptolemy.actor.lib.hoc.Refinement";
                
                String moml = "<entity name=\""
                        + StringUtilities.escapeForXML(pattern) + "\" class=\""
                        + refinementClassName + "\"/>";

                // The following is, regrettably, copied from ModalTransitionController.
                MoMLChangeRequest change = new MoMLChangeRequest(this, _multiCompositeActor,
                        moml) {
                    @Override
                    protected void _execute() throws Exception {
                        super._execute();

                        
                        // Mirror the ports of the container in the refinement.
                        // Note that this is done here rather than as part of
                        // the MoML because we have set protected variables
                        // in the refinement to prevent it from trying to again
                        // mirror the changes in the container.
                        Refinement entity = (Refinement) _multiCompositeActor
                                .getEntity(pattern);

                        // Get the initial port configuration from the container.
                        Iterator<?> ports = ((CompositeActor)entity.getContainer()).portList().iterator();
                        Set<Port> portsToMirror = new HashSet<Port>();
                        while (ports.hasNext()) {
                            Port port = (Port) ports.next();
                            
                            // see if we should mirror the port
                            if(mirrorPort(port)) {
                                portsToMirror.add(port);
                            }
                        }
                        
                        MultiCompositeActor.mirrorContainerPortsInRefinement(entity, portsToMirror);

                        //JGraph jgraph = _addTabbedPane(entity, true);
                        _frame.addSubComposite(entity);
                        //((TabbedKeplerController) _controller)._addHotKeys(jgraph);
                    }
                };

                _multiCompositeActor.requestChange(change);
            }
        }
        
        /** Returns true if port should be mirrored. */
        public abstract boolean mirrorPort(Port port);
        
        ///////////////////////////////////////////////////////////////////
        ////                         private variables                 ////
        
        /** The type of the sub-workflow. */
        private String _refinementTypeName;
        
        /** The string displayed in the dialog. */
        private String _nameQuery;

        /** The title of the window. */
        private String _title;
    }

    /** Class implementing the Remove Refinement menu command. */
    public class RemoveRefinementAction extends FigureAction {

        /** Create a tabbed composite action with a label. */
        public RemoveRefinementAction(String refinementTypeName,
                String refinementTypePluralName) {
            super("Remove " + refinementTypeName);
            _refinementTypeName = refinementTypeName;
            _refinementTypePluralName = refinementTypePluralName;
            putValue(MNEMONIC_KEY, Integer.valueOf(KeyEvent.VK_R));
        }
        
        ///////////////////////////////////////////////////////////////////////////////
        ////                            public methods                             ////

        /** Perform the action. */
        @Override
        public void actionPerformed(ActionEvent e) {
            super.actionPerformed(e);
            // Dialog to ask for a refinement name.
            Query query = new Query();
            List<?> refinements = _multiCompositeActor.entityList(Refinement.class);
            if (refinements.size() < 2) {
                MessageHandler.error("No " + _refinementTypePluralName + " to remove.");
            } else {
                String[] refinementNames = new String[refinements.size() - 1];
                Iterator<?> refinementIterator = refinements.iterator();
                int i = 0;
                while (refinementIterator.hasNext()) {
                    String name = ((Nameable) refinementIterator.next()).getName();
                    if (!name.equals("default")) {
                        refinementNames[i] = name;
                        i++;
                    }
                }
                String title = "Remove " + _refinementTypeName;
                query.addChoice(_refinementTypeName, title, refinementNames,
                        refinementNames[0]);
                ComponentDialog dialog = new ComponentDialog(
                        _frame, title, query);
                if (dialog.buttonPressed().equals("OK")) {
                    final String name = query.getStringValue(_refinementTypeName);
                    String moml = "<deleteEntity name=\""
                            + StringUtilities.escapeForXML(name) + "\"/>";

                    // The following is, regrettably, copied from ModalTransitionController.
                    MoMLChangeRequest change = new MoMLChangeRequest(this,
                            _multiCompositeActor, moml) {
                        @Override
                        protected void _execute() throws Exception {
                            super._execute();
                            _frame.updateTabsForComposite(_multiCompositeActor);
                            /*
                            // Find the tabbed pane that matches the name and remove it.
                            int count = _multiRefinementTabbedPane.getTabCount();
                            for (int i = 0; i < count; i++) {
                                if (name.equals(_multiRefinementTabbedPane.getTitleAt(i))) {
                                    _multiRefinementTabbedPane.remove(i);
                                    break;
                                }
                            }
                            */
                        }
                    };
                    _multiCompositeActor.requestChange(change);
                }
            }
        }

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

        /** The type of sub-workflow. */
        private String _refinementTypeName;
        
        /** The plural of the type of sub-workflow. */
        private String _refinementTypePluralName;

    }
    
}