//****************************************************************
//	TRABAJO ISBC : INTEGRACION JAVA-JESS. CASO DEL ELEVADOR	
//****************************************************************
//
//	Fichero:	Edificio.java
//	Autor:	
//	Modificado por:	Daniel Urieta Lopez
//    David Portolés Rodríguez 17/11/2001
//          Añadido MAX_NUM_PISOS, MAX_NUM_ASCENS
//	Proposito:	Contiene la clase Edificio que es un thread que
//			maneja todo el resto de clases, y mantiene
//			variables como las personas que hay en el edificio
//			y cada cuanto cogen el ascensor.
//
//****************************************************************
import Piso;
import Ascensor;
import Pasajero;
import Controlador;
import java.lang.*;
import java.util.*;
import java.awt.*;



public class Edificio implements Runnable
{
  public Controlador controlador;
  public int maximo_numero_pasajeros=10;
  public int intervalo_creacion_pasajeros=5000;
  public boolean creacion_continua = false;

  private int numero_pasajeros = 0;
  private int numero_ascensores = 0;
  private int numero_pisos = 0;

  private Piso pisos[];
  public Vector ascensores;
  private Vector pasajeros;

  private int estado_threads;

  private VentanaAscensores VA;
  private VentanaControl VC;
  private Visualizar VD;

  private ThreadGroup edificio_grupo;

  private Thread edificio_thread;

  static public int MAX_NUM_PISOS = 7;
  static public int MAX_NUM_ASCENS = 2;

  public Edificio()
  {
     int i;

     ascensores = new Vector(MAX_NUM_ASCENS + 1);
     pisos = new Piso[MAX_NUM_PISOS + 1];
     pasajeros = new Vector(20);

     VD=new Visualizar("Motor inferencia (Jess)",this,null);

     VC=new VentanaControl("Control del edificio") ;

     controlador=new Controlador(VD);

     VA=new VentanaAscensores (this,"Ascensores");

     edificio_grupo=new ThreadGroup("edificio");

     for(i = 1; i <= MAX_NUM_PISOS; i++) {
       CrearPiso();
     }

     for(i = 1; i <= MAX_NUM_PISOS - 1; i++) {
       pisos[i+1].vecino_abajo=pisos[i];
       pisos[i].vecino_arriba=pisos[i+1];
     }

     for(i = 1; i <= MAX_NUM_ASCENS; i++) {
       CrearAscensor();
     }

     VC.ControlarEdificio(this);
     VC.setVisible(true);

     VA.setVisible(true);

     edificio_thread=new Thread(edificio_grupo,this);
     edificio_thread.start();
     estado_threads=0;

  }

  public void CrearAscensor()
  {
    ascensores.addElement(new Ascensor(++numero_ascensores,pisos[1],this,VA));
  }

  public void Parar_Arrancar()
  {
    if (estado_threads == 0) 
    {
       System.err.println("Paro todos los threads");
       edificio_grupo.suspend();
       estado_threads = 1;
    }
    else
    {
       System.err.println("Rearranco todos los threads");
       edificio_grupo.resume();
       estado_threads = 0;

    }
  }

  public ThreadGroup grupo()
  {
	return edificio_grupo;
  }

  private void CrearPiso()
  {
    pisos[++numero_pisos]=new Piso(numero_pisos,this);
  }

  private void CrearPasajero()
  {
    pasajeros.addElement(new Pasajero(++numero_pasajeros,this,VA));
  }

  public Piso SeleccionarPisoAleatorio()
  {
    return pisos[(int)(Math.random()*MAX_NUM_PISOS+1)];
  }

  public Piso SeleccionarPisoAleatorio(Piso P)
  {
    Piso temp;
    do{
      temp=pisos[(int)(Math.random()*MAX_NUM_PISOS+1)];
    }while (temp==P);
    return temp;
  }

  public void run()
  {

    while (true)
    {
      try
      {
        edificio_thread.sleep(intervalo_creacion_pasajeros);
      } catch (InterruptedException e){}
     
      if ((numero_pasajeros<maximo_numero_pasajeros)|| creacion_continua)
        CrearPasajero();
    }
  }


}