/*

 * Created on Oct 20, 2003

 */

package isac.bridge;

import isac.util.CalcChanged;

import isac.util.Formalization;

import isac.util.NotInSpecificationPhaseException;

import isac.util.formulae.CalcHead;

import isac.util.formulae.CalcHeadCompoundID;

import isac.util.interfaces.ICalcElement;

import isac.util.interfaces.ICalcIterator;

import isac.util.tactics.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;

import org.apache.log4j.Logger;

/**

 * Class MathEngine: This class is called by the Dialog

 * and communicates with the Bridge via RMI.

 * It also delegates the methods of the CalcTree and the

 * CalcIterator to the Bridge. 

 * @author rgradisc

 */

public class MathEngine implements Serializable {

  private static MathEngine singleton;

  private IBridgeRMI bridgeRMI;

  // Stores the calcTrees after call of startSpecifying //WN00827 startCalculation

  // and hands them out to the dialog after startSolving//WN00827 ???

  private Map calcTrees;

  static Logger logger = Logger.getLogger(MathEngine.class.getName());

  // This is a Singleton Class: A private constructor is needed

  private MathEngine(String hostName) {

  	logger.debug("MathEngine("+hostName+")");

    try {

      //connect to bridge  

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

      System.out.println(

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

      if (bridgeRMI == null)

        System.out.println("Error occured: The Bridge could not be found!");

    } 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();

  }

  /*

   * FIXME.WN040924 just to make the old bridge continue work 

   **/

  protected IBridgeRMI getBridgeRMI() {

	return bridgeRMI; 	

  }

  /**

   * Initialize the MathEngine

   * @param hostName: Host name on which the Bridge is running

   */

  public static void init(String hostName) {

  	logger.fatal("DG->BR: init("+hostName+")");

    if (singleton == null) {

      singleton = new MathEngine(hostName);

    }

  }

  public static MathEngine getMathEngine() {

  	logger.fatal("DG->BR: getMathEngine()");

    return singleton;

  }

	 /**

	  * Start a new calculation

	  * @param f Formalization of the new calculation, from expl

	  * @return CalcHead: empty for startSpecifying

	  * @throws RemoteException WN040924 ???

	  *     

	  * int id = calcHead.getCalcTreeID();//WN040922 TODO simplify CalcHead

	  * CalcTree calcTree = (CalcTree) calcTrees.get(new Integer(id));//WN040922 TODO simplify

	  */

   public CalcTree startCalculation(Formalization f) {

  	logger.fatal("DG->BR: startCalculation("+f.toSMLString()+")");

    //CalcHead calcHead = null;

    CalcTree calcTree = null;//WN

    ICalcIterator hotSpot = null;//WN

    try {

      int id = bridgeRMI.startCalculation(f);

      calcTree = new CalcTree(this, id);

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

      hotSpot = calcTree.iterator();

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

      hotSpot.moveRoot();

      //---------------------------------------------- startSpecifying

      //WN calcHead = (CalcHead) hotSpot.getElement();

      //WN System.out.println("Calchead: " + calcHead.toSMLString());

    } catch (RemoteException e) {

      e.printStackTrace();

    }

    return calcTree;

  }

/*

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

   	logger.debug("autoCalculate: id="+id+", scope="+scope+", nSteps="+nSteps);

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

   }

*/

  /**

   * @see IToCalc#startSolving(), copied to CalcTree

   *

  public void startSolving(CalcHead calcHead) throws Exception {

  	logger.debug("startSolving: calcHead="+calcHead);

    int id = calcHead.getCalcTreeID();//WN040922 TODO simplify CalcHead

    CalcTree calcTree = (CalcTree) calcTrees.get(new Integer(id));//WN040922 TODO simplify

    if (calcHead.getCalcHeadStatus() != CalcHead.CALCHEAD_CORRECT) {

      throw new Exception("Startsolving with incorrect CalcHead");

    }

    Tactic t = calcTree.fetchProposedTactic();

    if (t.getName().compareTo("Apply_Method") != 0) {

      throw new Exception("Startsolving fetches " + t.getName());

    }

    //Next Tactic must always be Apply_Method

    calcTree.setNextTactic(t);

    //return calcTree;

  }

  **/

  /**

   * @see IToCalc   

  public void modifyCalcHead(CalcHead calcHead) {

  	logger.debug("modifyCalcHead: calcHead="+calcHead);

    CalcHead newCalcHead = null;

    try {

      newCalcHead = bridgeRMI.modifyCalcHead(calcHead);

      calcHead.fillValuesfrom(newCalcHead);

    } catch (RemoteException e) {

      e.printStackTrace();

    }

  }

  */

  /*

   * @see IToCalc

  public void completeCalcHead(CalcHead calcHead) {

  	logger.debug("completeCalcHead: calcHead="+calcHead);

    CalcHead newCalcHead = null;

    try {

    	//WN040924 newCalcHead = bridgeRMI.completeCalcHead(calcHead);

        bridgeRMI.completeCalcHead(calcHead);

        //WN040924 calcHead.fillValuesfrom(newCalcHead);

    } catch (RemoteException e) {

      e.printStackTrace();

    }

  }

  */

  /*

   * @see IToCalc

  public void completeCalcHead(CalcHead calcHead, int completeItem) {

    CalcHead newCalcHead;

    try {

      //WN040924 newCalcHead = bridgeRMI.completeCalcHead(calcHead, completeItem);

        bridgeRMI.completeCalcHead(calcHead, completeItem);

      //WN040924 calcHead.fillValuesfrom(newCalcHead);

      //TODO: Remove the following line!!

      calcHead.setCalcHeadStatus(CalcHead.CALCHEAD_CORRECT);

    } catch (RemoteException e) {

      e.printStackTrace();

    }

  }

   */

  /**

  * Refine a given problem for this CalcTree

  * @param problemID

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

  */

  public void tryRefine(CalcHead calcHead, CalcHeadCompoundID problemID)

    throws NotInSpecificationPhaseException {

    CalcHead newCalcHead = null;

    try {

    	//WN040924 newCalcHead = bridgeRMI.tryRefine(calcHead.getCalcTreeID(), problemID);

        bridgeRMI.tryRefine(calcHead.getCalcTreeID(), problemID);

      if (newCalcHead == null) {

        throw new NotInSpecificationPhaseException();

      }

      calcHead.fillValuesfrom(newCalcHead);

    } catch (RemoteException e) {

      // TODO Auto-generated catch block

      e.printStackTrace();

    }

  }

  /**

  * Match a given problem for this CalcTree

  * @param problemID

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

  */

  public void tryMatch(CalcHead calcHead, CalcHeadCompoundID problemID)

    throws NotInSpecificationPhaseException {

    CalcHead newCalcHead = null;

    try {

    	//WN040924 newCalcHead = bridgeRMI.tryMatch(calcHead.getCalcTreeID(), problemID);

        bridgeRMI.tryMatch(calcHead.getCalcTreeID(), problemID);

      if (newCalcHead == null) {

        throw new NotInSpecificationPhaseException();

      }

      calcHead.fillValuesfrom(newCalcHead);

    } catch (RemoteException e) {

      // TODO Auto-generated catch block

      e.printStackTrace();

    }

  }

  // 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);

  }

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

  	logger.debug("autoCalculate: id="+id+", scope="+scope+", nSteps="+nSteps);

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

  }

  int iterator(int id) throws RemoteException {

  	logger.debug("iterator: id="+id);

    return bridgeRMI.iterator(id);

  }

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

  	logger.debug("moveRoot: calcTreeID="+calcTreeID+", iteratorID="+iteratorID);

  	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 {

  	logger.debug("moveDown: calcTreeID="+calcTreeID+", iteratorID="+iteratorID);

    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);

  }

  ICalcElement getElement(int calcTreeID, int iteratorID)

    throws RemoteException {

    return bridgeRMI.getElement(calcTreeID, iteratorID);

  }

  /**

   * 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 previously 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;

  }

}