/* ActionController.java
 *
 * created: Tue Sep 17 2002
 *
 * This file is part of Artemis
 *
 * Copyright (C) 2002  Genome Research Limited
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * $Header: //tmp/pathsoft/artemis/uk/ac/sanger/artemis/ActionController.java,v 1.6 2008-01-30 09:15:31 tjc Exp $
 */

package uk.ac.sanger.artemis;

import java.util.List;
import java.util.Vector;

import javax.swing.JMenuItem;

import uk.ac.sanger.artemis.sequence.SequenceChangeEvent;
import uk.ac.sanger.artemis.sequence.SequenceChangeListener;
import uk.ac.sanger.artemis.util.OutOfRangeException;
import uk.ac.sanger.artemis.util.ReadOnlyException;

import uk.ac.sanger.artemis.io.OutOfDateException;
import uk.ac.sanger.artemis.io.EntryInformationException;


/**
 *  This class is maintains a Vector of Action objects to allow Undo.
 *
 *  @author Kim Rutherford <kmr@sanger.ac.uk>
 *  @version $Id: ActionController.java,v 1.6 2008-01-30 09:15:31 tjc Exp $
 **/

public class ActionController
    implements EntryGroupChangeListener, EntryChangeListener,
               FeatureChangeListener, SequenceChangeListener 
{
  /**
   *  The current Action.  If null we aren't currently in an Action, if
   *  non-null we are in an Action.
   **/
  private Action current_action = null;

  /* Storage for Actions. **/
  private ActionVector undo_action_vector = new ActionVector ();
  private ActionVector redo_action_vector = new ActionVector ();

  private List<JMenuItem> undo;
  private List<JMenuItem> redo;
  
  /**
   *  Note the start of an action.  Create a new Action and add all
   *  ChangeEvents to it until the next call to endAction().
   **/
  public void startAction () 
  {
    if (Options.getOptions ().getUndoLevels () == 0) 
      return;  // undo disabled

    if (current_action == null) 
      current_action = new Action ();
    else 
    {
      current_action = null;
      throw new Error ("internal error - ActionController.startAction() " +
                       "called twice");
    }
  }

  /**
   *  Finish an Action and make a note of the completed Action.
   **/
  public void endAction () 
  {
    if (Options.getOptions ().getUndoLevels () == 0) 
      return;  // undo disabled

    if (current_action == null) {
//
// believed to cause problems with FeatureList update if thrown...
//
//    throw new Error ("internal error - in ActionController.endAction() " +
//                     "no Action in progress");
    }
    else 
    {
      if (!current_action.isEmpty ())
        undo_action_vector.add (current_action);
      current_action = null;
    }
    setEnabledMenuItems();
  }

  /**
   *  Discard all undo information.
   **/
  private void discardUndoRedo () 
  {
    undo_action_vector = new ActionVector();
    redo_action_vector = new ActionVector();
    setEnabledMenuItems();
  }

  /**
   *  Return true if and only if we can can undo() successfully at least once.
   **/
  public boolean canUndo () 
  {
    if (undo_action_vector.size () == 0) 
      return false;
    else 
      return true;
  }
  
  /**
   *  Undo the last Action then return true.  If there was no last Action
   *  return false.
   **/
  public boolean undo () 
  {
    Action action = doLastAction(undo_action_vector, true);
    if(action == null)
      return false;
    
    redo_action_vector.add(action);
    setEnabledMenuItems();
    return true;
  }

  /**
   *  Redo the last Action then return true.  If there was no last Action
   *  return false.
   **/
  public boolean redo () 
  {
    Action action = doLastAction(redo_action_vector, false);
    if(action == null)
      return false;
    
    undo_action_vector.add(action);
    setEnabledMenuItems();
    return true;
  }
  
  /**
   * Enable undo/redo menu if they contain Action's
   */
  private void setEnabledMenuItems()
  {
    if(undo != null)
    {
      for(int i=0; i<undo.size(); i++)
      {
        JMenuItem undo_item = (JMenuItem) undo.get(i);
        if(undo_action_vector.size()>0)
          undo_item.setEnabled(true);
        else
          undo_item.setEnabled(false);
      }
    }
    
    if(redo != null)
    {
      for(int i=0; i<redo.size(); i++)
      {
        JMenuItem redo_item = (JMenuItem) redo.get(i);
        if(redo_action_vector.size()>0)
          redo_item.setEnabled(true);
        else
          redo_item.setEnabled(false); 
      }
    }
  }
 
  /**
   * Undo / redo the last Action then return true.  If there was no last Action
   * return false.
   * @param action_vector   carry out last action from list 
   * @param isUndo          if true this is an undo action, otherwise this is
   *                        a redo action
   * @return
   */
  private Action doLastAction(final ActionVector action_vector,
                              final boolean isUndo) 
  {
    if (action_vector.size () == 0) 
      return null;
   
    final Action temp_current_action = current_action;

    // discard the in-progress Action (if any) and throw an exception below
    current_action = null;

    try 
    {
      final Action last_action = action_vector.removeAndReturnLast ();
      if(last_action.isEmpty()) 
        return null;

      final ChangeEventVector last_action_change_events =
        last_action.getChangeEvents ();

      for(int i = last_action_change_events.size() - 1 ; i >= 0 ; --i) 
      {
        final int index;
        if(isUndo)
          index = i;
        else
          index = last_action_change_events.size() - 1 - i;
        
        final ChangeEvent this_event =
            last_action_change_events.elementAt (index);

        if (this_event instanceof FeatureChangeEvent) 
          doFeatureChange ((FeatureChangeEvent) this_event, isUndo);
        else if (this_event instanceof EntryChangeEvent)
          doEntryChange ((EntryChangeEvent) this_event, isUndo);
        else 
          throw new Error ("internal error - unknown event type: " +
                           this_event);
      }

      if (temp_current_action != null) {
        // throw exception after undo so that undo still works.
        throw new Error ("internal error - in ActionController.undo() " +
                         "Action in progress");
      }

      return last_action;
    } 
    catch (ArrayIndexOutOfBoundsException e) 
    {
      throw new Error ("internal error - unexpected exception: " + e);
    }
  }
  
  /**
   *  Undo the effect of one FeatureChangeEvent.
   **/
  private void doFeatureChange (final FeatureChangeEvent event, final boolean isUndo) 
  {
    final Feature feature = event.getFeature ();

    try {
      if (feature.getEntry () != null) 
      {
        if(isUndo)
          feature.set (null,
                       event.getOldKey (),
                       event.getOldLocation (),
                       event.getOldQualifiers ());
        else
          feature.set (null,
              event.getNewKey (),
              event.getNewLocation (),
              event.getNewQualifiers ());
      }
    } catch (OutOfRangeException e) {
      throw new Error ("internal error - unexpected exception: " + e);
    } catch (OutOfDateException e) {
      throw new Error ("internal error - unexpected exception: " + e);
    } catch (ReadOnlyException e) {
      throw new Error ("internal error - unexpected exception: " + e);
    } catch (EntryInformationException e) {
      throw new Error ("internal error - unexpected exception: " + e);
    }
  }

  /**
   *  Undo the effect of one EntryChangeEvent.
   **/
  private void doEntryChange (final EntryChangeEvent event, final boolean isUndo) {
    try 
    {
      if(isUndo)
      {
        if(event.getType () == EntryChangeEvent.FEATURE_DELETED)
          event.getEntry ().add (event.getFeature (), true);
        else if (event.getType () == EntryChangeEvent.FEATURE_ADDED) 
          event.getFeature ().removeFromEntry ();
      }
      else
      {
        if(event.getType () == EntryChangeEvent.FEATURE_DELETED)
          event.getFeature ().removeFromEntry ();
        else if (event.getType () == EntryChangeEvent.FEATURE_ADDED) 
          event.getEntry ().add (event.getFeature (), true);
      }
    } catch (ReadOnlyException e) {
      throw new Error ("internal error - unexpected exception: " + e);
    } catch (EntryInformationException e) {
      throw new Error ("internal error - unexpected exception: " + e);
    } catch (OutOfRangeException e) {
      throw new Error ("internal error - unexpected exception: " + e);
    }
  }

  /**
   *  Implementation of the EntryGroupChangeListener interface.  We listen to
   *  EntryGroupChange events so that we can update the display if entries
   *  are added or deleted.
   **/
  public void entryGroupChanged (final EntryGroupChangeEvent event) 
  {
    switch (event.getType ()) 
    {
      case EntryGroupChangeEvent.ENTRY_DELETED:
        discardUndoRedo ();
      break;
    }
  }
    
  /**
   *  Implementation of the EntryChangeListener interface.  We listen for
   *  FEATURE_ADDED and FEATURE_DELETED events so that we can undo them
   **/
  public void entryChanged (final EntryChangeEvent event) 
  {
    if (current_action != null)
      current_action.addChangeEvent (event);
  }

  /**
   *  Implementation of the FeatureChangeListener interface.  We need to
   *  listen to feature change events from the Features in this object.
   *  @param event The change event.
   **/
  public void featureChanged (FeatureChangeEvent event) 
  {
    if (current_action != null)
      current_action.addChangeEvent (event);
  }

  /**
   *  If the sequence changes all bets are off - discard all Actions.
   **/
  public void sequenceChanged (final SequenceChangeEvent event) 
  {
    discardUndoRedo ();
  }

  public void addUndoMenu(final JMenuItem undo_item)
  {
    if(undo == null)
      undo = new Vector<JMenuItem>();
    undo.add(undo_item);
    setEnabledMenuItems();
  }
  
  public void addRedoMenu(final JMenuItem redo_item)
  {
    if(redo == null)
      redo = new Vector<JMenuItem>();
    redo.add(redo_item);
    setEnabledMenuItems();
  }  
}