/*

  * Created on Sep 11, 2003

  * @author rgradisc

  */

 package isac.bridge;

 import isac.util.CalcChanged;

 import isac.util.CalcChangedEvent;

 import isac.util.formulae.CalcHead;

 import isac.util.formulae.CalcFormula;

 import isac.util.formulae.Position;

 import isac.util.interfaces.ICalcIterator;

 import isac.util.interfaces.IToCalc;

 import isac.util.interfaces.IToUser;

 import isac.util.tactics.Tactic;

 import isac.wsdialog.DialogGuide;

 import java.io.Serializable;

 import java.rmi.RemoteException;

 import java.util.Iterator;

 import java.util.Vector;

 import org.apache.log4j.Logger;

 /**

  * A CalcTree represents a Calculation: It is a tree which consists of one

  * CalcHead at the top and abitrarily many Formulas and SubCalculations (with

  * separate CalcHeads). This is the main interface between the Bridge and the

  * Dialog. The CalcTree calls methods of the Math Engine, which in turn are

  * delegated to the BridgeRMI object on the other side of the RMI connection

  * ??????WN0409. The communication with the SML Kernel is completly hided from

  * the Dialog and the Frontend.

  * 

  * @author Richard Gradischnegg

  */

 public class CalcTree implements IToCalc, Serializable {

 	private int id_;

 	private Vector listeners_;

 	private MathEngine mathEngine_;

 	private ICalcIterator hot_spot_;//WN040924 ..delete: control hotSpot --> DG

 	private IBridgeRMI bridgeRMI_;//WN040924 added for completeCalcHead & Co.

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

 	/**

 	 * Start a new calculation. In case of failure, the constructor may change

 	 * the formalization object to hint at incomplete or contradictory

 	 * specifications. <br>

 	 * Only complete calcHeads should be passed. <br>

 	 * Check every CalcHead for completeness (with the static method

 	 * checkcalcHead() before constructing a CalcTree ..TODO WN040824 shift to

 	 * authoring-tools

 	 * 

 	 * @param identification

 	 *            for the CalcTree as delivered by the SML-kernel

 	 */

 	CalcTree(MathEngine me, int id) {

 		this.id_ = id;

 		this.mathEngine_ = me;

 		this.bridgeRMI_ = me.getBridgeRMI();//WN040924

 		listeners_ = new Vector();

 	}

 	/**

 	 * Attach another dialog to the existing calculation tree.

 	 * 

 	 * @param dlg

 	 *            The new Dialog to be attached to this CalcTree

 	 */

 	public void attach(DialogGuide dg) {

 		listeners_.add(dg);

 	}

 	/**

 	 * Get a new iterator referencing the root element of the calculation tree.

 	 * <p>

 	 * The functionality for navigating the calculation is implemented in the

 	 * CalcIterator object.

 	 * 

 	 * @return new instance of CalcIterator

 	 */

 	public ICalcIterator iterator() {

 		return new CalcIterator(this);

 	}

 	/**

 	 * Makes the passed formula the active formula, i.e. the formula the next

 	 * tactic is applied to.

 	 * 

 	 * @param newActiveFormula

 	 */

 	public void moveActiveFormula(ICalcIterator cit) {

 		try {

 			Position p = mathEngine_.moveActiveFormula(id_, cit.getPosition());

 			//			if (p == null)//WN0412 message ?!

 			//				return false;

 			//			else

 			//				return true;

 		} catch (RemoteException e) {

 			// TODO Auto-generated catch block

 			e.printStackTrace();

 		}

 	}

 	/**

 	 * WN040924 copied + updated from MathEngine

 	 * 

 	 * @see isac.util.interfaces.IToCalc#startSolving()

 	 */

 	public void startSolving() throws Exception {

 		// TODO Auto-generated method stub

 	}

 	/*

 	 * @see isac.util.interfaces.IToCalc#startSolving(isac.util.formulae.CalcHead)

 	 *      WN040924 copied + updated from MathEngine

 	 * 

 	 * public void startSolving() throws Exception {

 	 * logger.warn("startSolving"); 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; }

 	 */

 	/*

 	 * TODO WN040924 redesign COMPLETE_PROBLEM, COMPLETE_GIVEN ... public static

 	 * final int COMPLETE_METHOD = 1; public static final int COMPLETE_THEORY =

 	 * 2; public static final int COMPLETE_PROBLEM = 3; public static final int

 	 * COMPLETE_GIVEN = 4; public static final int COMPLETE_FIND = 5; public

 	 * static final int COMPLETE_RELATE = 6; //FIXME WN040820 complete a

 	 * particular model-item is not included into this design

 	 */

 	/**

 	 * @see isac.util.interfaces.IToCalc#modifyCalcHead(isac.util.formulae.CalcHead)

 	 */

 	public void modifyCalcHead(CalcHead calcHead) {

 		logger_.fatal(" DG->BR: modifyCalcHead(" + calcHead.toSMLString());

 		CalcHead newCalcHead = null;

 		try {

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

 			bridgeRMI_.modifyCalcHead(calcHead);

 			//WN040924 calcHead.fillValuesfrom(newCalcHead);

 		} catch (RemoteException e) {

 			e.printStackTrace();

 		}

 	}

 	/**

 	 * @see isac.util.interfaces.IToCalc#completeCalcHead(isac.util.formulae.CalcHead)

 	 */

 	public void completeCalcHead() {

 		logger_.fatal(" DG->BR: completeCalcHead()");

 		try {

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

 			bridgeRMI_.completeCalcHead(this.id_);

 			//WN040924 calcHead.fillValuesfrom(newCalcHead);

 		} catch (RemoteException e) {

 			e.printStackTrace();

 		}

 	}

 	/**

 	 * @see isac.util.interfaces.IToCalc#completeCalcHead(isac.util.formulae.CalcHead,

 	 *      int)

 	 * @param calcHead

 	 *            eventually updated by the user

 	 * @param completeItem

 	 *            requested by the DialogGuide

 	 * 

 	 * WN040924 copied from MathEngine

 	 */

 	public void completeCalcHead(CalcHead calcHead, int completeItem) {

 		CalcHead newCalcHead;

 		try {

 			//WN040924 newCalcHead = bridgeRMI.completeCalcHead(calcHead,

 			// completeItem);

 			bridgeRMI_.completeCalcHead(this.id_, calcHead, completeItem);

 			//WN040924 calcHead.fillValuesfrom(newCalcHead);

 			//TODO: Remove the following line!!

 			calcHead.setCalcHeadStatus(CalcHead.CALCHEAD_CORRECT);

 		} catch (RemoteException e) {

 			e.printStackTrace();

 		}

 	}

 	/**

 	 * Calculate the next n steps starting from the active formula. The Tactic

 	 * to be applied in this step may be preset by setNextTactic

 	 * 

 	 * @param scope

 	 *            The scope parameter can have following values:

 	 *            <ul>

 	 *            <li>Stay in the current subproblem

 	 *            <li>Stay in the current subcalculation (e.g. repetitions)

 	 *            <li>Stay in the current calculation as a whole.

 	 *            </ul>

 	 *            Constants for this scopes are found in the IToCalc class

 	 * @param nSteps

 	 *            Specifies the count of steps to be autocalculated. Passing 0

 	 *            for nSteps will calculate until reaching a final result.

 	 * @return The method returns an unique id to identify the request when

 	 *         notifying about updates in the tree.

 	 */

 	public int autoCalculate(int scope, int nSteps) {

 		logger_.fatal(" DG->BR: autoCalculate(" + scope + ", " + nSteps + ")");

 		CalcChanged cc;

 		int transactionID = -1;

 		try {

 			cc = mathEngine_.autoCalculate(this.id_, scope, nSteps);

 			if (!(cc == null)) {

 				hot_spot_ = new CalcIterator(this, cc.getLastGenerated());

 				transactionID = generateTransactionID();

 				informListeners(new CalcIterator(this, cc.getLastUnchanged()),

 						new CalcIterator(this, cc.getLastDeleted()),

 						new CalcIterator(this, cc.getLastGenerated()),

 						transactionID);

 			}

 		} catch (RemoteException e) {

 			e.printStackTrace();

 		}

 		return transactionID;

 	}

 	/**

 	 * Tries to replaces the active formula in the calculation tree by the

 	 * passed formula. This could fail if no valid derivation from the preceding

 	 * formula to the (new) active formula can be found.

 	 * <p>

 	 * Parts of the calculation after the replaced formula are likely to become

 	 * invalid, listeners will be informed of this with the update message,

 	 * which contains the last unchanged formula.

 	 * 

 	 * @param newFormula

 	 * @return The method will return 0 on success or a nonzero value indicating

 	 *         the status otherwise.

 	 */

 	public int replaceFormula(CalcFormula f) throws RemoteException {

 		logger_.fatal(" DG->BR: replaceFormula(" + f.toSMLString() + ")");

 		CalcChanged cc;

 		int transactionID = -1;

 		try {

 			cc = mathEngine_.replaceFormula(this.id_, f);

 			if (!(cc == null)) {

 				hot_spot_ = new CalcIterator(this, cc.getLastGenerated());

 				transactionID = generateTransactionID();

 				informListeners(new CalcIterator(this, cc.getLastUnchanged()),

 						new CalcIterator(this, cc.getLastDeleted()),

 						new CalcIterator(this, cc.getLastGenerated()),

 						transactionID);

 			}

 		} catch (RemoteException e) {

 			e.printStackTrace();

 		}

 		return 0;

 	}

 	/**

 	 * Tries to append the passed formula after the active formula. This could

 	 * fail if no valid derivation from the preceding formula to the (new)

 	 * active formula can be found. The method will fail as well if the active

 	 * formula is not the last formula in the (sub)calculation. Parts of the

 	 * calculation might become invalid.

 	 * 

 	 * @param newFormula

 	 * @return The method will return 0 on success or a nonzero value indicating

 	 *         the status otherwise.

 	 */

 	public int appendFormula(CalcFormula f) throws RemoteException {

 		logger_.fatal(" DG->BR: appendFormula(" + f.toSMLString() + ")");

 		CalcChanged cc;

 		int transactionID = -1;

 		try {

 			cc = mathEngine_.appendFormula(this.id_, f);

 			if (!(cc == null)) {

 				hot_spot_ = new CalcIterator(this, cc.getLastGenerated());

 				transactionID = generateTransactionID();

 				informListeners(new CalcIterator(this, cc.getLastUnchanged()),

 						new CalcIterator(this, cc.getLastDeleted()),

 						new CalcIterator(this, cc.getLastGenerated()),

 						transactionID);

 			}

 		} catch (RemoteException e) {

 			e.printStackTrace();

 		}

 		return 0;

 	}

 	/**

 	 * Set a tactic for usage by autocalculate.

 	 * 

 	 * @param tactic

 	 *            the Tactic to be used in the the next step

 	 * @return The return value indicates success, failure or probable success

 	 *         at a later time.

 	 */

 	public int setNextTactic(Tactic tactic) {

 		logger_.fatal(" DG->BR: setNextTactic(" + tactic.toSMLString() + ")");

 		int result = -1;

 		try {

 			result = mathEngine_.setNextTactic(this.id_, tactic);

 			if (result == 0) {

 				hot_spot_.moveDown(); // move to the new formula/calcHead

 				// FIXXXME

 				informListeners((ICalcIterator) hot_spot_.clone(),

 				// FIXXXME: nothing changed, but if outcommented: subpbl shows

 						// Add_Given etc. ... discuss with LK !

 						(ICalcIterator) hot_spot_.clone(),

 						(ICalcIterator) hot_spot_.clone(),

 						generateTransactionID());

 			}

 		} catch (RemoteException e) {

 			// TODO Auto-generated catch block

 			e.printStackTrace();

 		}

 		return -1;

 	}

 //	public int setNextTactic(Tactic tactic) {

 //		logger_.fatal(" DG->BR: setNextTactic(" + tactic.toSMLString() + ")");

 //		int result = -1;

 //		ICalcIterator it;

 //		try {

 //			result = mathEngine_.setNextTactic(this.id_, tactic);

 //			//^^^^ should be CalcChanged !

 //			if (result == 0) {

 //				//hack before @@@ autoCalculate --->

 //				//               isac.wsdialog.DialogGuide#notifyUserAction

 //				//works only if nothing is deleted by use in <Next Step>

 //				it = (ICalcIterator) hot_spot_.clone();

 //				hot_spot_.moveDown();

 //				informListeners((ICalcIterator) it, it,//thus deleted nodes

 //													   // are not reported !!!

 //						(ICalcIterator) hot_spot_.clone(),

 //						generateTransactionID());

 //			}

 //		} catch (RemoteException e) {

 //			// TODO Auto-generated catch block

 //			e.printStackTrace();

 //		}

 //		return -1;

 //	}

 	/**

 	 * Retrieve the tactic proposed by the SML-Kernel for the next step in the

 	 * calculation.

 	 * 

 	 * @return proposed tactic. Can be null, if the kernel does not know what to

 	 *         do next, or if the end of the calculation is reached

 	 */

 	public Tactic fetchProposedTactic() {

 		logger_.fatal(" DG->BR: fetchProposedTactic()");

 		try {

 			Tactic tac = mathEngine_.fetchProposedTactic(this.id_);

 			logger_.fatal(" DG<-BR: fetchProposedTactic <- "+tac.toSMLString());

 			return tac;

 		} catch (RemoteException e) {

 			// TODO Auto-generated catch block

 			e.printStackTrace();

 		}

 		logger_.fatal(" DG<-BR: fetchProposedTactic <- NULL helpless");

 		return null;

 	}

 	/**

 	 * Get a list of tactics applicable to the active formula.

 	 * 

 	 * @param scope

 	 *            The filter parameter selects the scope of search for

 	 *            applicable tactics: all tactics / all tactics from the current

 	 *            theory / all tactics from the (calculation) method being

 	 *            applied.

 	 * @return Array with applyable tactics

 	 */

 	public Tactic[] fetchApplicableTactics(int scope) {

 		logger_.fatal(" DG->BR: fetchApplicableTactics(" + scope + ")");

 		Tactic[] result = null;

 		try {

 			result = mathEngine_.fetchAppliableTactics(this.id_, scope);

 		} catch (RemoteException e) {

 			// TODO Auto-generated catch block

 			e.printStackTrace();

 		}

 		return result;

 	}

 	/**

 	 * Add a Listener to this CalcTree. Listeners will be informed about any

 	 * changes in the CalcTree.

 	 * 

 	 * @param listener

 	 *            the new Listener, has to implement the interface IToUser

 	 * @return true, if the listener has been added successfully

 	 */

 	public boolean addDataChangeListener(IToUser listener) {

 		logger_.fatal(" DG->BR: addDataChangeListener(" + listener + ")");

 		if (listeners_.contains(listener)) {

 			return false;

 		} else {

 			listeners_.add(listener);

 		}

 		return true;

 	}

 	/**

 	 * Retrieve the active formula in a CalcTree. This is the formula form where

 	 * the calculation will continue.

 	 * 

 	 * @return Iterator that marks the currently active formula

 	 */

 	public ICalcIterator getActiveFormula() {

 		logger_.fatal(" DG<>BR: getActiveFormula <- "+hot_spot_.toSMLString());

 		return (ICalcIterator) hot_spot_.clone();

 	}

 	/**

 	 * Destruct this CalcTree: the sml-Representation of the CalcTree is

 	 * disposed, the id can be used for a new CalcTree

 	 * 

 	 * @return boolean value: success of operation (complete/failed) TODO

 	 *         WN040824 call mathEngine.destruct when WS is closed TODO WN040824

 	 *         call mathEngine.destruct when session is closed

 	 */

 	public boolean destruct() {

 		try {

 			return mathEngine_.destruct(this.id_);

 		} catch (RemoteException e) {

 			// TODO Auto-generated catch block

 			e.printStackTrace();

 		}

 		return false;

 	}

 	// send an update event to the registered listeners

 	private void informListeners(ICalcIterator lastUnchangedFormula,

 			ICalcIterator lastDeletedFormula,

 			ICalcIterator lastGeneratedFormula, int transactionID)

 			throws RemoteException {

 		logger_.fatal(" . . <-BR: informListeners (unc="

 				+ lastUnchangedFormula.toSMLString() + ", del="

 				+ lastDeletedFormula.toSMLString() + ", gen="

 				+ lastGeneratedFormula.toSMLString());

 		Iterator listn_it = listeners_.iterator();

 		//DialogGuide dg;

 		IToUser dg;

 		CalcChangedEvent e = new CalcChangedEvent(transactionID, true, // completed

 				lastUnchangedFormula, lastDeletedFormula, lastGeneratedFormula);

 		while (listn_it.hasNext()) {

 			dg = (IToUser) listn_it.next();

 			dg.calcChanged(e);

 		}

 	}

 	MathEngine getMathEngine() {

 		return mathEngine_;

 	}

 	public int getId() {

 		return id_;

 	}

 	// Special iterator hotSpot: marks the currently active formula of

 	// the calcTree

 	void setHotSpot(ICalcIterator iterator) {

 		hot_spot_ = iterator;

 	}

 	//WN0411 reminiscence to Dinopolis, drop it !?

 	private int generateTransactionID() {

 		return (int) (Math.random() * 0xFFFF);

 	}

 	/* (non-Javadoc)

 	 * @see isac.util.interfaces.IToCalc#intermediateSteps()

 	 */

 	public int intermediateSteps() throws RemoteException {

 		// TODO Auto-generated method stub

 		return 0;

 	}

 }