package isac.wsdialog;

 import isac.bridge.*;

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

 	/**

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

 		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;

 	}

 }