/*

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

	}

}