//****************************************************************
//	TRABAJO ISBC : INTEGRACION JAVA-JESS. CASO DEL ELEVADOR
//****************************************************************
//
//	Fichero:	Ascensor.java
//	Autor:
//	Modificado por:	Daniel Urieta Lopez
//	Proposito:	Contiene la clase Ascensor que es un thread.
//
//****************************************************************


import Piso;
import Direccion;
import Puertas;
import Motor;
import Pasajero;
import PanelAscensor;
import CanvasPasajero;
import VentanaAscensores;
import java.awt.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.LineBorder;

public class Ascensor implements Runnable
{
  private final static int PARADO = 0, MOVIENDO = 1;

   //Atributos propios de la clase
  private int id_ascensor;
  private int estado;
  private Piso piso_actual;
  private int direccion_actual;
  private int direccion_programada;

    //Atributos de relacion
  private Edificio edificio;
  private Puertas puertas;
  private Motor motor;
  private Vector pasajeros;
  public PanelDestino panel_destino;                          

    //Atributos del interfaz grafico
  public PanelAscensor panel_ascensor;
  private CanvasPasajero canvas_pasajero;
  private CanvasPasajero2 canvas_pasajero2;
  private VentanaAscensores VA;

    //Atributo que lleva el proceso
  private Thread ascensor_thread;


  public Ascensor(int id,Piso P, Edificio E,VentanaAscensores va)
  {
    id_ascensor=id;
    direccion_actual=Direccion.NONE;
    direccion_programada=Direccion.NONE;
    estado=PARADO;
//    SetPisoActual(P);       //dporto
//    P.LlegaAscensor(this);          //dporto

    edificio=E;
    panel_destino=new PanelDestino(40);
    puertas=new Puertas();
    motor=new Motor();
    pasajeros=new Vector(5);

    VA=va;
    canvas_pasajero = new CanvasPasajero(pasajeros);
    panel_ascensor = new PanelAscensor(id_ascensor);
    panel_ascensor.piso.SetPiso(P.GetIdPiso());

    JPanel panel_control=new JPanel();
    panel_control.setLayout(new BorderLayout());
    panel_control.add(panel_ascensor,BorderLayout.NORTH);

    Canvas unCanvas = new Canvas();
    unCanvas.setSize(70,50);
    unCanvas.setBackground(Color.white);
    panel_control.add(unCanvas,BorderLayout.SOUTH);

    canvas_pasajero2 = new CanvasPasajero2();
    panel_ascensor.setPasajeros(canvas_pasajero2);

    VA.setAscensor(panel_control, this.GetIdAscensor());

    SetPisoActual(P);       //dporto
    P.LlegaAscensor(this);          //dporto

    edificio.controlador.InsertaAscensor(id,1,0,0,0);

    ascensor_thread=new Thread(edificio.grupo(),this);
    ascensor_thread.start();

  }

  public int GetIdAscensor()
  {
    return id_ascensor;
  }

  public void SetPisoActual(Piso P)
  {
    piso_actual=P;
    VA.SetPisoAscensor(this.GetIdAscensor(), P.GetIdPiso());
  }

  public Piso GetPisoActual()
  {
    return piso_actual;
  }

  public int GetDireccionProgramada()
  {
    return direccion_programada;
  }

  public int GetDireccionActual()
  {
    return direccion_actual;
  }

  public void SetDireccionProgramada(int D)
  {
    if (GetDireccionProgramada() != D)
    {
    	direccion_programada = D;
    	switch (D)
    	{
		case 0:  {edificio.controlador.ModificaAscensor(id_ascensor,-1,-1,0,-1); break;}
		case 1:  {edificio.controlador.ModificaAscensor(id_ascensor,-1,-1,1,-1); break;}
		case 2:  {edificio.controlador.ModificaAscensor(id_ascensor,-1,-1,2,-1); break;}
		case 3:  {edificio.controlador.ModificaAscensor(id_ascensor,-1,-1,3,-1); break;}
		default: System.err.println("Direccion programada no valida");
    	}
    }
  }

  public void SetDireccionActual(int D)
  {
    if (GetDireccionActual() != D)
    {
    	direccion_actual = D;
    	switch (D)
    	{
		case 0:  {edificio.controlador.ModificaAscensor(id_ascensor,-1,0,-1,-1); break;}
		case 1:  {edificio.controlador.ModificaAscensor(id_ascensor,-1,1,-1,-1); break;}
		case 2:  {edificio.controlador.ModificaAscensor(id_ascensor,-1,2,-1,-1); break;}
		case 3:  {edificio.controlador.ModificaAscensor(id_ascensor,-1,3,-1,-1); break;}
		default: System.err.println("Direccion actual no valida");
    	}
    }
  }

  public void EmbarcaPasajero(Pasajero P)
  {
    pasajeros.addElement(P);
    canvas_pasajero.repaint();

    canvas_pasajero2.addPasajero();

    panel_ascensor.botones.addPasajero(P);

    canvas_pasajero2.repaint();
    panel_ascensor.repaint();
  }

  public void DesembarcaPasajero(Pasajero P)
  {
    pasajeros.removeElement(P);
    canvas_pasajero.repaint();

    canvas_pasajero2.removePasajero();

    panel_ascensor.botones.removePasajero(P);

    canvas_pasajero2.repaint();
    panel_ascensor.repaint();
  }

  public void LlegarAlSiguientePiso()
  {
    if (direccion_actual==Direccion.UP)
      SetPisoActual(piso_actual.vecino_arriba);
    else
      SetPisoActual(piso_actual.vecino_abajo);

    panel_ascensor.piso.SetPiso(GetPisoActual().GetIdPiso());
    edificio.controlador.ModificaAscensor(id_ascensor,GetPisoActual().GetIdPiso(),-1,-1,-1);
//Posible error de concurrencia y no se modifica el piso antes de que se calcule si sube o baja
// alguien. *******************************************+

  }

  public boolean EstaElAscensorAbierto()
  {
    return (puertas.PuertasAbiertas());
  }

  private void CicloPuertas()
  {
    puertas.AbrirPuertas();
    while (!puertas.PuertasAbiertas()) { Esperar(); }

    puertas.MantenerPuertasAbiertas();
    while (!puertas.FinTiempoPuertasAbiertas()) { Esperar(); }
  }

  private void Esperar()
  {
    try
    {
      ascensor_thread.sleep(200);
    } catch (InterruptedException e){}
  }



  public void run()
  {
    while (true)
    {
      switch (estado)
      {
        case PARADO:

          edificio.controlador.EstablecerSiguienteDireccion(this);
          panel_ascensor.piso.SetDireccion(direccion_actual,direccion_programada);

          if ((direccion_actual != Direccion.NONE)&&(direccion_actual != Direccion.STOP))
          {
            puertas.CerrarPuertas();
            while (puertas.PuertasAbiertas()) { Esperar(); }
            panel_ascensor.estado.SetParado(false);
            piso_actual.SaleAscensor(this);
            estado=MOVIENDO;
		edificio.controlador.ModificaAscensor(id_ascensor,-1,-1,-1,1);
          }
          else Esperar();
          break;

       case MOVIENDO:
          motor.MoverAscensor();
          while (!motor.AscensorHaLlegado()) {
            Esperar();
          }

	    LlegarAlSiguientePiso();
	    //******************************************************
          edificio.controlador.DebePararAscensor(this);

          panel_ascensor.piso.SetDireccion(direccion_actual,direccion_programada);

          if (direccion_actual==Direccion.STOP)
          {
		edificio.controlador.ModificaAscensor(id_ascensor,-1,-1,-1,0);
            piso_actual.LlegaAscensor(this);
            panel_ascensor.estado.SetParado(true);
            panel_destino.ResetDestino(piso_actual);
            CicloPuertas();
            estado=PARADO;
          }

          break;
      }

    }
  }
}