//****************************************************************
//	TRABAJO ISBC : INTEGRACION JAVA-JESS. CASO DEL ELEVADOR	
//****************************************************************
//
//	Fichero:	Controlador.java
//	Autor:
//	Modificado por:	Daniel Urieta Lopez
//    David Portolés: 22/11/2001
//      Modificado constructor sin el numero de pisos. Tomara el
//       valor de Edificio.MAX_NUM_PISOS
//	Proposito:	Contiene la clase Controlador que contiene la
//			logica de movimiento del ascensor las solicitudes
//			y el piso en el que se encuentra.
//
//****************************************************************

import Direccion;
import java.io.*;
import jess.*;
import ISBC_JESS.*;

public class Controlador {
  final int max_iteraciones=5;
  static int iteraciones=0;
  public static ReteISBC r;

  Visualizar VD;
  TextAreaOutputStream wr;

  public Controlador(Visualizar vdis) {
  	String frase;
    
	  VD = vdis;
	  r = new ReteISBC(VD.display());
    r.setVerbose(false);

    frase = new String("(assert (ultimo-piso " + Integer.toString(Edificio.MAX_NUM_PISOS) + "))");
  	try	{
	  	r.executeCommand(frase);
  	} catch (ReteException ret) {
	  	System.err.println("Error: Assert de ultimo-piso no realizado.");
  	}

    try {
      r.cargaReglas("./test.clp");
      r.cargaReglas("./reglas.clp");
    } catch (Exception ex) {
      System.err.println("Error Controlador: Imposible cargar los ficheros de reglas");
      ex.printStackTrace();
    }

   	VD.setVisible(true);
  }

  public synchronized boolean InsertaPersona(int ident,int or,int de,int est) {
  	String frase1,frase2;

	  frase1 = new String("(assert (persona (id " + Integer.toString(ident) +
				 ") (origen " + Integer.toString(or) + ") (destino " +
				Integer.toString(de) + ") (estado " + Integer.toString(est) +
				")))");

  	try	{
	  	r.executeCommand(frase1);
    }	catch (ReteException ret)	{
  		System.err.println("Error: no se puede insertar persona en Rete.");
	  	ret.printStackTrace(VD.display().stderr());
		  return false;
  	}
	  return true;
  }

  public synchronized boolean ModificaPersona(int ident,int nuevo) {
  	String frase1,frase2;

	  frase1 = new String("(defrule modifica-persona" +
					"  ?pers <- (persona (id " + Integer.toString(ident) + "))" +
					"  =>" +
					"  (modify ?pers (estado " +  Integer.toString(nuevo) + ")))");
  	try {
  		r.executeCommandAndRun1(frase1);
		  r.executeCommand("(undefrule modifica-persona)");
   	}	catch (ReteException ret)	{
  		System.err.println("Error: no se puede modificar persona en Rete.");
	  	ret.printStackTrace(VD.display().stderr());
  		return false;
	  }
  	return true;
  }

  public synchronized boolean EliminaPersona(int ident) {
  	String frase1,frase2;

	  //-------------------------------------
  	//Elimino el hecho de persona.
	  //-------------------------------------
  	frase1 = new String("(defrule elimina-persona " +
				"  ?pers <- (persona (id " + Integer.toString(ident) + "))" +
					"  =>" +
					"  (retract ?pers)))");
  	if (r.getVerbose()) {System.err.println(frase1);}
	  try {
  		r.executeCommandAndRun1(frase1);
		  r.executeCommand("(undefrule elimina-persona)");
    } catch (ReteException ret)	{
  		System.err.println("Error: no se puede eliminar persona en Rete.");
	  	ret.printStackTrace(VD.display().stderr());
		  return false;
  	}
  	return true;
  }

  public synchronized boolean RelacionaPersonaAscensor(int id_elevador, int id_pasajero)
  {
	String frase1;
	//-------------------------------------
	//Inserto relacion de persona ascensor.
	//-------------------------------------
	frase1 = new String("(assert (lleva-a (id-asc " + Integer.toString(id_elevador) +
				") (id-per " + Integer.toString(id_pasajero) + ")))");
	try	{
		r.executeCommand(frase1);
 	}	catch (ReteException ret)	{
		System.err.println("Error: no se puede relacionar persona en Rete.");
		ret.printStackTrace(VD.display().stderr());
		return false;
	}
	return true;
  }


  public synchronized boolean InsertaAscensor(int ident,int piso,int dir,int dir_p,int est)
  {
	String frase1,frase2;

	//-------------------------------------------
	//Inserto el hecho del Ascensor.
	//-------------------------------------------
	frase1 = new String("(assert (elevador (id " + Integer.toString(ident) +
				 ") (piso-actual " + Integer.toString(piso) + ") (direccion " +
				Integer.toString(dir) + ") (direccion-programada " +
				Integer.toString(dir_p) + ") (estado " + Integer.toString(est) +
				")))");
	try {
		r.executeCommand(frase1);
  } catch (ReteException ret)	{
		System.err.println("Error: no se puede insertar ascensor en Rete.");
		ret.printStackTrace(VD.display().stderr());
		return false;
	}
	return true;
  }

  public synchronized boolean ModificaAscensor(int ident,int piso,int dir,int dir_p,int est)
  {
	String frase1,frase2,frase3,frase4,frase5,frasen;

	//-----------------------------------------------
	//Modifico el hecho con una regla de modificacion.
	//-----------------------------------------------
	frase1 = new String("(defrule modifica-elevador" +
					"  ?elev <- (elevador (id " + Integer.toString(ident) + "))" +
					"  =>" +
					"  (modify ?elev");
	if (piso > -1)	{
		frase2 = new String(" (piso-actual " +  Integer.toString(piso) + ")");
		frase1 = frase1 + frase2;
  }
  if (dir > -1)	{
		frase3 = new String(" (direccion " + Integer.toString(dir) + ")");
		frase1 = frase1 + frase3;
  }
	if (dir_p > -1)	{
		frase4 = new String(" (direccion-programada " +  Integer.toString(dir_p) + ")");
		frase1 = frase1 + frase4;
	}
	if (est > -1) {
		frase5 = new String(" (estado " + Integer.toString(est) + ")");
		frase1 = frase1 + frase5;
	}
	frasen = new String("))");
	frase1 = frase1 + frasen;
	try {
		r.executeCommandAndRun1(frase1);
		r.executeCommand("(undefrule modifica-elevador)");
  } catch (ReteException ret) {
		System.err.println("Error: no se puede modificar ascensor en Rete.");
		ret.printStackTrace(VD.display().stderr());
		return false;
	}
	return true;
  }

//*********************************************************************
//********                DEBE PARAR ASCENSOR              ************
//*********************************************************************

//*****Dispara las reglas activadas y obtiene los valores que deciden la
//***** parada del ascensor segun diferentes criterios.

  public synchronized boolean DebePararAscensor(Ascensor A)
  {
  Value valor,valordirp;
  int entero,enterodirp;
  String frase1;
  //*******************************************************************
  // Hago run para disparar las reglas de la logica del ascensor.
  try {
		r.executeCommand("(assert (evaluar-parada))");
		r.executeCommand("(run)");
  } catch (ReteException ret) {
		System.err.println("Error: Marca de parada y disparo de reglas.");
		ret.printStackTrace(VD.display().stderr());
		return false;
	}
	// quitar marca
	frase1 = new String("(defrule quita-marca-parada" +
					"  ?marca <- (evaluar-parada)" +
					"  =>" +
					"  (retract ?marca))");
	try	{
		r.executeCommandAndRun1(frase1);
		r.executeCommand("(undefrule quita-marca-parada)");
  }	catch (ReteException ret)	{
		System.err.println("Error: Eliminacion de marca de parada.");
		ret.printStackTrace(VD.display().stderr());
		return false;
	}
  //*******************************************************************
  // Extraigo los valores que interesan para parar el ascensor.
	valor = null;
	try	{
		valor = r.store("parar",new Value(0, RU.INTEGER));
	} catch (ReteException ret)	{
		System.err.println("Error: Obtencion de valor de parada.");
		ret.printStackTrace(VD.display().stderr());
		return false;
	}

	valordirp = null;
	try	{
		valordirp = r.store("dirp",new Value(-1, RU.INTEGER));
	} catch (ReteException ret)	{
		System.err.println("Error: Obtencion de valor de direccion en parada.");
		ret.printStackTrace(VD.display().stderr());
		return false;
	}
  //*******************************************************************
  // Evaluo la parada y el cambio de la direccion programada.
	if (valor != null){
    try {
			entero = valor.intValue();
		} catch (ReteException ret) {
			System.err.println("Error: Transformacion de valor de parada.");
			ret.printStackTrace(VD.display().stderr());
			return false;
		}
		if (entero > 0) {
			A.SetDireccionProgramada(A.GetDireccionActual());
			A.SetDireccionActual(Direccion.STOP);
		}
	}

	if (valordirp != null) {
    try {
			enterodirp = valordirp.intValue();
		} catch (ReteException ret)	{
			System.err.println("Error: Transformacion de direccion en parada.");
			ret.printStackTrace(VD.display().stderr());
			return false;
		}
		if (enterodirp >= 0) {
			if (enterodirp == 0) {
				A.SetDireccionProgramada(Direccion.UP);
			} else if (enterodirp == 1) {
					A.SetDireccionProgramada(Direccion.DOWN);
			}
		}
	}
	return true;
  }
//*********************************************************************
//********          ESTABLECER SIGUIENTE DIRECCION         ************
//*********************************************************************

//*****Dispara las reglas activadas y obtiene los valores que modifican
//***** las direcciones (actual y programada).

  public synchronized boolean EstablecerSiguienteDireccion(Ascensor A)
  {
  Value valordir,valordirp;
  int enterodir,enterodirp;
  String frase1;
  //*******************************************************************
  // Hago run para disparar las reglas de la logica del ascensor
  try {
		r.executeCommand("(assert (evaluar-direccion))");
		r.executeCommand("(run)");
  } catch (ReteException ret) {
		System.err.println("Error: Marca de direccion y disparo de reglas.");
		ret.printStackTrace(VD.display().stderr());
		return false;
	}
	// quitar marca
	frase1 = new String("(defrule quita-marca-direccion" +
					"  ?marca <- (evaluar-direccion)" +
					"  =>" +
					"  (retract ?marca))");
	try {
		r.executeCommand(frase1);
		r.executeCommand("(run 1)");
		r.executeCommand("(undefrule quita-marca-direccion)");
  } catch (ReteException ret)	{
		System.err.println("Error: Eliminacion de Marcade direccion.");
		ret.printStackTrace(VD.display().stderr());
		return false;
	}

  //*******************************************************************
  // Extraigo los posibles resultados para direccion(valordir)
  //  y direccion programada(valordirp).
	valordir = null;
	try	{
		valordir = r.store("dir",new Value(-1, RU.INTEGER));
	}	catch (ReteException ret)	{
		System.err.println("Error: Obtencion de direccion actual.");
		ret.printStackTrace(VD.display().stderr());
		return false;
	}

	valordirp = null;
	try {
		valordirp = r.store("dirp",new Value(-1, RU.INTEGER));
	} catch (ReteException ret)	{
		System.err.println("Error: Obtencion de direccion programada.");
		ret.printStackTrace(VD.display().stderr());
		return false;
	}
  //*******************************************************************
  // Evaluo la modificacion de las direcciones (actual y programada).
	if (valordir != null)	{
    try	{
			enterodir = valordir.intValue();
		} catch (ReteException ret) {
			System.err.println("Error: Transformacion de direccion actual.");
			ret.printStackTrace(VD.display().stderr());
			return false;
		}
		if (enterodir >= 0) {
			if (enterodir == 0)	{
				A.SetDireccionActual(Direccion.UP);
			}	else if (enterodir == 1){
				A.SetDireccionActual(Direccion.DOWN);
      }
		}
	}

	if (valordirp != null) {
    try {
			enterodirp = valordirp.intValue();
		} catch (ReteException ret) {
			System.err.println("Error: Trasformacion de direccion programada.");
			ret.printStackTrace(VD.display().stderr());
			return false;
		}
		if (enterodirp >= 0) {
			if (enterodirp == 0) {
				A.SetDireccionProgramada(Direccion.UP);
			}
			else if (enterodirp == 1) {
					A.SetDireccionProgramada(Direccion.DOWN);
      }
		}
	}
  	return true;
  }
}