/**

 * Created on Oct 13, 2003

 * @author Richard Gradischnegg RG

 */

package isac.bridge;

import isac.util.CalcChanged;

import isac.util.Formalization;

import isac.util.Message;

import isac.util.ResponseWrapper;

import isac.util.formulae.Assumptions;

import isac.util.formulae.CalcHead;

import isac.util.formulae.KEStoreID;

import isac.util.formulae.CalcHeadSimpleID;

import isac.util.formulae.CalcFormula;

import isac.util.formulae.FormHeadsContainer;

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.interfaces.IToCalc;

import isac.util.parser.XMLParserDigest;

import isac.util.tactics.Tactic;

import isac.util.tactics.TacticsContainer;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.MalformedURLException;

import java.net.Socket;

import java.net.UnknownHostException;

import java.rmi.Naming;

import java.rmi.RMISecurityManager;

import java.rmi.RemoteException;

import java.rmi.registry.LocateRegistry;

import java.rmi.server.UnicastRemoteObject;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import java.util.Vector;

import org.apache.log4j.Logger;

/**

  * @author Richard Gradischnegg RG

 * 

 * WN0422 here seems to be the key for simplifying the whole bridge.* drawbacks

 * of the present implementation: # more complicated than necessary #

 * JUnitTestCases require BridgeMain running # BridgeLogger cannot be made

 * serializable, thus not accessible for writing by JUnitTestCases #

 */

public class BridgeRMI extends UnicastRemoteObject implements IBridgeRMI {

    private BridgeMain bridge_;

    private XMLParserDigest xml_parser_digest_;

    // Socket used to communicate with bridge

    private Socket socket_ = null;

    // Writer to write sml requests to the kernel

    private PrintWriter out_ = null;

    // Reader to read sml response from kernel

    private BufferedReader in_ = null;

    private String host_;

    private int port_;

    private String dtdpath_;

    private int rmiid_;

    /**

     * Maps the Java calc(Tree)rmiID to the sml calc(Tree)rmiID. A mapping is

     * nescessary because these ids are not (nescessary) the same: For example

     * when restoring the kernel, the calcTree rmiID can change because of

     * already finished CalcTrees no longer existing and their CalcId assigned

     * to another CalcTree. key: Integer (javaCalcID) value: Integer (smlCalcID)

     */

    private Map java_calcid_to_smlcalcid_;

    /**

     * This map stores user inputs which have already been answered by the

     * kernel and the response being sent back to the user. These inputs are

     * resent to the kernel in the case of a newstart of the kernel. key:

     * Integer (javaCalcID) value: Vector (containing input strings)

     */

    private Map inputs_;

    static Logger logger_ = Logger.getLogger(BridgeRMI.class.getName());

    public BridgeRMI(BridgeMain bridge, String host, int port, String dtdPath)

            throws RemoteException {

        logger_.warn("BridgeRMI obj.init: bridge=" + bridge + ", host=" + host

                + ", port=" + port + ", dtdPath=" + dtdPath);

        this.host_ = host;

        this.port_ = port;

        this.dtdpath_ = dtdPath;

        this.bridge_ = bridge;

        /*

         * out = bridge.getSmlWriter(); in = bridge.getSmlReader();

         */

        in_ = bridge.getSmlReader();

        try {

            socket_ = new Socket(host, port);

            out_ = new PrintWriter(socket_.getOutputStream(), true);

            in_ = new BufferedReader(new InputStreamReader(socket_

                    .getInputStream()));

        } catch (UnknownHostException e) {

            System.out.println("Unknown host: " + host + "\n");

        } catch (IOException e) {

            System.out.println("No I/O\n");

        }

        rmiBind();

        xml_parser_digest_ = new XMLParserDigest(dtdPath);

        //xml_parser_digest_.setValidating(true);

        //...all XML-data should be tested in

        //javatest.isac.util.parser.TestXMLParserDigest

        inputs_ = new HashMap();

        java_calcid_to_smlcalcid_ = new HashMap();

    }

    /**

     * Buffers input sent to the sml-Kernel (for later possible restart)

     * 

     * @param javaCalcID

     *            calcTree this input belongs to

     * @param input

     *            to be buffered

     */

    public void bufferInput(int javaCalcID, String input) {

        Vector v = (Vector) inputs_.get(new Integer(javaCalcID));

        if (v == null) {

            v = new Vector();

            inputs_.put(new Integer(javaCalcID), v);

        }

        v.add(input);

    }

    // '@calcid@' is a placeholder for the CalcID

    // this method replaces it with a real CalcID

    private String insertCalcID(int id, String s) {

        return s.replaceAll("@calcid@", String.valueOf(id));

    }

    // return smallest integer which is not yet

    // used as a (java)CalcID

    private int smallestFreeCalcID() {

        Set set = java_calcid_to_smlcalcid_.keySet();

        for (int i = 0; i < set.size(); i++) {

            if (!set.contains(new Integer(i))) {

                return i;

            }

        }

        return set.size();

    }

    /*

     * Send a sml instruction to the kernel. restore == true, if the instruction

     * is resent after the kernel crashed

     */

    private ResponseWrapper sendToKernel(String smlInstr, boolean restore) {

        logger_.fatal("   BR->KN: sendToKernel(" + smlInstr + ")");

        ResponseWrapper wrapper = null;

        //bridge.log(1,"---sendToKernel |

        //bridge.isRestoring=="+bridge.isRestoring());

        //bridge.log(1,"---sendToKernel | restoring=="+restore);

        if (!bridge_.isRestoring() || restore) {

            String xmlString = "";

            out_.println(smlInstr);// send the sml Instruction to the sml Kernel

            try {

                xmlString = in_.readLine();//read the response from the kernel

                logger_.fatal("   BR<-KN: sendToKernel <- xml= " + xmlString);

            } catch (IOException e) {

                bridge_.log(1, "BridgeRMI.interpretSKN: IOException");

                e.printStackTrace();

            }

            //if (!(restore) && bridge.isRestoring()) {

            //	this.restoreExistingCalcTrees();

            //}

            wrapper = xml_parser_digest_.parse(xmlString);

        }

        return wrapper;

    }

    /**

     * Starts a new calculation in the sml-Kernel: i.e. a new CalcTree with the

     * initial hot_spot_

     * 

     * @param instr

     *            "CalcTree" + Formalization in string Representation

     * @return Returns smlCalcID

     */

    private synchronized int newCalculation(int javaCalcID, String instr,

            boolean restore) {

        logger_.warn("newCalculation: javaCalcID=" + javaCalcID + ", instr"

                + instr + ", restore=" + restore);

        bridge_.log(1, "new calculation: " + instr);

        ResponseWrapper wrapper = sendToKernel(instr, restore);

        if (wrapper == null)

            return -1;

        int smlCalcID = wrapper.getCalcID();

        /* int javaCalcID = smallestFreeCalcID(); */

        java_calcid_to_smlcalcid_.put(new Integer(javaCalcID), new Integer(

                smlCalcID));

        sendToKernel("Iterator " + smlCalcID + ";", restore);//WN041209 no

        // Iterator from KN

        sendToKernel("moveActiveRoot " + smlCalcID + ";", restore);//WN041209

        // no

        // Iterator

        // from KN

        if (!restore)

            bufferInput(javaCalcID, instr);

        return smlCalcID;

    }

    /**

     * Send an instruction to the SML-Kernel and return the response

     * 

     * @param smlInstr

     *            Instruction

     * @return response from SML-Kernel

     */

    private synchronized ResponseWrapper interpretSML(int javaCalcID,

            String instr, boolean restore) {

        int smlCalcID;

        smlCalcID = ((Integer) java_calcid_to_smlcalcid_.get(new Integer(

                javaCalcID))).intValue();

        String smlInstr = insertCalcID(smlCalcID, instr);

        bridge_.log(1, "JavaCalcID " + javaCalcID + " == SmlCalcID "

                + smlCalcID);

        bridge_.log(1, "sent to bridge: " + smlInstr);

        ResponseWrapper wrapper = this.sendToKernel(smlInstr, restore);

        if (!restore)

            bufferInput(javaCalcID, smlInstr);

        return wrapper;

    }

    private void rmiBind() {

        logger_.warn("rmiBind");

        if (System.getSecurityManager() == null) {

            System.setSecurityManager(new RMISecurityManager());

        }

        try {

            LocateRegistry.createRegistry(1099);

        } catch (java.rmi.RemoteException exc2) {

            System.err.println("can not create registry: " + exc2.getMessage());

        }

        String name = "//" + host_ + "/BridgeRMI";

        try {

            System.out.println("try to bind as " + name);

            Naming.rebind(name, this);

            System.out.println("Bridge RMI bound to " + name);

        } catch (java.rmi.ConnectException e) {

            System.err.println("failed to contact as " + name

                    + " (creating RMI-Server on localhost: 1099)");

        } catch (RemoteException e) {

            e.printStackTrace();

        } catch (MalformedURLException e) {

            e.printStackTrace();

        }

    }

    //---------------------------------------------- Delegated Methods for

    // MathEngine

    public void modifyCalcHead(CalcHead calcHead) {

        logger_.warn("modifyCalcHead: calc_head_=" + calcHead.toSMLString());

        ResponseWrapper wrapper = interpretSML(calcHead.getCalcTreeID(), //FIXME

                // simplify

                // CalcHead

                "modifyCalcHead @calcid@ " + calcHead.toModifyCalcHeadString()

                        + ";", false);

        //if (wrapper == null) WN040924 miniupdate for void instead CalcHead

        //  return null; WN040924 miniupdate for void instead CalcHead

        CalcHead result = (CalcHead) wrapper.getResponse();

        result.setCalcTreeID(smlCalcIDtoJavaCalcID(wrapper.getCalcID()));

        //return result; WN040924 miniupdate for void instead CalcHead

    }

    /**

     * Starts the specifying phase: fill the calcTree with the appropriate

     * information. Once the calc_head_ is fully specified, the user can begin

     * with the actual calculation.

     * 

     * @param f

     *            Formalization for this calculation (empty if user starts a

     *            complete new calculation)

     * @return javaCalcID

     */

    public int startCalculation(Formalization formalization) {

        logger_.warn("startCalculation: formalization=" + formalization);

        int javaCalcID = smallestFreeCalcID();

        this.bridge_.log(1, "-----smallest free javaCalcID = " + javaCalcID);

        int smlCalcID = newCalculation(javaCalcID, "CalcTree "

                + formalization.toSMLString() + ";", false);

        //javaCalcIDtoSmlCalcID.put(new Integer(javaCalcID), new

        // Integer(smlCalcID));

        return javaCalcID;

    }

    /*

     * // this function is no longer needed here, // MathEngine handels the

     * startSolving now public boolean startSolving(int calcID) { //TODO: check

     * activeCalcHead for completeness return true; }

     */

    /**

     * @deprecated

     */

    public void completeCalcHead(int id, CalcHead calcHead, int completeItem) {

        ResponseWrapper wrapper = interpretSML(calcHead.getCalcTreeID(),

                "autoCalculate @calcid@ CompleteCalcHead;", false);

        CalcHead result = (CalcHead) wrapper.getResponse();

        result.setCalcTreeID(smlCalcIDtoJavaCalcID(wrapper.getCalcID()));

        //return result; WN040924 miniupdate

    }

    /**

     * FIXXME.WN05 completeCalcHead MUST return CalcChanged !

     */

    public void completeCalcHead(int id) {

        logger_.warn("begin completeCalcHead");

        ResponseWrapper wrapper = interpretSML(id, //calc_head_.getCalcTreeID(),

                "autoCalculate @calcid@ CompleteCalcHead;", false);

        //return CalcChanged !!!

        //        if (wrapper == null)

        //            return null;

        //        else if (wrapper.getResponse() instanceof Message)

        //            return null;//TODO.WN041209 handle messages

        //        else

        //            return (CalcChanged) wrapper.getResponse();

    }

    public int setNextTactic(int id, Tactic tactic) {

        ResponseWrapper wrapper = interpretSML(id, "setNextTactic @calcid@ ("

                + tactic.toSMLString() + ");", false);

        if (wrapper == null) //WN050223 response ... MESSAGE wird nicht

            // ausgeparst !!!

            return -1;

        if (wrapper.getResponse() == null) {

            //WN041126 ---> isac.wsdialog.DialogGuide#notifyUserAction #@#

            //autoCalculate(id, /* scope */1, /* steps */1);

            return 0; //Everything is ok

        } else {

            return -1; //An Error occcured

        }

    }

    public Tactic fetchProposedTactic(int id) {

        ResponseWrapper wrapper = interpretSML(id,

                "fetchProposedTactic @calcid@;", false);

        if (wrapper == null) {

            return null;

        }

        // wrapper != null

        return (Tactic) wrapper.getResponse();

    }

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

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

                + ", nSteps" + nSteps);

        ResponseWrapper wrapper = null;

        //3 means IToCalc.SCOPE_CALCHEAD:

        if ((scope == 3) && (nSteps == 0)) {

            wrapper = interpretSML(id,

                    "autoCalculate @calcid@ CompleteCalcHead;", false);

            //FIXXXME.WN040624 nSteps == 0 hides mismatch in specifications

        } else if ((scope == IToCalc.SCOPE_CALCULATION) && (nSteps == 0)) {

            wrapper = interpretSML(id, "autoCalculate @calcid@ CompleteCalc;",

                    false);

        } else if ((scope == IToCalc.SCOPE_MODEL) && (nSteps == 0)) {

            wrapper = interpretSML(id, "autoCalculate @calcid@ CompleteModel;",

                    false);

        } else if ((scope == IToCalc.SCOPE_SUBCALCULATION) && (nSteps == 0)) {

            wrapper = interpretSML(id,

                    "autoCalculate @calcid@ CompleteToSubpbl;", false);

        } else if ((scope == IToCalc.SCOPE_SUBPROBLEM) && (nSteps == 0)) {

            wrapper = interpretSML(id,

                    "autoCalculate @calcid@ CompleteSubpbl;", false);

        } else {

            //FIXXXME040624: steps do not regard the scope

            wrapper = interpretSML(id, "autoCalculate @calcid@ (Step " + nSteps

                    + ");", false);

        }

        if (wrapper == null)

            return null;

        else if (wrapper.getResponse() instanceof Message)

            return null;//TODO.WN041209 handle messages

        else

            return (CalcChanged) wrapper.getResponse();

    }

    public CalcChanged replaceFormula(int id, CalcFormula f) {

        ResponseWrapper wrapper = null;

        wrapper = interpretSML(id, "replaceFormula @calcid@ \""

                + f.toSMLString() + "\";", false);

        if (wrapper == null)

            return null;

        else if (wrapper.getResponse() instanceof Message)

            return null;//TODO.WN041209 handle messages

        else

            return (CalcChanged) wrapper.getResponse();

    }

    public CalcChanged appendFormula(int id, CalcFormula f) {

        ResponseWrapper wrapper = null;

        wrapper = interpretSML(id, "appendFormula @calcid@ \""

                + f.toSMLString() + "\";", false);

        if (wrapper == null)

            return null;

        else if (wrapper.getResponse() instanceof Message)

            return null;//TODO.WN041209 handle messages

        else

            return (CalcChanged) wrapper.getResponse();

    }

    public CalcChanged intermediateSteps(int id, ICalcIterator ci) {

        ResponseWrapper wrapper = null;

        wrapper = interpretSML(id, "interSteps @calcid@ " + ci.toSMLString()

                + ";", false);

        if (wrapper == null)

            return null;

        else if (wrapper.getResponse() instanceof Message)

            return null;//TODO.WN041209 handle messages

        else

            return (CalcChanged) wrapper.getResponse();

    }

    public Vector getElementsFromTo(int id, ICalcIterator iterator_from,

            ICalcIterator iterator_to, Integer level,

            boolean result_includes_tactics) {

        ResponseWrapper wrapper = null;

        // getElementsFromTo 1 unc gen 1 false;

        wrapper = interpretSML(id, "getElementsFromTo @calcid@ "

                + iterator_from.toSMLString() + " " + iterator_to.toSMLString()

                + " " + level + " " + result_includes_tactics + ";", false);

        if (wrapper == null)

            return null;

        FormHeadsContainer con = (FormHeadsContainer) wrapper.getResponse();

        return con.getElements();

    }

    public int iterator(int id) {

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

        //		ResponseWrapper wrapper = null;

        //		wrapper = interpretSML(id, "Iterator @calcid@;", false);

        //		if (wrapper == null)

        //			return -1;

        //		return Integer.parseInt(((CalcHeadSimpleID)

        //                               wrapper.getResponse()).getID());

        if (id == 1) {

            ResponseWrapper wrapper = interpretSML(id, "Iterator @calcid@;",

                    false);

            if (wrapper == null)

                return -1;

            else

                return Integer.parseInt(((CalcHeadSimpleID) wrapper

                        .getResponse()).getID());

        } else

            return 4711;//TODO.WN041208 drop CalcIterator.iteratorID_

    }

    //	private Position moveSuccess(ResponseWrapper wrapper) {

    //		if (wrapper == null)

    //			return null;

    //		else {

    //			if (wrapper.getResponse() instanceof Message)

    //				return null;//TODO.WN041209 handle messages

    //			else {

    //				Position p = (Position) wrapper.getPosition();

    //				return p;

    //			}

    //		}

    //	}

    private Position moveSuccess(ResponseWrapper wrapper) {

        if (wrapper == null)

            return null;

        else {

            Object r = wrapper.getResponse();

            if (r instanceof Message)

                return null;//TODO.WN041209 handle messages

            else {

                Position p = (Position) wrapper.getResponse();

                return p;

            }

        }

    }

    //returns Position for uniformity with move*; not required elsewhere

    public Position moveActiveFormula(int javaCalcID, Position p) {

        logger_.debug("moveDown: javaCalcID=" + javaCalcID + ", sml_pos="

                + p.toSMLString());

        ResponseWrapper wrapper = interpretSML(javaCalcID,

                "moveActiveFormula @calcid@ " + p.toSMLString() + ";", false);

        return moveSuccess(wrapper);

    }

    public Position moveRoot(int javaCalcID, int iteratorID) {

        logger_.warn("moveRoot: javaCalcID=" + javaCalcID);

        ResponseWrapper wrapper = null;

        if (iteratorID == 1)

            wrapper = interpretSML(javaCalcID, "moveActiveRoot @calcid@" + ";",

                    false);

        else

            wrapper = interpretSML(javaCalcID, "moveRoot @calcid@ " + ";",

                    false);

        return moveSuccess(wrapper);

    }

    public Position moveUp(int javaCalcID, int iteratorID, Position p) {

        ResponseWrapper wrapper = null;

        if (iteratorID == 1)

            wrapper = interpretSML(javaCalcID, "moveActiveUp @calcid@" + ";",

                    false);

        else

            wrapper = interpretSML(javaCalcID, "moveUp @calcid@ "

                    + p.toSMLString() + ";", false);

        return moveSuccess(wrapper);

    }

    public Position moveDown(int javaCalcID, int iteratorID, Position p) {

        logger_.debug("moveDown: javaCalcID=" + javaCalcID + ", sml_pos="

                + p.toSMLString());

        ResponseWrapper wrapper = null;

        if (iteratorID == 1)

            wrapper = interpretSML(javaCalcID, "moveActiveDown @calcid@" + ";",

                    false);

        else

            wrapper = interpretSML(javaCalcID, "moveDown @calcid@ "

                    + p.toSMLString() + ";", false);

        return moveSuccess(wrapper);

    }

    public Position moveLevelUp(int javaCalcID, int iteratorID, Position p) {

        ResponseWrapper wrapper = null;

        if (iteratorID == 1)

            wrapper = interpretSML(javaCalcID, "moveActiveLevelUp @calcid@"

                    + ";", false);

        else

            wrapper = interpretSML(javaCalcID, "moveLevelUp @calcid@ "

                    + p.toSMLString() + ";", false);

        return moveSuccess(wrapper);

    }

    public Position moveLevelDown(int javaCalcID, int iteratorID, Position p) {

        ResponseWrapper wrapper = null;

        if (iteratorID == 1)

            wrapper = interpretSML(javaCalcID, "moveActiveLevelDown @calcid@"

                    + ";", false);

        else

            wrapper = interpretSML(javaCalcID, "moveLevelDown @calcid@ " + " "

                    + p.toSMLString() + ";", false);

        return moveSuccess(wrapper);

    }

    public Position moveCalcHead(int javaCalcID, int iteratorID, Position p) {

        ResponseWrapper wrapper = null;

        if (iteratorID == 1)

            wrapper = interpretSML(javaCalcID, "moveActiveCalcHead @calcid@"

                    + ";", false);

        else

            wrapper = interpretSML(javaCalcID, "moveCalcHead @calcid@ " + " "

                    + p.toSMLString() + ";", false);

        return moveSuccess(wrapper);

    }

    /**

     * @deprecated in favour of getTactic

     */

    public boolean moveTactic(int javaCalcID, int iteratorID) {

        ResponseWrapper wrapper = interpretSML(javaCalcID,

                "moveTactic @calcid@ " + iteratorID + ";", false);

        return true;//WN041208 moveSuccess(wrapper);

    }

    /**

     * @deprecated in favour of getFormula

     */

    public boolean moveFormula(int javaCalcID, int iteratorID) {

        ResponseWrapper wrapper = interpretSML(javaCalcID,

                "moveFormula @calcid@ " + iteratorID + ";", false);

        return true;//WN041208 moveSuccess(wrapper);

    }

    public int smlCalcIDtoJavaCalcID(int smlID) {

        Iterator it = java_calcid_to_smlcalcid_.keySet().iterator();

        while (it.hasNext()) {

            Object key = it.next();

            Integer value = (Integer) java_calcid_to_smlcalcid_.get(key);

            if (value.intValue() == smlID) {

                return ((Integer) key).intValue();

            }

        }

        return -1;

    }

    public boolean destruct(int javaCalcID) {

        ResponseWrapper wrapper = interpretSML(javaCalcID,

                "DEconstrCalcTree @calcid@;", false);

        if (wrapper == null) {

            return false;

        }

        java_calcid_to_smlcalcid_.remove(new Integer(javaCalcID));

        inputs_.remove(new Integer(javaCalcID));

        return true;

    }

    public Map getInputs() {

        return inputs_;

    }

    public int getRmiID() {

        return rmiid_;

    }

    public void setRmiID(int i) {

        logger_.warn("setRmiID: i=" + i);

        rmiid_ = i;

    }

    /**

     * Save a calcTree for later restoring (probably to another SML Kernel)

     * 

     * @param calcTreeID

     *            the ID of the calcTree

     * @return a vector containing strings. This is representatation of the

     *         status of the calcTree

     */

    public Vector saveCalcTree(int calcTreeID) {

        this.bridge_.log(1, "----------------begin saving calcTree "

                + calcTreeID + "------------");

        return (Vector) inputs_.get(new Integer(calcTreeID));

    }

    /**

     * Restore a saved calcTree.

     * 

     * @param v

     *            Vector containing strings

     * @return Java CalcTreeID (not SML-ID)

     */

    public int loadCalcTree(Vector v) {

        this.bridge_.log(1, "----------------begin loading------------");

        int javaCalcID = smallestFreeCalcID();

        this.bridge_.log(1, "-----smallest free  = " + javaCalcID);

        restoreToSML(javaCalcID, v);

        this.bridge_.log(1, "----------------done loading-------------");

        return javaCalcID;

    }

    private void restoreToSML(int javaCalcID, Vector v) {

        Iterator it = ((Vector) v.clone()).iterator();

        CalcTree result = null;

        String s = (String) it.next();

        int smlCalcID = newCalculation(javaCalcID, s, true);

        //javaCalcIDtoSmlCalcID.put(new Integer(javaCalcID), new

        // Integer(smlCalcID));

        //int smlID = ((Integer)javaCalcIDtoSmlCalcID.get(new

        // Integer(calcID))).intValue();

        while (it.hasNext()) {

            s = (String) it.next();

            interpretSML(javaCalcID, s, true);

        }

    }

    /**

     * This method is used when the kernel crashes and the CalcTrees need to be

     * entered again to the kernel to restore the previous state. The

     * Java-CalcIDs stay the same

     */

    public void restoreExistingCalcTrees() {

        bridge_.log(1, "---- entering restoreExistingCalcTrees");

        Iterator it = java_calcid_to_smlcalcid_.keySet().iterator();

        // keySet = javaCalcIDs

        int javaCalcID, newSmlCalcID;

        Vector v;

        while (it.hasNext()) {

            //bridge.log(1, "1");

            //int i = ((Integer)it.next()).intValue();

            javaCalcID = ((Integer) it.next()).intValue();

            //bridge.log(1, "2");

            v = saveCalcTree(javaCalcID);

            //bridge.log(1, "3");

            this.restoreToSML(javaCalcID, v);

        }

        bridge_.log(1, "---- done restoreExistingCalcTrees");

    }

    /**

     * @see isac.bridge.IBridgeRMI#getElement(int, int)

     * @deprecated in favour of getFormula, getTactic, getAssumption

     */

    public ICalcElement getElement(int javaCalcID, Position p) {

        ResponseWrapper wrapper = interpretSML(javaCalcID,

                "refFormula @calcid@ " + p.toSMLString() + ";", false);

        if (wrapper == null)

            return null;

        ICalcElement ce = (ICalcElement) wrapper.getResponse();

        if (ce instanceof CalcFormula) {

            //			((CalcFormula) ce).setPosition(wrapper.getPosition());

        } else if (ce instanceof CalcHead) {

            //			((CalcHead) ce).setPosition(wrapper.getPosition());

            ((CalcHead) ce).setCalcTreeID(javaCalcID);

        }

        return ce;

    }

    /**

     * @see isac.bridge.IBridgeRMI#getFormula(int, int)

     */

    public ICalcElement getFormula(int calcTreeID, Position p)

            throws RemoteException {

        ResponseWrapper wrapper = interpretSML(calcTreeID,

                "refFormula @calcid@ " + p.toSMLString() + ";", false);

        if (wrapper == null)

            return null;

        ICalcElement ce = (ICalcElement) wrapper.getResponse();

        if (ce instanceof CalcFormula) {

            //			((CalcFormula) ce).setPosition(wrapper.getPosition());

        } else if (ce instanceof CalcHead) {

            //			((CalcHead) ce).setPosition(wrapper.getPosition());

            ((CalcHead) ce).setCalcTreeID(calcTreeID);

        }

        return ce;

    }

    /*

     * (non-Javadoc)

     * 

     * @see isac.bridge.IBridgeRMI#getTactic(int, int)

     */

    public Tactic getTactic(int calcTreeID, Position pos)

            throws RemoteException {

        ResponseWrapper wrapper = interpretSML(calcTreeID,

                "getTactic @calcid@ " + pos.toSMLString() + ";", false);

        return (Tactic) wrapper.getResponse();

    }

    //	 WN050217 public Tactic[] fetchAppliableTactics(int id, int scope) {

    public Vector getAppliableTactics(int id, int scope, Position pos) {

        ResponseWrapper wrapper = interpretSML(id,

                "fetchApplicableTactics @calcid@ " + scope + pos.toSMLString()

                        + ";", false);

        if (wrapper == null)

            return null;

        TacticsContainer tc = (TacticsContainer) wrapper.getResponse();

        Vector v = tc.getTactics();

        //		Object[] result = new Tactic[v.size()];

        //		return (Tactic[]) v.toArray(result);

        return v;

    }

    /**

     * @see isac.bridge.IBridgeRMI#getAssumption(int, int)

     */

    public Assumptions getAssumptions(int calcTreeID, Position pos)

            throws RemoteException {

        ResponseWrapper wrapper = interpretSML(calcTreeID,

                "getAssumptions @calcid@ " + pos.toSMLString() + ";", false);

        return (Assumptions) wrapper.getResponse();

    }

    /**

     * @see isac.bridge.IBridgeRMI#getAccumulatedAssumptions(int,

     *      isac.util.formulae.Position)

     */

    public Assumptions getAccumulatedAssumptions(int calcTreeID, Position pos)

            throws RemoteException {

        ResponseWrapper wrapper = interpretSML(calcTreeID,

                "getAccumulatedAsms @calcid@ " + pos.toSMLString() + ";", false);

        return (Assumptions) wrapper.getResponse();

    }

    /**

     * @see isac.util.interfaces.ICalcIterator#tryMatchProblem(KEStoreID)

     */

    public Match tryMatchProblem(int javaCalcID, ProblemID problemID) {

        ResponseWrapper wrapper = interpretSML(javaCalcID,

                "tryMatchProblem @calcid@ " + problemID.toSMLString() + ";",

                false);

        Object response = wrapper.getResponse();

        CalcHead ch = (CalcHead) response;

        //ch.setCalcTreeID(smlCalcIDtoJavaCalcID(wrapper.getCalcID()));

        Match m = new Match(ch.getSpecification().getProblem(), ch

                .getStatusString(), ch.getHeadLine(), ch.getModel());

        return m;

    }

    /**

     * @see isac.util.interfaces.ICalcIterator#tryRefineProblem(KEStoreID)

     */

    public Match tryRefineProblem(int javaCalcID, ProblemID problemID) {

        ResponseWrapper wrapper = interpretSML(javaCalcID,

                "tryRefineProblem @calcid@ " + problemID.toSMLString() + ";",

                false);

        Object response = wrapper.getResponse();

        CalcHead ch = (CalcHead) response;

        //ch.setCalcTreeID(smlCalcIDtoJavaCalcID(wrapper.getCalcID()));

        Match m = new Match(ch.getSpecification().getProblem(), ch

                .getStatusString(), ch.getHeadLine(), ch.getModel());

        return m;

    }

    /**

     * @see isac.util.interfaces.ICalcIterator#tryMatchMethod(KEStoreID)

     * @deprecated is not impl. in math-engine !!!

     */

    public Match tryMatchMethod(int javaCalcID, KEStoreID keStoreID)

            throws RemoteException {

        ResponseWrapper wrapper = interpretSML(javaCalcID,

                "tryMatchMethod @calcid@ " + keStoreID.toSMLString() + ";",

                false);

        Object response = wrapper.getResponse();

        CalcHead ch = (CalcHead) response;

        //ch.setCalcTreeID(smlCalcIDtoJavaCalcID(wrapper.getCalcID()));

        Match m = new Match(ch.getSpecification().getProblem(), ch

                .getStatusString(), ch.getHeadLine(), ch.getModel());

        return m;

    }

    /**

     * @see isac.util.interfaces.ICalcIterator#tryRefineMethod(KEStoreID)

     * @deprecated is not impl. in math-engine !!!

     */

    public Match tryRefineMethod(int javaCalcID, KEStoreID keStoreID)

            throws RemoteException {

        ResponseWrapper wrapper = interpretSML(javaCalcID,

                "tryRefineMethod @calcid@ " + keStoreID.toSMLString() + ";",

                false);

        Object response = wrapper.getResponse();

        CalcHead ch = (CalcHead) response;

        //ch.setCalcTreeID(smlCalcIDtoJavaCalcID(wrapper.getCalcID()));

        Match m = new Match(ch.getSpecification().getProblem(), ch

                .getStatusString(), ch.getHeadLine(), ch.getModel());

        return m;

    }

}