/*

 * Created on Oct 20, 2003

 */

package isac.bridge;

import isac.util.CalcChanged;

import isac.util.Formalization;

import isac.util.formulae.Assumptions;

import isac.util.formulae.CalcFormula;

import isac.util.formulae.KEStoreID;

import isac.util.formulae.Match;

import isac.util.formulae.Position;

import isac.util.formulae.ProblemID;

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

    // Stores the calc_trees_ after call of startSpecifying //WN00827

    // startCalculation

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

    private Map calc_trees_;

    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

            bridge_rmi_ = (IBridgeRMI) Naming.lookup("//" + hostName

                    + "/BridgeRMI");

            System.out.println("MathEngine Constr: connected to Bridge: "

                    + bridge_rmi_.toString());

            if (bridge_rmi_ == 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();

        }

        calc_trees_ = new HashMap();

    }

    /*

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

     */

    protected IBridgeRMI getBridgeRMI() {

        return bridge_rmi_;

    }

    /**

     * 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 = calc_head_.getCalcTreeID();//WN040922 TODO simplify CalcHead

     * CalcTree calcTree = (CalcTree) calc_trees_.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 = bridge_rmi_.startCalculation(f);

            calcTree = new CalcTree(this, id);

            calc_trees_.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 bridge_rmi_.autoCalculate(id,

     * scope, nSteps); }

     */

    /**

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

     * 

     * public void startSolving(CalcHead calc_head_) throws Exception {

     * logger.debug("startSolving: calc_head_="+calc_head_); int id =

     * calc_head_.getCalcTreeID();//WN040922 TODO simplify CalcHead CalcTree

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

     * simplify

     * 

     * if (calc_head_.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 calc_head_) {

     *      logger.debug("modifyCalcHead: calc_head_="+calc_head_); CalcHead

     *      newCalcHead = null; try { newCalcHead =

     *      bridge_rmi_.modifyCalcHead(calc_head_);

     *      calc_head_.fillValuesfrom(newCalcHead); } catch (RemoteException e) {

     *      e.printStackTrace(); } }

     */

    /*

     * @see IToCalc public void completeCalcHead(CalcHead calc_head_) {

     *      logger.debug("completeCalcHead: calc_head_="+calc_head_); CalcHead

     *      newCalcHead = null; try { //WN040924 newCalcHead =

     *      bridge_rmi_.completeCalcHead(calc_head_);

     *      bridge_rmi_.completeCalcHead(calc_head_); //WN040924

     *      calc_head_.fillValuesfrom(newCalcHead); } catch (RemoteException e) {

     *      e.printStackTrace(); } }

     */

    /*

     * @see IToCalc public void completeCalcHead(CalcHead calc_head_, int

     *      completeItem) { CalcHead newCalcHead; try { //WN040924 newCalcHead =

     *      bridge_rmi_.completeCalcHead(calc_head_, completeItem);

     *      bridge_rmi_.completeCalcHead(calc_head_, completeItem); //WN040924

     *      calc_head_.fillValuesfrom(newCalcHead); //TODO: Remove the following

     *      line!! calc_head_.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 try_refine_(CalcHead calc_head_, CalcHeadCompoundID

    // problemID)

    //			throws NotInSpecificationPhaseException {

    //		CalcHead newCalcHead = null;

    //		try {

    //			//WN040924 newCalcHead =

    //			// bridge_rmi_.try_refine_(calc_head_.getCalcTreeID(), problemID);

    //			bridge_rmi_.try_refine_(calc_head_.getCalcTreeID(), problemID);

    //			if (newCalcHead == null) {

    //				throw new NotInSpecificationPhaseException();

    //			}

    //			calc_head_.fillValuesfrom(newCalcHead);

    //		} catch (RemoteException e) {

    //	

    //			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 try_match_(CalcHead calc_head_, CalcHeadCompoundID problemID)

    //			throws NotInSpecificationPhaseException {

    //		CalcHead newCalcHead = null;

    //		try {

    //			//WN040924 newCalcHead =

    //			// bridge_rmi_.try_match_(calc_head_.getCalcTreeID(), problemID);

    //			bridge_rmi_.try_match_(calc_head_.getCalcTreeID(), problemID);

    //			if (newCalcHead == null) {

    //				throw new NotInSpecificationPhaseException();

    //			}

    //			calc_head_.fillValuesfrom(newCalcHead);

    //		} catch (RemoteException e) {

    //			

    //			e.printStackTrace();

    //		}

    //	}

    // Delegated methods from CalcTree/Iterator

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

        return bridge_rmi_.setNextTactic(id, tactic);

    }

    Tactic fetchProposedTactic(int id) throws RemoteException {

        return bridge_rmi_.fetchProposedTactic(id);

    }

    CalcChanged autoCalculate(int id, int scope, int nSteps)

            throws RemoteException {

        logger_.debug("autoCalculate: id=" + id + ", scope=" + scope

                + ", nSteps=" + nSteps);

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

    }

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

        return bridge_rmi_.replaceFormula(id, f);

    }

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

        return bridge_rmi_.appendFormula(id, f);

    }

    CalcChanged intermediateSteps(int id, ICalcIterator ci)

            throws RemoteException {

        return bridge_rmi_.intermediateSteps(id, ci);

    }

    Vector getElementsFromTo(int id, ICalcIterator iterator_from,

            ICalcIterator iterator_to, Integer level,

            boolean result_includes_tactics) throws RemoteException {

        return bridge_rmi_.getElementsFromTo(id, iterator_from, iterator_to,

                level, result_includes_tactics);

    }

    Position moveActiveFormula(int calcTreeID, Position p)

            throws RemoteException {

        return bridge_rmi_.moveActiveFormula(calcTreeID, p);

    }

    int iterator(int id) throws RemoteException {

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

        return bridge_rmi_.iterator(id);

    }

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

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

                + iteratorID);

        return bridge_rmi_.moveRoot(calcTreeID, iteratorID);

    }

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

            throws RemoteException {

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

    }

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

            throws RemoteException {

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

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

    }

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

            throws RemoteException {

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

    }

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

            throws RemoteException {

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

    }

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

            throws RemoteException {

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

    }

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

        return bridge_rmi_.moveTactic(calcTreeID, iteratorID);

    }

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

        return bridge_rmi_.moveFormula(calcTreeID, iteratorID);

    }

    ICalcElement getElement(int calcTreeID, Position p) throws RemoteException {

        return bridge_rmi_.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 bridge_rmi_.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 bridge_rmi_.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 = bridge_rmi_.loadCalcTree(v);

            CalcTree calcTree = new CalcTree(this, id);

            calc_trees_.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 bridge_rmi_.getTactic(id, pos);

    }

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

            throws RemoteException {

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

    }

    /**

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

     */

    public Assumptions getAssumptions(int id, Position pos)

            throws RemoteException {

        return bridge_rmi_.getAssumptions(id, pos);

    }

    /**

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

     */

    public Assumptions getAccumulatedAssumptions(int id, Position pos)

            throws RemoteException {

        return bridge_rmi_.getAccumulatedAssumptions(id, pos);

    }

    /**

     * @see isac.util.interfaces.ICalcIterator#tryMatchProblem

     */

    public Match tryMatchProblem(int calcTreeID, ProblemID pblID)

            throws RemoteException {

        return bridge_rmi_.tryMatchProblem(calcTreeID, pblID);

    }

    /**

     * @see isac.util.interfaces.ICalcIterator#tryRefineProblem

     */

    public Match tryRefineProblem(int calcTreeID, ProblemID pblID)

            throws RemoteException {

        return bridge_rmi_.tryRefineProblem(calcTreeID, pblID);

    }

    /**

     * @see isac.util.interfaces.ICalcIterator#tryMatchMethod

     */

    public Match tryMatchMethod(int calcTreeID, KEStoreID pblID)

            throws RemoteException {

        return bridge_rmi_.tryMatchMethod(calcTreeID, pblID);

    }

    /**

     * @see isac.util.interfaces.ICalcIterator#tryRefineMethod

     */

    public Match tryRefineMethod(int calcTreeID, KEStoreID pblID)

            throws RemoteException {

        return bridge_rmi_.tryRefineMethod(calcTreeID, pblID);

    }

}