package isac.wsdialog;

 import isac.bridge.*;

 import isac.util.*;

 import isac.util.formulae.*;

 import isac.util.interfaces.*;

 import isac.util.tactics.*;

 import java.io.Serializable;

 import java.net.MalformedURLException;

 import java.rmi.*;

 import java.rmi.registry.LocateRegistry;

 import java.rmi.server.UnicastRemoteObject;

 import java.util.Vector;

 /* TODO:

  * 

  * * recognize CalcHead in Changed Formula -> switch to DILAOGPAHSE_SPECIFY_SUBPROBLEM

  * * differentiate CalcHeads 

  * 

  *

  */

 /**

  * The DialogGuide moderates the communication between two instances working on

  * the same CalcTree object. One of these instances is the user, the other a

  * math engine. Most probably, the user's GUI, the DialogGuide and the math

  * engine reside on different machines and communicate with each other by means

  * of RMI.

  * 

  * @author Alan Krempler

  */

 public class DialogGuide extends UnicastRemoteObject implements DGuide,

 		IToUser, Serializable {

 	protected CalcTree calc_tree_;

 	protected CalcHead calc_head_;

 	protected CalcHead calc_head_sub_;

 	protected MathEngine math_engine_;

 	protected int phase_;

 	private Vector datachange_listeners_;

 	private IToWorksheet ui_control_listener_;

 	/**

 	 * @param ME_path

 	 *            URL of the math engine to be used

 	 * @throws RemoteException

 	 */

 	public DialogGuide(String ME_path) throws RemoteException {

 		super();

 		this.rmiBind();

 		datachange_listeners_ = new Vector();

 		MathEngine.init(ME_path);

 		math_engine_ = MathEngine.getMathEngine();

 		phase_ = DIALOGPHASE_IDLE;

 	}

 	/**

 	 * at the beginning of a calculation as well as of a subproblem

 	 * 

 	 * @param calc_head

 	 *            empty (formalization stored invisibly in the calcTree)

 	 * @return calc_head with viestyle set

 	 */

 	// FIXME.WN040906 do NOT return calc_head, like Formula in solve-phase

 	// and like trymatch etc. see below

 	CalcHead startSpecifying(CalcHead calc_head) {

 		//  WN040825 if (start_from == STARTFROM_EXAMPLE) { <---startSpecifying ?

 		int calchead_view = CalcHead.VIEWSTYLE_SINGLELINE;

 		//WN040824 VIEWSTYLE_IN_CALC depends on UserModel

 		//WN040824 VIEWSTYLE_IN_CALC is appropriate for equations, not for

 		// maximumexpl

 		//WN040825 appropriate for pbl-class [univatiate,equation]

 		//WN040825 NOT -"- for maximum-expl

 		calc_head.setCalcHeadStatus(calchead_view);

 		math_engine_.completeCalcHead(calc_head);

 		phase_ = DIALOGPHASE_SPECIFY;

 		return calc_head; //WN040906 this is NOT completed !!!

 		// FIXME.WN040906 do NOT return calc_head, like Formula in solve-phase

 	}

 	// FIXME.WN040906 do NOT return calc_head, like Formula in solve-phase

 	public CalcHead startCalculation(int user_id, Formalization f,

 			int start_from, int requested_calchead_view) {

 		calc_head_ = math_engine_.startCalculation(f);

 		// for the moment, all requests for a view are honored

 		//  WN040825 calc_head_.setViewStyle(requested_calchead_view);

 		// --->startSpecifying

 		// for testing purposes: if starting an example from the collection,

 		// have everything filled in by the KI

 		//  WN040825 if (start_from == STARTFROM_EXAMPLE) { --->startSpecifying ?

 		// old-style filling the fields of the calc-head by setting

 		// the HELP_ME flag

 		// calc_head_.setCalcHeadStatus(CalcHead.CALCHEAD_HELP_ME);

 		// }

 		// test code; this protocol is now controlled by the presentation layer

 		// do {

 		// checkCalcHead()

 		// } while (false); // status != ok

 		// newCalculation(calc_head_);

 		//WN040825 phase_ = DIALOGPHASE_SPECIFY; --->startSpecifying

 		//WN040825 return calc_head_;

 		return startSpecifying(calc_head_);

 	}

 	public void newCalculation(CalcHead calcHead) {

 		try {

 			calc_tree_ = math_engine_.startSolving(calcHead);

 		} catch (Exception e) {

 			// TODO Auto-generated catch block

 			e.printStackTrace();

 		}

 		// calc_tree_ = MathEngine.getMathEngine().startSolving(calcHead);

 		calc_tree_.addDataChangeListener(this);

 		phase_ = DIALOGPHASE_SOLVE;

 	}

 	/*

 	 * (non-Javadoc)

 	 * 

 	 * @see isac.wsdialog.IToUser#calcChanged(isac.wsdialog.CalcChangedEvent)

 	 */

 	public void calcChanged(CalcChangedEvent event) {

 		ICalcElement calc_elem;

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

 			((IToUser) datachange_listeners_.elementAt(i)).calcChanged(event);

 		}

 		ICalcIterator last_formula = event.getFirstChangedFormula();

 		// while searching for last formula, mark intermediate CalcHeads as not

 		// to be edited

     try {

 		while (!last_formula.isLast()) {

 			if (last_formula.getElement().getType() == ICalcElement.CALCEL_CALCHEAD) {

 				last_formula.getElement().setViewStyle(

 						CalcHead.VIEWSTYLE_IN_CALC);

 			}

 			last_formula.moveDown();

 			//TODO last_formula.moveDown.. WN040824 DG may limit the level down

 		}

 		// for now, do not specify the CalcHead, just display it.

 		calc_elem = last_formula.getElement();

 		if (calc_elem.getType() == ICalcElement.CALCEL_CALCHEAD) {

 			//WN040826 phase_ = DIALOGPHASE_SPECIFY; --->startSpecifying

 			//WN040826

 			// calc_elem.setViewStyle(CalcHead.VIEWSTYLE_SINGLELINE);--->startSpecifying

 			//WN040826calc_head = startSpecifying((CalcHead) calc_elem);

 			// --->startSpecifying

 			startSpecifying((CalcHead) calc_elem);

 			//WN040826 math_engine_.completeCalcHead(calc_head);

 			// --->startSpecifying

 		} else {

 			phase_ = DIALOGPHASE_SOLVE;

 		}

     } catch (Exception e) {

       e.printStackTrace();

     }

 	}

 	/**

 	 * @deprecated Use {@link #notifyUserAction(IUserAction)}instead

 	 */

 	public void modifyCalcHead(CalcHead calc_head) {

 		// MathEngine.getMathEngine().modifyCalcHead(calc_head);

 		math_engine_.modifyCalcHead(calc_head);

 	}

 	/*

 	 * (non-Javadoc)

 	 * 

 	 * @see isac.wsdialog.IToCalc#iterator()

 	 */

 	public ICalcIterator iterator() {

     try {

 		return new DialogIterator((CalcIterator) calc_tree_.iterator());

     } catch (Exception e){

       e.printStackTrace();

     }

     return null;

   }

 	/*

 	 * (non-Javadoc)

 	 * 

 	 * @see isac.wsdialog.IToCalc#addListener(isac.wsdialog.IToUser)

 	 */

 	public boolean addDataChangeListener(IToUser listener) {

 		if (datachange_listeners_.contains(listener)) {

 			return false;

 		} else {

 			datachange_listeners_.add(listener);

 		}

 		return true;

 	}

 	public boolean registerUIControlListener(IToWorksheet listener) {

 		if (ui_control_listener_ != null) {

 			ui_control_listener_.doUIAction(new UserAction(UI_DO_DETACH));

 		}

 		ui_control_listener_ = listener;

 		return true;

 	}

 	public Tactic fetchProposedTactic() {

 		return calc_tree_.fetchProposedTactic();

 	}

 	public Tactic[] fetchApplicableTactics(int scope) {

 		return calc_tree_.fetchApplicableTactics(scope);

 	}

 	/**

 	 * @deprecated Use {@link #notifyUserAction(IUserAction)}instead

 	 */

 	public int setNextTactic(Tactic tactic) {

 		return calc_tree_.setNextTactic(tactic);

 	}

 	/**

 	 * @deprecated Use {@link #notifyUserAction(IUserAction)}instead

 	 */

 	public int autoCalculate(int scope, int nSteps) {

 		return calc_tree_.autoCalculate(scope, nSteps);

 	}

 	/**

 	 * @deprecated Use {@link #notifyUserAction(IUserAction)}instead

 	 */

 	public void tryMatch(CalcHead ch, CalcHeadCompoundID problemID)

 			throws NotInSpecificationPhaseException {

 		// MathEngine.getMathEngine().tryMatch(ch, problemID);

 		math_engine_.tryMatch(ch, problemID);

 	}

 	/**

 	 * @deprecated Use {@link #notifyUserAction(IUserAction)}instead

 	 */

 	public void tryRefine(CalcHead ch, CalcHeadCompoundID problemID)

 			throws NotInSpecificationPhaseException {

 		// MathEngine.getMathEngine().tryRefine(ch , problemID);

 		math_engine_.tryRefine(ch, problemID);

 	}

 	public ICalcIterator getActiveFormula() {

 		return calc_tree_.getActiveFormula();

 	}

 	/**

 	 * @deprecated Use {@link #notifyUserAction(IUserAction)}instead

 	 */

 	public int replaceFormula(Formula newFormula) {

 		return calc_tree_.replaceFormula(newFormula);

 	}

 	/**

 	 * @deprecated Use {@link #notifyUserAction(IUserAction)}instead

 	 */

 	public int appendFormula(Formula newFormula) {

 		return calc_tree_.appendFormula(newFormula);

 	}

 	/**

 	 * @deprecated Use {@link #notifyUserAction(IUserAction)}instead

 	 */

 	public void moveActiveFormula(ICalcIterator newActiveFormula) {

 		calc_tree_.moveActiveFormula(newActiveFormula);

 	}

 	/**

 	 * Notify the Dialog Guide about interaction from the User

 	 * 

 	 * @param action

 	 * @return true, if the action has been processed, false if the processing

 	 *         the action has been denied

 	 *  

 	 */

 	public boolean notifyUserAction(IUserAction action)

 			throws DialogProtocolException {

 		int request = action.getActionID();

 		switch (phase_) {

 		case DIALOGPHASE_IDLE:

 			throw new DialogProtocolException(request, phase_);

 		//case DIALOGPHASE_SPECIFY: WN040826

 		case DIALOGPHASE_SPECIFY: //_SUBPROBLEM WN040826

 			if (request < UI_DUMMY_FIRST_SPECIFY

 					|| request > UI_DUMMY_LAST_SPECIFY)

 				throw new DialogProtocolException(request, phase_);

 			break;

 		case DIALOGPHASE_SOLVE:

 			if (request < UI_DUMMY_FIRST_SOLVE || request > UI_DUMMY_LAST_SOLVE)

 				throw new DialogProtocolException(request, phase_);

 			break;

 		}

 		switch (request) {

 		case UI_SPECIFY_TRY_MATCH:

 			try {

 				tryMatch(calc_head_, ((UserActionOnCalcHeadCompoundID) action)

 						.getObjectID());

 			} catch (NotInSpecificationPhaseException e) {

 				throw new DialogMathException(request, phase_, e);

 			}

 			break;

 		case UI_SPECIFY_TRY_REFINE:

 			try {

 				tryRefine(calc_head_, ((UserActionOnCalcHeadCompoundID) action)

 						.getObjectID());

 			} catch (NotInSpecificationPhaseException e) {

 				throw new DialogMathException(request, phase_, e);

 			}

 			break;

 		case UI_SPECIFY_CHANGE_VIEW:

 			calc_head_.setViewStyle(((UserActionOnInt) action).getInt());

 			break;

 		case UI_SPECIFY_COMPLETE_CALCHEAD:

 			math_engine_.completeCalcHead(calc_head_);

 			// old-style filling the fields of the calc-head by setting

 			// the HELP_ME flag

 			// calc_head_.setCalcHeadStatus(CalcHead.CALCHEAD_HELP_ME);

 			// modifyCalcHead(calc_head_);

 			break;

 		case UI_SPECIFY_COMPLETE_METHOD:

 		case UI_SPECIFY_COMPLETE_THEORY:

 		case UI_SPECIFY_COMPLETE_PROBLEM:

 		case UI_SPECIFY_COMPLETE_GIVEN:

 		case UI_SPECIFY_COMPLETE_FIND:

 		case UI_SPECIFY_COMPLETE_RELATE:

 			throw new DialogNotImplementedException(request, phase_);

 		case UI_SPECIFY_CHECK_CALCHEAD:

 			modifyCalcHead(calc_head_);

 			break;

 		// was: newCalculation()

 		case UI_SPECIFY_CALCULATE_1:

 		case UI_SPECIFY_CALCULATE_ALL:

 			modifyCalcHead(calc_head_);

 			if (calc_head_.getCalcHeadStatus() != CalcHead.CALCHEAD_CORRECT)

 				return false;

 			try {

 				calc_tree_ = math_engine_.startSolving(calc_head_);

 			} catch (Exception e) {

 				// TODO Auto-generated catch block

 				e.printStackTrace();

 			}

 			// calc_tree_ = MathEngine.getMathEngine().startSolving(calcHead);

 			calc_tree_.addDataChangeListener(this);

 			phase_ = DIALOGPHASE_SOLVE;

 		// fall through to calculate

 		case UI_SOLVE_CALCULATE_1:

 		case UI_SOLVE_CALCULATE_ALL:

 			switch (request) {

 			case UI_SPECIFY_CALCULATE_ALL:

 			case UI_SOLVE_CALCULATE_ALL:

 				autoCalculate(SCOPE_CALCULATION, 0);

 				break;

 			case UI_SPECIFY_CALCULATE_1:

 				break;

 			default:

 				autoCalculate(SCOPE_CALCULATION, 1);

 				break;

 			}

 			break;

 		case UI_SOLVE_CALCULATE_SUBPROBLEM:

 			autoCalculate(SCOPE_SUBPROBLEM, 0);

 			break;

 		case UI_SOLVE_EDIT_ACTIVE_FORMULA:

 			ui_control_listener_.doUIAction(new UserAction(UI_DO_EDIT_FORMULA));

 			break;

 		case UI_SOLVE_EDIT_ACTIVE_FORMULA_COMPLETE:

 			replaceFormula((Formula) ((UserActionOnCalcElement) action)

 					.getCalcElement());

 			break;

 		case UI_SOLVE_APPEND_USER_FORMULA:

 			// appendFormula((Formula) ((UserActionOnCalcElement)

 			// action).getCalcElement());

 			ui_control_listener_

 					.doUIAction(new UserAction(UI_DO_APPEND_FORMULA));

 			break;

 		case UI_SOLVE_MOVE_ACTIVE_FORMULA:

 			moveActiveFormula(((UserActionOnIterator) action).getPosition());

 			break;

 		case UI_SOLVE_GET_PROPOSED_TACTIC:

 			throw new DialogNotImplementedException(request, phase_);

 		case UI_SOLVE_GET_APPLICABLE_TACTICS:

 			throw new DialogNotImplementedException(request, phase_);

 		case UI_SOLVE_SET_NEXT_TACTIC:

 			setNextTactic((Tactic) ((UserActionOnCalcElement) action)

 					.getCalcElement());

 			break;

 		case UI_SOLVE_HELP_ENTERING_FORMULA:

 			throw new DialogNotImplementedException(request, phase_);

 		case UI_SOLVE_SHOW_ASSUMPTIONS:

 			throw new DialogNotImplementedException(request, phase_);

 		case UI_SOLVE_SHOW_DETAILS:

 			throw new DialogNotImplementedException(request, phase_);

 		default:

 			throw new DialogUnknownActionException(request, phase_);

 		}

 		return true;

 	}

 	private void 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 = "//localhost/isac-DialogGuide";

 		try {

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

 			Naming.rebind(name, this);

 			System.out.println("Dialog Guide bound to " + name);

 			//WN040906      was Object Manager ...

 		} catch (java.rmi.ConnectException e) {

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

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

 		} catch (RemoteException e) {

 			// TODO Auto-generated catch block

 			e.printStackTrace();

 		} catch (MalformedURLException e) {

 			// TODO Auto-generated catch block

 			e.printStackTrace();

 		}

 	}

 	public static void main(String[] args) {

 		try {

 			new DialogGuide(args[0]);

 		} catch (RemoteException e) {

 			e.printStackTrace();

 		}

 	}

 }