/*

  * Created on Sep 11, 2003

  */

 package isac.bridge;

 import isac.util.CalcChangedEvent;

 import isac.util.Formula;

 import isac.util.ICalcIterator;

 import isac.util.IToCalc;

 import isac.util.IToUser;

 import isac.util.Tactic;

 import isac.wsdialog.DialogGuide;

 import java.io.Serializable;

 import java.rmi.RemoteException;

 import java.util.Iterator;

 import java.util.Vector;

 /**

  * A CalcTree represents a Calculation: It is a tree which consists

  * of one CalcHead at the top and abitrarily many Formulas and Tactics.

  * SubCalculations (with separate CalcHeads) are also part of CalcTree

  * This is the main interface between the Bridge and the Dialog

  * The CalcTree calls methods of the Math Engine, which in turn are

  * delegated to the BridgeRMI object on the other side of the RMI connection

  * The communication with the SML Kernel is completly hided from

  * the Dialog and the Frontend.

  * @author rgradisc

  */

 public class CalcTree implements IToCalc, Serializable {

   private final static int SCOPE_CURRENT_SUBPROBLEM = 1;

   private final static int SCOPE_CURRENT_SUBCALCULATION = 2;

   private final static int SCOPE_WHOLE_CALCULATION = 3;

   private int id;

   private Vector listeners;

   private MathEngine mathEngine;

   private ICalcIterator hotSpot;

   /**

   Start a new calculation. In case of failure, 

   the constructor may change the formalization object to hint at incomplete or

   contradictory specifications. 

   <br> Under normal circumstances, only complete calcHeads should be passed. 

   <br> Check every CalcHead for completeness (with the

   static method checkcalcHead() before constructing a CalcTree

   * @param calcHead The CalcHead for this CalcTree

   */

   CalcTree(MathEngine mathEngine, int id) {

     this.id = id;

     this.mathEngine = mathEngine;    

     listeners = new Vector();

   }

   /**

   Attach another dialog to the existing calculation tree. 

   * @param dlg The new Dialog to be attached to this CalcTree

   */

   public void attach(DialogGuide dg) {

   	listeners.add(dg);

   }

   /**

   Get a new iterator referencing the root element of the calculation tree. 

   <p> The functionality for navigating the calculation 

   is implemented in the CalcIterator object.

   * @return new instance of CalcIterator

   */

   public ICalcIterator iterator() {

     return new CalcIterator(this);

   }

   /**

   Makes the passed formula the active formula, i.e. the formula 

   the next tactic is applied to.

   * @param newActiveFormula

   */

   public void moveActiveFormula(ICalcIterator newActiveFormula) {

     //String s = sendToBridge("moveActiveFormula 1 1;");

     //not implemented in kernel

     ((CalcIterator)hotSpot).moveTo((CalcIterator)newActiveFormula);	

   }

   /**

   Tries to replaces the active formula in the calculation tree by 

   the passed formula. This could fail if no valid derivation from 

   the preceding formula to the (new) active formula can be found. 

   <p>Parts of the calculation after the replaced 

   formula are likely to become invalid, listeners will be informed

   of this with the update message, which contains the last unchanged 

   formula.

   * @param newFormula

   * @return The method will return 0 on success or a nonzero value 

   indicating the status otherwise. 

   */

   public int replaceFormula(Formula newFormula) {

     //String s = sendToBridge("replaceFormula 1 1;");

     //Not implemented in kernel

 	informListeners((ICalcIterator)hotSpot.clone(), generateTransactionID());

     return 0;

   }

   /**

   Tries to append the passed formula after the active formula. 

   This could fail if no valid derivation from the preceding formula 

   to the (new) active formula can be found. The method will fail as 

   well if the active formula is not the last formula in the (sub)calculation.

   Parts of the calculation might become invalid.

   * @param newFormula

   * @return The method will return 0 on success or a nonzero value 

   indicating the status otherwise.

   */

   public int appendFormula(Formula newFormula) {

 	informListeners((ICalcIterator)hotSpot.clone(), generateTransactionID());

     return 0;

   }

   /**

   Set and use a tactic in the next step of calculation.   

   * @param tactic the Tactic to be used in the the next step

   * @return The return value indicates success, failure or probable

   success at a later time.

   */

   public int setNextTactic(Tactic tactic) {

     int result = -1;

     try {

       result = mathEngine.setNextTactic(this.id, tactic);

       if (result == 0) {

         hotSpot.moveDown(); // move to the new formula/calcHead

 		informListeners((ICalcIterator)hotSpot.clone(),generateTransactionID());

       }	  

     } catch (RemoteException e) {

       // TODO Auto-generated catch block

       e.printStackTrace();

     }

     return -1;

   }

   /**

   Retrieve the tactic proposed by the SML-Kernel for 

   the next step in the calculation.  

   * @return proposed tactic.

   * Can be null, if the kernel does

   * not know what to do next, or if the end 

   * of the calculation is reached 

   */

   public Tactic fetchProposedTactic() {

     try {

       return mathEngine.fetchProposedTactic(this.id);

     } catch (RemoteException e) {

       // TODO Auto-generated catch block

       e.printStackTrace();

     }

     return null;

   }

   /**

   Get a list of tactics applicable to the active formula. 

   * @param scope The filter parameter selects the scope of

   search for applicable tactics: all tactics / all tactics from the 

   current theory / all tactics from the (calculation) method being applied.

   * @return Array with applyable tactics

   */

   public Tactic[] fetchApplicableTactics(int scope) {

     Tactic[] result = null;

     try {

       result = mathEngine.fetchAppliableTactics(this.id, scope);

 	} catch (RemoteException e) {

       // TODO Auto-generated catch block

       e.printStackTrace();

     }

     return result;

   }

   /**

   Calculate the next n steps starting from the active formula.   

   * @param scope The scope parameter can have following values:

   <ul>

   <li> 1 .. Stay in the current subproblem

   <li> 2 .. Stay in the current subcalculation (e.g. repetitions) 

   <li> 3 .. Stay in the current calculation as a whole. 

   </ul>

   * @param nSteps Specifies the count of steps to be autocalculated. 

   Passing 0 for nSteps will calculate until reaching a final result. 

   * @return The method returns an unique id to identify the request when 

   notifying about updates in the tree.

   */

   public int autoCalculate(int scope, int nSteps) {

     boolean isOK;

 	int transactionID = -1;

     try {

       isOK = mathEngine.autoCalculate(this.id, scope, nSteps);

       if (isOK) {      

 		transactionID = generateTransactionID();

 	    informListeners((ICalcIterator)hotSpot.clone(),transactionID);

       }

     } catch (RemoteException e) {

       e.printStackTrace();

     }

     return transactionID;

   }

   /**

    * Add a Listener to this CalcTree. Listeners will be informed about any

    * changes in the CalcTree.

    * @param listener the new Listener, has to implement the interface IToUser

    * @return true, if the listener has been added successfully

    */

   public boolean addListener(IToUser listener) {

     if (listeners.contains(listener)) {

       return false;

     } else {

       listeners.add(listener);

     }

     return true;

   }

   /**

    * Retrieve the active formula in a CalcTree. This is the formula form

    * where the calculation will continue.

    * @return Iterator that marks the currently active formula

    */

   public ICalcIterator getActiveFormula() {    

     return (ICalcIterator)hotSpot.clone();

   }  

   /**

   * Destruct this CalcTree: the sml-Representation of the CalcTree

   * is disposed, the id can be used for a new CalcTree

   * @return boolean value: success of operation (complete/failed)

   */

   public boolean destruct() {

     try {

       return mathEngine.destruct(this.id);

     } catch (RemoteException e) {

       // TODO Auto-generated catch block

       e.printStackTrace();

     }

     return false;

   } 

   // send an update event to the registered listeners

   private void informListeners(ICalcIterator firstChangedFormula, int transactionID) {

     Iterator it = listeners.iterator();    

     DialogGuide dg;

     CalcChangedEvent e = new CalcChangedEvent(

     transactionID,    // transactionID 

     true, // completed    

     firstChangedFormula);

     while (it.hasNext()) {

       dg = (DialogGuide)it.next();

       dg.calcChanged(e);

     }

   }  

   MathEngine getMathEngine() {

     return mathEngine;

   }

   public int getId() {

     return id;

   }

   // Special iterator hotSpot: marks the currently active formula of

   // the calcTree 

   void setHotSpot(ICalcIterator iterator) {

     hotSpot = iterator;

   }

   private int generateTransactionID() {

 	return (int)(Math.random()*0xFFFF);

   }

 }