package statemachine.hsm;

import java.util.EventObject;

/**
 * This class represents event for Hierarchical State Machine (HSM)
 * @author Alexei Krasnopolski (krasnop@bellsouth.net)
 */
public class Event extends EventObject
{
  private final int id;

  public Event( Object o, int id )
  {
    super( o );
    this.id = id;
  }

  public int getID()
  {
    return id;
  }

}

  
  package statemachine.hsm;

/**
 * This class represents a graph of state behavioral inheritance
 * 
 * @author Alexei Krasnopolski (krasnop@bellsouth.net)
 */

class Path
{
  /**
   * reference to the root node of HSM state tree. It is common for all states of HSM
   */
  Hsm root;
  /**
   * Reference to the parent node for this node in tree hierarchy
   */
  State parent;
  /**
   * Reference to the daughter node for this node in tree hierarchy. This helper field trails
   * moving from leaf nodes to root. This allows make moving back on the same way.
   */
  State daughter;
  /**
   * Holds the index of a node's level in a tree of graph. Highest level equals 0 ( root node of
   * state machine )
   */
  int level;
  /**
   * Constructor creates instance of path for given instance of State (Path class is superclass of
   * State). It takes one parameter. The parameter is a reference to the parent node of the current
   * state in the state tree.
   */
  protected Path( State parent )
  {
    this.parent = parent;
    daughter = null;
    level = parent.level + 1;
    root = parent.root;
  }
  /**
   * Constructor without parameter uses for creates instance of root node.
   */
  protected Path()
  {
    parent = null;
    daughter = null;
    level = 0;
    root = (Hsm)this;
  }
  /**
   * Get-method returns reference to the parent node of the instance.
   */
  protected State getParent()
  {
    return parent;
  }
  /**
   * Method return parent node of state with <code>lvl</code> level from current path. Moving from
   * this node to <code>lvl</code>-level node is recording by setting <code>daughter</code>
   * fields for each processed node. If level of this node lows then <code>lvl</code> method
   * returns reference to the current instance.
   * 
   * @param lvl
   *          is level of node in the current path (branch) of SM tree
   * @return parent state of node lvl level
   */
  State pullDownToLevel( int lvl )
  {
    State tmp = (State)this;           // starting position of tmp is this state
    State prnt;
    while( tmp.level > lvl )          // if leval of tmp > lvl (the end poin of moving)
    {                                  // let's move
      if( (prnt = tmp.getParent()) == null)  // does tmp is root?
        return null;
      prnt.daughter = tmp;          // mark a way we are going: daughter will help us when we go opposit direction
      tmp = prnt;                    // next step
    }
    return tmp;
  }
  /**
   * Get-method returns reference to the root noode of the path which is common node for all
   * branches of state node tree of the HSM.
   */
  Hsm getRoot()
  {
    return root;
  };
  /**
   * Get-method returns reference to the level of the instance.
   */
  int getLevel()
  {
    return level;
  };
}

  
  package statemachine.hsm;

/**
 * This class represents a state of state machine
 * 
 * @author Alexei Krasnopolski (krasnop@bellsouth.net)
 */
abstract public class State extends Path
{
  /**
   * Constructor creates instance of State and invokes a constructor of superclass
   */
  public State( State parent )
  {
    super( parent );
  }

  /**
   * Constructor creates instance of root state (represents Hierarchical State Machine - HSM)
   */
  public State()
  {}

  /**
   * The method moves HSM from current state to destination state. The given instance is a state
   * stimulated this transition.
   */
  protected void transition( State destination )
  {
    int sourceLevel = this.getLevel(); // level of source node of the transition
// Moving along path of tree from current state to root of the tree.
// Note <code>this</code> is reference to state instance of transition source
// For each leaving state execute exit() method.
    State testedNode = root.getState();
// Adjust destination node: if it far away from root then current state, move it to current state level
    State destinationNode = destination.pullDownToLevel( testedNode.level );
    while( testedNode != null )
    {
//      if( testedNode.getLevel() <= sourceLevel )  // while do not reach of source node level skip a testing
//      {
        if( testedNode == destination && this == destination ) // self transition
        {  
          testedNode.exit();
          testedNode.enter();
          destinationNode = destination;  // needed?
          break;  
        }
        if( testedNode == destinationNode ) 
          break;  // reach a common node for a current state and a destination state branches
//      }
      testedNode.exit(); // execute exit procedure
      destinationNode = destinationNode.pullDownToLevel( testedNode.level - 1 );
      testedNode = testedNode.getParent();
    }
// Now move from common node to destination node in opposite direction.
// Other direction is a reason to execute enter() methods for each state in the path
    while( destinationNode != destination )
    {
      (destinationNode = destinationNode.daughter).enter();
    }
// Set SM in the destination state. Check and execute initial transition(s) for given state.
    root.setState( destination );
  }

// These abstract methods have to be implemented in subclasses. They are represents
// behavior of the state.
  abstract public State fireInit();

  abstract public void enter();

  abstract public State fireEvent( Event e );

  abstract public void exit();
}

  
  package statemachine.hsm;

/**
 * This class represents a Hierarchical State Machine (HSM) 
 * @author Alexei Krasnopolski (krasnop@bellsouth.net)
 */
abstract public class Hsm extends State 
{
  /**
   * Holds reference to current state of HSM 
   */
  private State currState;
  /**
   * Initializing of HSM. Moving from pseudostate (null) to initial state (this), 
   * root of HSM's state tree. 
   */  
  public void init()
  {
    enter();
    setState( this );  
  }
  /**
   * Get-method for current state 
   */  
  public State getState()
  {
    return currState;
  }
  /**
   * Set-method for current state. After setting currState field, we have to check
   * does have this state init transition? If it has HSM moves to up along branch of state tree. 
   */  
  public void setState( State dest )
  {
	currState = dest;
	State daughterNode;
	
	while( (daughterNode = currState.fireInit()) != null )
	{
	  (currState = daughterNode).enter();
	}
  }
  /**
   * Dispatch method for external events. Pass the event to the states. Current state
   * is always first. After processing event HSM checks return value and in case null 
   * the process is over. 
   */  
  public void dispatchEvent(final Event e )
  {
    State parentState = currState;
    Event ee = e;
    do {
//      System.out.println(">>> dispatch event " + e.getID() + "; state " + parentState );
      parentState = parentState.fireEvent( e );
    } while (parentState != null );
//    while( (parentState = parentState.fireEvent( e )) != null );
  }
}

  
  package test;


import java.io.*;

import statemachine.hsm.Event;
import statemachine.hsm.Hsm;
import statemachine.hsm.State;


/**
 * This class represents a test HSM implementation.
 * @author Alexei Krasnopolski (krasnop@bellsouth.net)
 */

public class Test extends Hsm
{
  int myFoo;

  public void init()
  {
    System.out.print("Top-INIT;" );
    myFoo = 0;
    super.init();
  };

  public State fireInit()
  {
    System.out.print("INIT>>s0;" );
    return s1;
  }

  public State fireEvent( Event e )
  {
    printMessage( e, "s0" );
    switch( e.getID() )
    {
      case 5 :
        transition( s211 );
        return null;
      default :
        break;
    }
    return getParent();
  };
  public void enter()
  {
    System.out.print("ENTRY>>s0;" );
  }
  public void exit()
  {
    System.out.print("EXIT<<s0;" );
  };

  Hsm s0 = this;                 // This is just alias of current instance
  State s1 = new State( s0 )
  {
    public State fireEvent( Event e )
    {
      printMessage( e, "s1" );
      switch( e.getID() )
      {
        case 1 :
          transition( s1 );
          return null;
        case 2 :
          transition( s11 );
          return null;
        case 3 :
          transition( s2 );
          return null;
        case 4 :
          transition( s0 );
          return null;
        case 6 :
          transition( s211 );
          return null;
        default :
          break;
      }
      return getParent();
    }
    public State fireInit()
    {
      System.out.print("INIT>>s1;" );
      return s11;
    }
    public void enter()
    {
      System.out.print("ENTRY>>s1;" );
    }
    public void exit()
    {
      System.out.print("EXIT<<s1;" );
    }
  };
  State s11 = new State( s1 )
  {
    public State fireEvent( Event e )
    {
      printMessage( e, "s11" );
      switch( e.getID() )
      {
        case 7 :
          transition( s211 );
          return null;
        case 8 :
          System.out.print("myFoo="+myFoo + ";");
          if ( myFoo == 1 )
          {
            myFoo = 0;
            return null;
          }
          break;
        default :
          break;
      }
      return getParent();
    }
    public State fireInit()
    {
      return null;
    }
    public void enter()
    {
      System.out.print("ENTRY>>s11;" );
    }
    public void exit()
    {
      System.out.print("EXIT<<s11;" );
    }
  };
  State s2 = new State( s0 )
  {
    public State fireEvent( Event e )
    {
      printMessage( e, "s2" );
      switch( e.getID() )
      {
        case 3 :
          transition( s1 );
          return null;
        case 6 :
          transition( s11 );
          return null;
        default :
          break;
      }
      return getParent();
    }
    public State fireInit()
    {
      System.out.print("INIT>>s2;" );
      return s21;
    }
    public void enter()
    {
      System.out.print("ENTRY>>s2;" );
    }
    public void exit()
    {
      System.out.print("EXIT<<s2;" );
    }
  };
  State s21 = new State( s2 )
  {
    public State fireEvent( Event e )
    {
      printMessage( e, "s21" );
      switch( e.getID() )
      {
        case 2 :
          transition( s211 );
          return null;
        case 8 :
          System.out.print("myFoo=" + myFoo + ";");
          if ( myFoo == 0 )
          {
            myFoo = 1;
            transition( s21 );
            return null;
          }
          break;
        default :
          break;
      }
      return getParent();
    }
    public State fireInit()
    {
      System.out.print("INIT>>s21;" );
      return s211;
    }
    public void enter()
    {
      System.out.print("ENTRY>>s21;" );
    }
    public void exit()
    {
      System.out.print("EXIT<<s21;" );
    }
  };
  State s211 = new State( s21 )
  {
    public State fireEvent( Event e )
    {
      printMessage( e, "s211" );
      switch( e.getID() )
      {
        case 4 :
          transition( s21 );
          return null;
        case 7 :
          transition( s0 );
          return null;
        default :
          break;
      }
      return getParent();
    }
    public State fireInit()
    {
      return null;
    }
    public void enter()
    {
      System.out.print("ENTRY>>s211;" );
    }
    public void exit()
    {
      System.out.print("EXIT<<s211;" );
    }
  };

  public static void printMessage( Event e, String stateName )
  {
    char c = 'A';
    System.out.print( "Event-" + (char)(c + e.getID() - 1) + ">>" + stateName + ";" );
  }
  
  public static void main(String[] args)
  {
    Test fsm = new Test();
    fsm.init();

    for(;;)
    {
      char c;
      try
      {
        System.out.print("\nSignal<-");
        c = (char)System.in.read();
        System.in.skip( 2 );
      }
      catch( IOException ioe )
      {
        System.out.print("\nIO error");
        break;
      }
      if( c >= 'a' && c <= 'h' )
      {
        fsm.dispatchEvent( new Event( fsm, c - 'a' + 1 ) );
      }
      else
        break;
    };
    System.out.print("\nThe Program Ends");
  }
}