/*

  * Created on Oct 20, 2003

  */

 package isac.bridge;

 import isac.util.CalcChanged;

 import isac.util.Formalization;

 import isac.util.NotInSpecificationPhaseException;

 import isac.util.formulae.Assumptions;

 import isac.util.formulae.CalcHead;

 import isac.util.formulae.CalcHeadCompoundID;

 import isac.util.formulae.CalcFormula;

 import isac.util.formulae.Position;

 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() + ")");

 		CalcTree calcTree = null;//WN

 		try {

 			int id = bridgeRMI.startCalculation(f);

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

 			int i = 111;

 		} catch (RemoteException e) {

 			e.printStackTrace();

 		}

 		logger.fatal("  DG<-BR: startCalculation <- calcTree=" + calcTree);

 		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.MODEL_ITEM_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.MODEL_ITEM_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();

 //		}

 //	}

 //WN050610 transferred toCalcTree

 //	/**

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

 	}

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

 	}

 	CalcChanged replaceFormula(int id, CalcFormula f) throws RemoteException {

 		return bridgeRMI.replaceFormula(id, f);

 	}

 	CalcChanged appendFormula(int id, CalcFormula f) throws RemoteException {

 		return bridgeRMI.appendFormula(id, f);

 	}

 	CalcChanged intermediateSteps(int id, ICalcIterator ci)

 			throws RemoteException {

 		return bridgeRMI.intermediateSteps(id, ci);

 	}

 	Vector getElementsFromTo(int id, ICalcIterator iterator_from,

 			ICalcIterator iterator_to, Integer level,

 			boolean result_includes_tactics) throws RemoteException {

 		return bridgeRMI.getElementsFromTo(id, iterator_from, iterator_to,

 				level, result_includes_tactics);

 	}

 	Position moveActiveFormula(int calcTreeID, Position p)

 			throws RemoteException {

 		return bridgeRMI.moveActiveFormula(calcTreeID, p);

 	}

 	int iterator(int id) throws RemoteException {

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

 		return bridgeRMI.iterator(id);

 	}

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

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

 				+ iteratorID);

 		return bridgeRMI.moveRoot(calcTreeID, iteratorID);

 	}

 	Position moveUp(int calcTreeID, int iteratorID, Position p)

 			throws RemoteException {

 		return bridgeRMI.moveUp(calcTreeID, iteratorID, p);

 	}

 	Position moveDown(int calcTreeID, int iteratorID, Position p)

 			throws RemoteException {

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

 		return bridgeRMI.moveDown(calcTreeID, iteratorID, p);

 	}

 	Position moveLevelUp(int calcTreeID, int iteratorID, Position p)

 			throws RemoteException {

 		return bridgeRMI.moveLevelUp(calcTreeID, iteratorID, p);

 	}

 	Position moveLevelDown(int calcTreeID, int iteratorID, Position p)

 			throws RemoteException {

 		return bridgeRMI.moveLevelDown(calcTreeID, iteratorID, p);

 	}

 	Position moveCalcHead(int calcTreeID, int iteratorID, Position p)

 			throws RemoteException {

 		return bridgeRMI.moveCalcHead(calcTreeID, iteratorID, p);

 	}

 	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, Position p) throws RemoteException {

 		return bridgeRMI.getElement(calcTreeID, p);

 	}

 	/**

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

 	}

 	/**

 	 * @see isac.util.interfaces.ICalcIterator#getTactic()

 	 */

 	public Tactic getTactic(int id, Position pos) throws RemoteException {

 		return bridgeRMI.getTactic(id, pos);

 	}

 	public Vector getApplicableTactics(int calcTreeID, int scope, Position pos)

 			throws RemoteException {

 		return bridgeRMI.getAppliableTactics(calcTreeID, scope, pos);

 	}

 	/**

 	 * @see isac.util.interfaces.ICalcIterator#getAssumptions()

 	 */

 	public Assumptions getAssumptions(int id, Position pos) throws RemoteException {

 		return bridgeRMI.getAssumptions(id, pos);

 	}

 	/**

 	 * @see isac.util.interfaces.ICalcIterator#getAssumptions()

 	 */

 	public Assumptions getAccumulatedAssumptions(int id, Position pos) throws RemoteException {

 		return bridgeRMI.getAccumulatedAssumptions(id, pos);

 	}

 }