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;

import org.apache.log4j.Logger;

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

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

	/**

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

		calc_tree_.completeCalcHead();

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

			int start_from, int requested_calchead_view) {

    calc_tree_ = math_engine_.startCalculation(f);

    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<-DG: 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) {

		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(Formula newFormula) throws RemoteException {

		return calc_tree_.replaceFormula(newFormula);

	}

	/**

	 * @throws RemoteException

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

	 */

	public int appendFormula(Formula 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);

		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;

		}

    CalcHead calc_head = new CalcHead();

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

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

			//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

  }

}