// Responsável: Juliano Pastorelli Dutra - RA: 981449
package pckInterface;

import java.awt.Rectangle;
import java.util.Vector;
import java.lang.Math;

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

/**
 * A classe Localizador eh responsavel pela localizacao de 
 * trechos e conexoes dentro de um Mapa
 **/

/**
 * Membro responsavel pelo modulo
 * Juliano Pastorelli Dutra
 * 981449
 **/

public class LocalizadorImpl
{
    
    /**
     * ATRIBUTOS
     * 981449
     **/
    private Mapa planta;
    
    /**
     * Construtor para o Localizador
     * 981449
     **/
    public LocalizadorImpl(Mapa pl)
    { this.planta = pl; }
    
    /**
     * Retorna o Trecho mais proximo do ponto dado
     * Entrada: Ponto
     * Saida: O trecho mais proximo do ponto p.
     * 981449
     **/
    public Trecho trechoMaisProximo(Ponto p)
    { Trecho[] t = planta.getTrechos(); // Todos os Trechos do Mapa
    Trecho minTrecho = null;
    double minDist = Double.MAX_VALUE;
    for (int i = 0; i < t.length; i++)
	{ Ponto pontoinicio = t[i].getInicio().getPonto();
	Ponto pontofim = t[i].getFim().getPonto();
	double dist = LocalizadorImpl.distanciaASegmento(p,pontoinicio,pontofim);
	if (dist < minDist)
	    { minDist = dist; minTrecho = t[i]; }
	}
    return(minTrecho);
    } // Fim do trechoMaisProximo()

    /**
     * Retorna os Trechos que interceptam uma area retangular
     * Entrada: um objeto do tipo Retangulo
     * Saida: Um vetor com todos os Trechos interceptados por r.
     * 981449
     **/
    public Trecho[] todosTrechosDentro(Retangulo r) 
    { Trecho[] t = planta.getTrechos(); // Todos os Trechos do Mapa
    Vector v = new Vector();
    for (int i = 0; i < t.length; i++)
	{ Ponto pontoinicio = t[i].getInicio().getPonto();
	Ponto pontofim = t[i].getFim().getPonto();
	if (LocalizadorImpl.intercepta(pontoinicio,pontofim,r)){ v.addElement(t[i]); } }
    int n = v.size();
    Trecho[] ret = new Trecho[n];
    for (int i = 0; i < n; i++) { ret[i] = (Trecho) v.elementAt(i); }
    return ret;
    } // Fim do todosTrechosDentro()	
	
    /**
     * Retorna as Conexoes que interceptam uma area retangular
     * Entrada: um objeto do tipo Retangulo
     * Saida: um vetor das Conexoes englobadas pelo retangulo
     * 981449
     **/
    public Conexao[] todasConexoesDentro(Retangulo r)
    { Conexao[] c = planta.getConexoes(); // todas as Conexoes do Mapa
    Vector v = new Vector();
    for (int i = 0; i < c.length; i++)
	{ Ponto ponto = c[i].getPonto();
	if (LocalizadorImpl.intercepta(ponto,ponto,r)) { v.addElement(c[i]); } }
    int n = v.size();
    Conexao[] ret = new Conexao[n];
    for (int i = 0; i < n; i++) { ret[i] = (Conexao) v.elementAt(i); }
    return ret;
    } // Fim do todasConexoesDentro

    /**
     * Retorna a Distancia Euclidiana entre um segmento de reta e um ponto
     * Entrada: dois pontos (extremos de um trecho) e um ponto
     * Saida: a distancia Euclidiana entre o ponto e o trecho
     * 981449
     **/
    public static double distanciaASegmento(Ponto p, Ponto u, Ponto v)
    {
	double dux = (double)(p.getX() - u.getX()); // diferenca px ux
	double duy = (double)(p.getY() - u.getY()); // diferenca py uy
	double dvx = (double)(p.getX() - v.getX()); // diferenca px vx
	double dvy = (double)(p.getY() - v.getY()); // diferenca py vy
	double drx = (double)(v.getX() - u.getX()); // diferenca vx ux
	double dry = (double)(v.getY() - u.getY()); // diferenca vy uy
	if (dux*drx + duy*dry <= 0)
	    { return Math.sqrt(dux*dux + duy*duy); }
	else if (dvx*drx + dvy*dry >= 0)
	    { return Math.sqrt(dvx*dvx + dvy*dvy); }
	else
	    { double dsx = dry;
	    double dsy = - drx;
	    return Math.abs(dux*dsx + duy*dsy)/Math.sqrt(dsx*dsx + dsy*dsy);
	    }
    } // Fim do distanciaASegmento

    /**
     * O metodo diz se um trecho eh ou nao interceptado pelo retangulo
     * Entrada: dois pontos (extremos de um trecho) e um retangulo
     * Saida: true (se o trecho esta contido ou eh interceptado pelo retangulo)
     * 981449
     **/
    public static boolean intercepta(Ponto ponto1, Ponto ponto2, Retangulo r)
    {
	double x1 = ponto1.getX(); // este eh o x do ponto1
	double y1 = ponto1.getY(); // este eh o y do ponto1
	double x2 = ponto2.getX(); // este eh o x do ponto2
	double y2 = ponto2.getY(); // este eh o y do ponto2
	// o resultado serah verdadeiro se um dos dois pontos estiver contido
	// dentro do retangulo dado
	if ((x1>r.xMin) & (x1<r.xMax) & (y1>r.yMin) & (y1<r.yMax))
	    { return true; } else {
		if ((x2>r.xMin) & (x2<r.xMax) & (y2>r.yMin) & (y2<r.yMax))
		    { return true; } else { return false; }}
    } // Fim do intercepta
    
} // Fim da Classe