package org.state4j.sm;
   
   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.List;
   import java.util.Map;
   import java.util.TreeMap;
   
   import org.state4j.exceptions.PreconditionViolatedException;
  
  
  public abstract class SmStateImpl implements SmState {
      private SmAction         entryAction;
      private SmAction         exitAction;
      private String           name;
      private String           subtype;
      private SmCompositeState parent;
  
      public boolean hasEntryAction() {
          return this.entryAction != null;
      }
  
      public boolean hasExitAction() {
          return this.exitAction != null;
      }
  
      public boolean hasSubtype() {
          return this.subtype != null;
      }
  
      public SmAction getEntryAction() {
          return entryAction;
      }
  
      public void setEntryAction(SmAction entryAction) {
          this.entryAction = entryAction;
      }
  
      public SmAction getExitAction() {
          return exitAction;
      }
  
      public void setExitAction(SmAction exitAction) {
          this.exitAction = exitAction;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public boolean hasName() {
          return this.name != null;
      }
  
      public String getSubtype() {
          return subtype;
      }
  
      public void setSubtype(String subtype) {
          this.subtype = subtype;
      }
  
      public void entry(SmContext cntx) {
          cntx.entryInState(this);
          if (!this.hasEntryAction()) {
              return;
          }
          this.getEntryAction().execute(cntx);
      }
  
      public void entryUp(SmContext cntx, SmCompositeState toParent) {
          if (this.hasParent() && !this.equals(toParent)) {
              this.getParent().entryUp(cntx, toParent);
          }
          if (!this.equals(toParent)) {
              cntx.entryInState(this);
              if (this.hasEntryAction()) {
                  this.getEntryAction().execute(cntx);
              }
          }
      }
  
      public void exit(SmContext cntx) {
          cntx.exitFromState(this);
          if (!this.hasExitAction()) {
              return;
          }
          this.getExitAction().execute(cntx);
      }
  
      public void exitUp(SmContext cntx, SmCompositeState toParent) {
          if (!this.equals(toParent)) {
              cntx.exitFromState(this);
              if (this.hasExitAction()) {
                  this.getExitAction().execute(cntx);
             }
         }
         if (this.hasParent() && !this.equals(toParent)) {
             this.getParent().exitUp(cntx, toParent);
         }
     }
 
     public boolean isInitial() {
         if (this.hasSubtype() && this.getSubtype().equals(SmNaming.ATT_STATE_INITIAL)) {
             return true;
         }
         return false;
     }
 
     public boolean isFinal() {
         if (this.hasSubtype() && this.getSubtype().equals(SmNaming.ATT_STATE_FINAL)) {
             return true;
         }
         return false;
     }
 
     private Map<String, SmTransition> outTransitions = new TreeMap<String, SmTransition>();
 
     public List<SmTransition> getFireableTransitions(SmContext cntx, boolean withTrigger) {
         if (!this.hasOutTransitions()) {
             return new LinkedList<SmTransition>();
         }
         Iterator itTrans = this.getOutTransitions().values().iterator();
         LinkedList<SmTransition> result = new LinkedList<SmTransition>();
         while (itTrans.hasNext()) {
             SmTransition currTran = (SmTransition) itTrans.next();
             if (currTran.fireable(cntx, withTrigger)) {
                 result.addLast(currTran);
             }
         }
         return result;
     }
 
     public SmTransition getOutTransition(String transName) {
         if (!this.hasOutTransition(transName)) {
             throw new RuntimeException("Sorry! cannot get transition " + transName + ". Does not exists");
         }
         return this.getOutTransitions().get(transName);
     }
 
     public Map<String, SmTransition> getOutTransitions() {
         return outTransitions;
     }
 
     public boolean hasOutTransition(String transName) {
         if (transName == null || transName.equals("")) {
             throw new RuntimeException("Sorry!! cannot check transition with name null/empty");
         }
         return this.getOutTransitions().containsKey(transName) && this.getOutTransitions().get(transName) != null;
     }
 
     public boolean hasOutTransitions() {
         return this.outTransitions != null && !this.outTransitions.isEmpty();
     }
 
     public void setOutTransitions(Map<String, SmTransition> transitions) {
         this.outTransitions = transitions;
     }
 
     public void fire(SmContext cntx) {
         boolean done = false;
         boolean withTrigger = true;
         while (!done) {
             List trans = this.getFireableTransitions(cntx, withTrigger);
             if (!trans.isEmpty()) {
                 SmTransition currentTransition = (SmTransition) trans.get(0);
                 if (currentTransition != null) {
                     currentTransition.fire(cntx);
                 }
             } else {
                 done = !withTrigger;
             }
             withTrigger = false;
         }
         cntx.setCurrentEvent(null);
     }
 
     public boolean isActive(SmContext cntx) {
         if (cntx.getCurrentState().equals(this)) {
             return true;
         }
         return false;
     }
 
     public boolean equals(Object obj) {
         if (obj instanceof SmState) {
             return this.getName().equals(((SmState) obj).getName());
         }
         return false;
     }
 
     public void init() {
     // nothing to do
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see com.tim.sm.interfaces.MyState#hasParent()
      */
     public boolean hasParent() {
         return this.parent != null;
     }
 
     /***
      * @return Returns the parent.
      */
     public SmCompositeState getParent() {
         if (!hasParent()) {
             throw new PreconditionViolatedException("can't get parent!!!");
         }
         return parent;
     }
 
     /***
      * @param parent
      *            The parent to set.
      */
     public void setParent(SmCompositeState parent) {
         this.parent = parent;
     }
 
     public void addOutTransition(SmTransition transition) {
         if (transition.getStateOut() != this) {
             throw new PreconditionViolatedException("Sorry!! cannot add transiction " + transition);
         }
         if (!transition.isInternal()) {
             this.getParent().registerLCA(transition);
         }
         this.getOutTransitions().put(transition.getName(), transition);
     }
 }