/*

  * Created on Sep 11, 2003

  * @author rgradisc

  */

 package isac.bridge;

 import isac.util.CalcChanged;

 import isac.util.CalcChangedEvent;

 import isac.util.StartSolvingException;

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

 		}

 	}

 	/**

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

 	 */

 	public void startSolving() throws Exception {

 		Tactic tac = this.fetchProposedTactic();

 		if (tac.getName().compareTo("Apply_Method") == 0)

 			this.autoCalculate(IToCalc.SCOPE_CALCULATION, 1);

 		else

 			new StartSolvingException (tac);

 	}

 	/**

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

 	 * WN050429 

 	 */

 	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.MODEL_ITEM_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.

 	 * 

 	 * WN0504 see differences to this method completely done by RG !

 	 */

 	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;

 	}

 	/**

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

 	 */

 	public int intermediateSteps(ICalcIterator ci) throws RemoteException {

 		logger_.fatal("  DG->BR: intermediateSteps(" + ci.toSMLString() + ")");

 		CalcChanged cc;

 		int transactionID = -1;

 		try {

 			cc = mathEngine_.intermediateSteps(this.id_, ci);

 			if (!(cc == null)) {

 				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 !?

 	//WN0501 ... _NO_: ... = return-value of autoCalculate,etc. =

 	// = CalcChangedEvent.transaction_id_

 	private int generateTransactionID() {

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

 	}

 	/*

 	 * (non-Javadoc)

 	 * 

 	 * @see isac.util.interfaces.IToCalc#getElementsFromTo(isac.util.interfaces.ICalcIterator,

 	 *      isac.util.interfaces.ICalcIterator, java.lang.Integer, boolean)

 	 */

 	public Vector getElementsFromTo(ICalcIterator iterator_from,

 			ICalcIterator iterator_to, Integer level,

 			boolean result_includes_tactics) throws RemoteException {

 		logger_.fatal("  DG->BR: getElementsFromTo("

 				+ iterator_from.toSMLString() + ", "

 				+ iterator_to.toSMLString() + level + ")");

 		try {

 			return mathEngine_.getElementsFromTo(this.id_, iterator_from,

 					iterator_to, level, result_includes_tactics);

 		} catch (RemoteException e) {

 			e.printStackTrace();

 		}

 		return null;

 	}

 }