/*

  * Created on Oct 20, 2003

  */

 package isac.bridge;

 import isac.util.CalcElement;

 import isac.util.CalcHead;

 import isac.util.CalcHeadCompoundID;

 import isac.util.Formalization;

 import isac.util.ICalcIterator;

 import isac.util.NotInSpecificationPhaseException;

 import isac.util.Tactic;

 import java.io.Serializable;

 import java.rmi.Naming;

 import java.rmi.RemoteException;

 import java.util.HashMap;

 import java.util.Map;

 import java.util.Vector;

 /**

  * @author rgradisc

  */

 public class MathEngine implements Serializable {

   private static MathEngine singleton;

   private IBridgeRMI bridgeRMI;

   private Map calcTrees;

   // Singleton Class: private constructor

   private MathEngine(String hostName) {

     //connect to bridge    

     try {

       bridgeRMI = (IBridgeRMI)Naming.lookup("//" + hostName + "/BridgeRMI");

       System.out.println("MathEngine Constr: connected to Bridge: " + bridgeRMI.toString());

       if (bridgeRMI == null)

         System.out.println("Bridge null!");

     } catch (Exception e) {

       System.out.println(

         "Could not connect to Bridge via RMI\n"

           + "Please make sure that the Bridge is running and connected");

       e.printStackTrace();

     }

     calcTrees = new HashMap();

     //states:= []; // only for testing: reset states for every new CalcTree

   }

   public static void init(String hostName) {

     singleton = new MathEngine(hostName);

   }

   public static MathEngine getMathEngine() {

     return singleton;

   }

   /**

   * Start a new calculation

   * @param f Formalization of the new calculation

   * @return CalcHead: Contains Specification part of Formalization

   * @throws RemoteException

   */

   public CalcHead startSpecifying(Formalization f) {

     CalcHead calcHead = null;

     try {

       int id = bridgeRMI.startSpecifying(f);

       CalcTree calcTree = new CalcTree(this, id);

       calcTrees.put(new Integer(id), calcTree);

       ICalcIterator hotSpot = calcTree.iterator();

       calcTree.setHotSpot(hotSpot); //first iterator marks the hotSpot

       hotSpot.moveRoot();

       calcHead = (CalcHead)hotSpot.getElement();

       // calcHead.setCalcTreeID(javaCalcID);

     } catch (RemoteException e) {

       e.printStackTrace();

     }

     return calcHead;

   }

   /**

   * Enter the solving phase of the calculation.

   * StartSpecifying must be called first

   * Only possible with a complete and correct calcHead

   * @param calcHead CalcHead for this calculation

   * @return CalcTree represents the calculation on the java side

   */

   public CalcTree startSolving(CalcHead calcHead) {

     /*CalcTree calcTree = null;

     System.out.println("MathEngine.startSolving: start");

     try {

       int id = bridgeRMI.startSolving(calcHead);

       calcTree = new CalcTree(this, id);

     } catch (RemoteException e) {

       e.printStackTrace();

     }

     System.out.println("MathEngine.startSolving: end");

     return calcTree;*/

     int id = calcHead.getCalcTreeID();

     CalcTree calcTree = (CalcTree)calcTrees.get(new Integer(id));

     return calcTree;

   }

   /**

    * Modify a given CalcHead    

    * The result is the same CalcHead with status flags for each item

    * @see CalcHead for possible status flags

    * @param calcHead CalcHead to be modified 

    * @return new CalcHead with a status for each item   

    */

   public CalcHead modifyCalcHead(CalcHead calcHead) {

     try {

       return bridgeRMI.modifyCalcHead(calcHead);

     } catch (RemoteException e) {

       e.printStackTrace();

     }

     return null;

   }

   /**

   * Refine a given problem for this CalcTree

   * @param problemID

   * @return CalcHead, if the operation was successful, else null 

   */

   public CalcHead tryRefine(CalcHead owner, CalcHeadCompoundID problemID)

     throws NotInSpecificationPhaseException {

     try {

       CalcHead result = bridgeRMI.tryRefine(owner.getCalcTreeID(), problemID);

       if (result == null) {

         throw new NotInSpecificationPhaseException();

       }

       return result;

     } catch (RemoteException e) {

       // TODO Auto-generated catch block

       e.printStackTrace();

     }

     return null;

   }

   /**

   * Match a given problem for this CalcTree

   * @param problemID

   * @return CalcHead, if the operation was successful, else null 

   */

   public CalcHead tryMatch(CalcHead owner, CalcHeadCompoundID problemID)

     throws NotInSpecificationPhaseException {

     try {

       CalcHead result = bridgeRMI.tryMatch(owner.getCalcTreeID(), problemID);

       if (result == null) {

         throw new NotInSpecificationPhaseException();

       }

       return result;

     } catch (RemoteException e) {

       // TODO Auto-generated catch block

       e.printStackTrace();

     }

     return null;

   }

   // Delegated methods from CalcTree/Iterator

   int setNextTactic(int id, Tactic tactic) throws RemoteException {

     return bridgeRMI.setNextTactic(id, tactic);

   }

   Tactic fetchProposedTactic(int id) throws RemoteException {

     return bridgeRMI.fetchProposedTactic(id);

   }

   Tactic[] fetchAppliableTactics(int id, int scope) throws RemoteException {

     return bridgeRMI.fetchAppliableTactics(id, scope);

   }

   int autoCalculate(int id, int scope, int nSteps) throws RemoteException {

     return bridgeRMI.autoCalculate(id, scope, nSteps);

   }

   int iterator(int id) throws RemoteException {

     return bridgeRMI.iterator(id);

   }

   boolean moveRoot(int calcTreeID, int iteratorID) throws RemoteException {

     return bridgeRMI.moveRoot(calcTreeID, iteratorID);

   }

   boolean moveUp(int calcTreeID, int iteratorID) throws RemoteException {

     return bridgeRMI.moveUp(calcTreeID, iteratorID);

   }

   boolean moveDown(int calcTreeID, int iteratorID) throws RemoteException {

     return bridgeRMI.moveDown(calcTreeID, iteratorID);

   }

   boolean moveLevelUp(int calcTreeID, int iteratorID) throws RemoteException {

     return bridgeRMI.moveLevelUp(calcTreeID, iteratorID);

   }

   boolean moveLevelDown(int calcTreeID, int iteratorID) throws RemoteException {

     return bridgeRMI.moveLevelDown(calcTreeID, iteratorID);

   }

   boolean moveTactic(int calcTreeID, int iteratorID) throws RemoteException {

     return bridgeRMI.moveTactic(calcTreeID, iteratorID);

   }

   boolean moveFormula(int calcTreeID, int iteratorID) throws RemoteException {

     return bridgeRMI.moveFormula(calcTreeID, iteratorID);

   }

   CalcElement getElement(int calcTreeID, int iteratorID) throws RemoteException {

     return bridgeRMI.getElement(calcTreeID, iteratorID);

   }

   /*

     public CalcHead tryRefine(int calcTreeID, CalcHeadCompoundID problemID) throws RemoteException {

       return bridgeRMI.tryRefine(calcTreeID, problemID);

     }

     public CalcHead tryMatch(int calcTreeID, CalcHeadCompoundID problemID) throws RemoteException {

       return bridgeRMI.tryMatch(calcTreeID, problemID);

     }

   */

   /**

    * Destruct a calcTree: Gives the memory occupied by this calcTree free again.

    * Call this method when the calcTree is no longer needed. This method is irreversible.

    * @param calcTreeID id of the calcTree to be destructed

    */

   public boolean destruct(int calcTreeID) throws RemoteException {    

     return bridgeRMI.destruct(calcTreeID);    

   }

   /**

    * Save a calcTree

    * @param calcTreeID id of the calcTree to be saved

    * @return a vector containing strings, representing the status of the calcTree

    */

   public Vector saveCalcTree(int calcTreeID) {

     try {

       return bridgeRMI.saveCalcTree(calcTreeID);

     } catch (RemoteException e) {

       e.printStackTrace();

     }

     return null;

   }

   /**

    * Load a stored calcTree

    * @param v Vector: the return value of saveCalcTree

    * @return a calcTree reference

    */

   public CalcTree loadCalcTree(Vector v) {    

     try {

       int id = bridgeRMI.loadCalcTree(v);

       CalcTree calcTree = new CalcTree(this, id);

       calcTrees.put(new Integer(id), calcTree);

       ICalcIterator hotSpot = calcTree.iterator(); // may be not first iterator (not hotspot)

       ((CalcIterator)hotSpot).makeHotSpot(); // make sure it is a hotspot iterator

       calcTree.setHotSpot(hotSpot); 

       hotSpot.moveRoot();

       return calcTree; 

     } catch (RemoteException e) {

       e.printStackTrace();

     }  

     return null;

   }

 }