/** Ultima atualizacao : 29-06-2001
 * Autores : Claudio Copello - 980860
 *           Joao Porto - 981389
 *           Joao Guilherme - 981374
 *           Joyce Ynoue - 981414
 *           Eduardo Lins - 952302
 */
package pckPlano;

import pckDemanda.Encomenda;
import pckMapa.Trecho;
import pckMapa.Mapa;

public class ValidadorImpl extends Validador {

    
    public ValidadorImpl(){
	/** Construtor da classe
	 */
	mensagemErro = "";
    }

    public boolean plano ( Plano pl, Encomenda[] e, Veiculo[] v, Mapa m ){
	/** Implementado por Joao Porto - 981389
	 * Este metodo consiste na validacao geral do plano de atendimento:
	 * - Validacao das rotas (conectividade, tempo de percurso )
	 * - Validacao do atendimento das encomendas
	 * - Validacao da capacidade maxima em cada veiculo 
	 */

	boolean v1 = rotas( pl.rotas(), m );
	boolean v2 = encomendas( pl, e );
	boolean v3 = capacidade( pl );

	return ( v1 && v2 && v3 );

    }    

    public boolean rotas( Rota[] pl, Mapa m ){
	/** Implementado por Joao Porto - 981389
	 * Validacao das rotas do Plano de Atendimento:
	 * - Conectividade dos trechos (a sequencia eh conexa)
	 * - Conectividade dos horarios (horario do fim de um passo eh o de
	 *     inicio do outro sucessor)
	 * - Tempo de percurso dos trechos (coerente) 
	 */

	boolean v1 = conectTrecho(pl, m);
	boolean v2 = conectHorario (pl);
	boolean v3 = tempoPercTrechos(pl);

	return ( v1 && v2 && v3 );

    }

    public boolean encomendas( Plano pl, Encomenda[] e ){
	/** Implementado por Joao Porto - 981389
	 * Validacao do atendimento das encomendas : 
	 *  - Carga e Descarga nos trechos especificados
	 *  - Carga e Descarga nos horarios especificados
	 */

	boolean v1 = trechoCargaDescargaEncomenda(pl, e);
	boolean v2 = horarioCargaDescargaEncomenda(pl, e);
	return ( v1 && v2 );

    }


    public boolean capacidade( Plano pl ){
	/** Implementado por Joao Porto - 981389 
	 *   Validacao da capacidade do veiculo durante o percurso
	 * O volume de encomendas dentro do veiculo nao deve ultrapassar
	 *  sua capacidade maxima.
	 */
	    
	Rota[] rotas;
	Passo[] passos;
	Encomenda[] encomendas;
	float capv, carga;

	rotas = pl.rotas();

	// Loop para percorrer todas as rotas do Plano
	for( int r=0; r < rotas.length; r++ ){

	    // Obtem a capacidade do veiculo designado para esta rota
	    capv = rotas[r].veiculo().getCapacidade();
	    // Zera a carga inicial
	    carga = 0;

	    passos = rotas[r].passos(); 
	    // Percorre todos os passos da rota verificando a capacidade do veiculo
	    for( int p=0; p < passos.length; p++ ){

		// Acumula todas as encomendas carregadas ate o passo p que
		// nao foram descarregadas ainda

		// Adiciona 'a carga as encomendas carregadas neste passo
		encomendas = passos[p].carrega(); 
		for( int e=0; e < encomendas.length; e++) {
		    carga += encomendas[e].getVolume();
		}

		// Subtrai da carga as encomendas descarregadas neste passo
		encomendas = passos[p].descarrega(); 
		for( int e=0; e < encomendas.length; e++) {
		    carga -= encomendas[e].getVolume();
		}

		// Verifica se a carga ao final do passo excede a capacidade do veiculo
		if (carga > capv){
		    mensagemErro = mensagemErro + "\n Capacidade Maxima do Veiculo excedida";
		    return false;
		}
	    }
	}
	return true;
    }
    

    public boolean conectTrecho( Rota[] planoRotas, Mapa mapa ){
	/**Implementado por Claudio Copello - 980860 
	 * Validacao da conectividade dos trechos
	 *  dst(trecho(Pi))=org(trecho(pi+1)) 
	 * Entrada: Plano de Rotas
	 * Saida: Verdadeiro se os trechos sao conexos. Falso, caso contrario
	 */
	int i;
        int j;
	Passo[] p;
        Trecho t1;
        Trecho t2;
	for (i=0; i<planoRotas.length; i++){
	    p = planoRotas[i].passos();
	    for (j=0; j<p.length-1; j++){
		t1 = p[j].trecho();
		t2 = p[j+1].trecho();
		if(!mapa.pode(t1,t2)){
		    mensagemErro = mensagemErro + "\n Trecho " + t1.getId() + "e trecho " + t2.getId() + " sao desconexos - Rota Desconexa no Plano de Atendimento";
		    return false;
		}
	    } 
	}
	return true;
    }


    public boolean tempoPercTrechos( Rota[] pr){
	/**Implementado por Joao Guilherme - 981374 
	 * Validacao do tempo de permanencia em um trecho.
	 * Retorna verdadeiro se o tempo de permanencia em cada trecho nao eh menor
	 * do que o tempo minimo de percurso do trecho.
	 */
	Passo[] passos;
	Encomenda[] carregadas, descarregadas;
	double tempoTotalCarga, tempoTotalDescarga;

	/* para cada rota do plano de rotas */
	for (int r=0; r<pr.length; r++){

	    /* para cada passo desta rota */
	    passos = pr[r].passos();
	    for (int p=0; p<passos.length; p++){

		/* calculando o tempo total de cargas neste passo */
		tempoTotalCarga = 0;
		carregadas = passos[p].carrega();
		for (int e=0; e<carregadas.length; e++){
		    tempoTotalCarga = tempoTotalCarga + carregadas[e].getTempoCarga();
		}

		/* calculando o tempo total de descargas neste passo */
		tempoTotalDescarga = 0;
		descarregadas = passos[p].descarrega();
		for (int e=0; e<descarregadas.length; e++){
		    tempoTotalDescarga = tempoTotalDescarga + descarregadas[e].getTempoDescarga();
		}

		if ( passos[p].intervalo().getInicio() +
		     tempoTotalCarga +
		     tempoTotalDescarga +
		     passos[p].trecho().getTempoPercurso() >
		     passos[p].intervalo().getFim() ){
		    mensagemErro = mensagemErro + "\nTempo de permanencia em um trecho excedido.";
		    return false;
		}

	    }
	}
	return true;
	
    }


    public boolean conectHorario( Rota[] planoRotas ) {
	/**Implementado por Joyce - 981414 
	 * Validacao da conectividade dos horaris 
	 * Entrada: Plano de Rotas
	 * Saida: Verdadeiro se os horarios sao conexos . Falso, caso contrario
	 */
    
	boolean valido = false;
	Passo[] passos = null;

    // Percorre todo o array de Rota[] setando o array passos 
	for ( int iLoop = 0; iLoop < planoRotas.length; iLoop++) {
	    passos = planoRotas[iLoop].passos();

	    for ( int i = 0; i < passos.length-1; i++ ) {
		Passo passoAtual = passos[i];
		Passo passoProximo = passos[i+1];
		IntervaloData intervaloAtual = passoAtual.intervalo();
		IntervaloData intervaloProximo = passoProximo.intervalo();
		double horaFim = intervaloAtual.getFim();
		double horaInicio = intervaloProximo.getInicio();
	    
		// Verifica se o instante final de um passo eh o instante inicial do passo seguinte.
		if ( horaFim == horaInicio ) {
		    valido = true;
		} else {
		    mensagemErro = mensagemErro + "\n Conectividade de horario falhou no passo " + i + " da Rota " + iLoop;
		} 
	    }
	}
	return valido;
    }



    public boolean horarioCargaDescargaEncomenda( Plano pl, Encomenda[] enc ){
	/** Implementado por Joao Guilherme - 981374
         * Valida o plano quanto ao horario de carga e descarga.
	 * Retorna verdadeiro se carrega e descarrega as encomendas nos horarios determinados para cada uma.
	 */

	Passo passo;
	Encomenda encomenda;

     /* para cada encomenda da lista de encomendas */
	for (int e=0; e<enc.length; e++){
	    
	    encomenda = enc[e];
	    
	    /* validando se contempla a carga da encomenda */
	    passo = pl.trechoCarga(encomenda);
	    if (passo == null){
		mensagemErro = mensagemErro + "\nCarga da encomenda " + encomenda.getEncomendaID() + " nao contemplada.";
		return false;
	    }

	    /* validando horario de carga da encomenda */
	    if ( ( encomenda.getHoraOrigem() < passo.intervalo().getInicio() ) ||
		( encomenda.getHoraOrigem() > passo.intervalo().getFim()) ){
		mensagemErro = mensagemErro + "\nHorario de carga da encomenda " + encomenda.getEncomendaID() + " nao contemplado.";
		return false;
	    }

	    /* validando se contempla a descarga da encomenda */
	    passo = pl.trechoDescarga(encomenda);
	    if (passo == null){
		mensagemErro = mensagemErro + "\nDescarga da encomenda " + encomenda.getEncomendaID() + " nao contemplada.";
		return false;
	    }

	    /* validando horario de descarga da encomenda */
	    if (( encomenda.getHoraDestino() < passo.intervalo().getInicio() ) ||
		( encomenda.getHoraDestino() > passo.intervalo().getFim())){
		mensagemErro = mensagemErro + "\nHorario de descarga da encomenda " + encomenda.getEncomendaID() + " nao contemplado.";
		return false;
	    }

	}
	
	return true;
    }


    public boolean trechoCargaDescargaEncomenda( Plano planoAtendimento, Encomenda[] encomendas ) {
	/**Implementado por Eduardo Lins - 952302 
	 * Validacao se todas as encomendas foram carregadas/descarregadas naquele trecho
	 * Entrada: Plano de Atendimento,  encomendas,  veiculos
	 * Saida: Verdadeiro se todas as encomendas foram contempladas. Falso, caso contrario
	 */

	Rota[] rotas;
	boolean valido = false;
   
	rotas = planoAtendimento.rotas();

    // Loop para percorrer todas as Encomendas
	for( int r=0; r < encomendas.length ; r++ ){

	    Encomenda encomenda = encomendas[r];

	    Passo passo =  planoAtendimento.trechoCarga(encomenda);

	    if (passo != null ) {
		if ( (encomenda.getOrigem().getId() != passo.trecho().getId()) &&
		     (encomenda.getDestino().getId() != passo.trecho().getId()) ) {
		    mensagemErro = mensagemErro + "\n A encomenda nao sera carregada ou descarregada nesse trecho";
		} else {
		    valido = true;
		}
	    } else {
		mensagemErro = mensagemErro + "\n A encomenda nao sera carregada ou descarregada nesse trecho";
	    }
	}
	return valido;
    }

    

    public String getMensagemErro(){
    /**Implementado por Claudio Copello - 980860 
     * Obtem a mensagem de erro gerada pelos metodos anteriores 
     * Entrada: nenhuma
     * Saida: Mensagem de erro gerada pelos outros metodos da classe
     */
	return mensagemErro;
    }


}