package isac.wsdialog;

import isac.bridge.*;

import isac.session.SDialog;

import isac.util.*;

import isac.util.formulae.*;

import isac.util.interfaces.*;

import isac.util.tactics.*;

import isac.util.usersettings.UserSettings;

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;

import org.apache.log4j.Logger;

/**

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

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

	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_;

	protected UserSettings user_settings_;

  protected SDialog session_dialog_;

  protected String session_id_;

	/**

	 * @param ME_path

	 *            URL of the math engine to be used

	 * @throws RemoteException

	 */

	public DialogGuide(String ME_path, SDialog session_dialog, String session_id) throws RemoteException {

		super();

		this.rmiBind();

		datachange_listeners_ = new Vector();

		MathEngine.init(ME_path);

		math_engine_ = MathEngine.getMathEngine();

		phase_ = DIALOGPHASE_IDLE;

    session_dialog_ = session_dialog;

    session_id_ = session_id;

	}

	/**

	 * 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) {

		int calchead_view;

		String setting_value;

		// set viewstyle according to user settings

		// dummy return of getValue() call until class is completed

		// setting_value = user_settings_.getValue("DefaultCalcHeadView");

		setting_value = null;

		if (setting_value == null)

			calchead_view = CalcHead.VIEWSTYLE_SINGLELINE;

		else

			calchead_view = Integer.parseInt(setting_value);

		calc_head.setViewStyle(calchead_view);

		phase_ = DIALOGPHASE_SPECIFY;

		//		 dummy return of getValue() call until class is completed

		// if (user_settings_.getValue("SkipSpecifyingPhase").equals("1")) {

		if (true) {

			calc_tree_.completeCalcHead();

			try {

				notifyUserAction(new UserAction(

						IUIElement.UI_SPECIFY_CALCULATE_1));

			} catch (RemoteException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			} catch (DialogProtocolException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

		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 CalcTree startCalculation(int user_id, Formalization f,

			int start_from, int requested_calchead_view) {

		ICalcIterator temp_iterator;

		calc_tree_ = math_engine_.startCalculation(f);

		temp_iterator = calc_tree_.iterator();

		try {

			temp_iterator.moveRoot();

			startSpecifying((CalcHead) temp_iterator.getFormula());

		} catch (RemoteException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		// AK removed duplicate completeCalcHead() call 20050222

		// the correct call is in startCalculation()

		// calc_tree_.completeCalcHead();

		// 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_);

		phase_ = DIALOGPHASE_SPECIFY;

		//WN040825 return calc_head_;

		return calc_tree_;

	}

	public void newCalculation(CalcHead calcHead) {

		try {

			calc_tree_.startSolving();

		} catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

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

		calc_tree_.addDataChangeListener(this);

		phase_ = DIALOGPHASE_SOLVE;//WN041122 nein ???!!!???

	}

	/*

	 * (non-Javadoc)

	 * 

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

	 */

	public void calcChanged(CalcChangedEvent event) throws RemoteException {

		logger_.fatal(" WS<-. . : calcChanged (unc="

				+ event.getLastUnchangedFormula().toSMLString() + ", del="

				+ event.getLastDeletedFormula().toSMLString() + ", gen="

				+ event.getLastGeneratedFormula().toSMLString());

		ICalcElement calc_elem;

		try {

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

		calc_tree_.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;

	}

	/**

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

	 */

	public boolean addDataChangeListener(IToUser listener)

			throws RemoteException {

		if (datachange_listeners_.contains(listener)) {

			return false;

		} else {

			datachange_listeners_.add(listener);

		}

		return true;

	}

	public boolean registerUIControlListener(IToWorksheet listener)

			throws RemoteException {

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

	}

	/**

	 * @throws RemoteException

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

	 */

	public int replaceFormula(CalcFormula newFormula) throws RemoteException {

		return calc_tree_.replaceFormula(newFormula);

	}

	/**

	 * @throws RemoteException

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

	 */

	public int appendFormula(CalcFormula newFormula) throws RemoteException {

		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

	 * @throws RemoteException

	 *  

	 */

	public boolean notifyUserAction(IUserAction action)

			throws DialogProtocolException, RemoteException {

		int request = action.getActionID();

		logger_.fatal(" WS->DG: notifyUserAction request= " + request);

		//*********** set and check DIALOGPHASE *******************

		// two userActions dont care about the dialogphase

		switch (request) {

		case (UI_CALCULATE_1):

			if (getActiveFormula().onCalcHead()) {

				request = UI_SPECIFY_CALCULATE_1;

				phase_ = DIALOGPHASE_SPECIFY;

			} else {

				request = UI_SOLVE_CALCULATE_1;

				phase_ = DIALOGPHASE_SOLVE;

			}

			break;

		case (UI_CALCULATE_ALL):

			if (getActiveFormula().onCalcHead()) {

				request = UI_SPECIFY_CALCULATE_ALL;

				phase_ = DIALOGPHASE_SPECIFY;

			} else {

				request = UI_SOLVE_CALCULATE_ALL;

				phase_ = DIALOGPHASE_SOLVE;

			}

		}

		// al other userActions belong to a certain dialogphase

		switch (phase_) {

		case DIALOGPHASE_IDLE:

			throw new DialogProtocolException(request, phase_);

		case DIALOGPHASE_SPECIFY:

			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;

		}

		//*********** handle IUserAction's **********************

		CalcHead calc_head = new CalcHead();//?WN0502023?????????

		try {

			calc_head = (CalcHead) calc_tree_.iterator().getFormula();

		} catch (Exception e) {

			e.printStackTrace();

		}

		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:

			calc_tree_.completeCalcHead();

			// 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_.startSolving();

			} catch (Exception e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

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

			calc_tree_.addDataChangeListener(this);

			//if (user_settings_.getValue(""))

			calc_tree_.completeCalcHead();

			//@@@@@@@WN050223

			phase_ = DIALOGPHASE_SOLVE;

		// fall through to calculate

		case UI_SOLVE_CALCULATE_1:

		//why not at (*) here ?

		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);//why not at (*) above ?

				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:

			CalcFormula formula = (CalcFormula) ((UserActionOnCalcElement) action)

					.getCalcElement();

			// if the position is null, the formula did not exist, so we try to

			// append a new formula

			if (formula.getPosition() == null) {

				appendFormula(formula);

			} else {

				replaceFormula(formula);

			}

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

			//WN041126 extracted from isac.bridge.CalcTree#setNextTactic @@@

			//autoCalculate(SCOPE_CALCULATION, 1);

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

//		}

//	}

	/*

	 * (non-Javadoc)

	 * 

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

	 */

	public void startSolving() throws Exception {

		// TODO Auto-generated method stub

	}

	/*

	 * (non-Javadoc)

	 * 

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

	 */

	public void completeCalcHead(CalcHead calcHead) {

		// TODO Auto-generated method stub

	}

	/*

	 * (non-Javadoc)

	 * 

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

	 *      int)

	 */

	public void completeCalcHead(CalcHead calcHead, int completeItem) {

		// TODO Auto-generated method stub

	}

	/*

	 * (non-Javadoc)

	 * 

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

	 */

	public void completeCalcHead() throws RemoteException {

		// TODO Auto-generated method stub WN050223

	}

	/**

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

	 * 

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

	 */

	public int intermediateSteps(ICalcIterator i) throws RemoteException {

		// TODO Auto-generated method stub

		return 0;

	}

	/*

	 * (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 {

		// TODO Auto-generated method stub

		return null;

	}

}