/*

 * Created on Sep 11, 2003

 * @author rgradisc

 */

package isac.bridge;

import isac.util.CalcChanged;

import isac.util.CalcChangedEvent;

import isac.util.NotInSpecificationPhaseException;

import isac.util.StartSolvingException;

import isac.util.formulae.CalcHead;

import isac.util.formulae.CalcFormula;

import isac.util.formulae.CalcHeadCompoundID;

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;

	}

	/**

	 * @see isac.util.interfaces.IToCalc#tryMatch(CalcHead, CalcHeadCompoundID)

	 * FIXXXME.WN050610 change to:       tryMatch(          CalcHeadCompoundID)

	 */

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

		}

	}

	/**

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

		}

	}

}