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_

   * @return 

   */

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

 }

  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

    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;

			}

    }

  /**

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

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

  }

  /* (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("Object Manager bound to " + name);

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

    }

  }

}