// Last edited on 2000-09-05 04:04:35 by stolfi

import java.util.Vector;
import Conexao;
import Trecho;
import Bairro;
import Ponto;
import Retangulo;
import Esquina;
        
public class EsquinaImpl extends Esquina
  {

    private int _id;          // Identificacao unica da esquina.
    private Ponto _centro;       // Localiza da esquina na planta.
    private Conexao[] _con;   // Custos para conexão entre trechos.
    private Trecho[] _trChg;    // Trechos que chegam na esquina.
    private Trecho[] _trSai;    // Trechos que saem da esquina.

    // ** CONSTRUTORES ** 

    public EsquinaImpl(int id) 
      { _id = id; }

    public void inicializa(Ponto pos, Vector listaEnt, Vector listaSai, Vector listaCon)
      { _centro = new Ponto(pos.x, pos.y);
        _trChg = pegaTrechos(listaEnt);
        _trSai = pegaTrechos(listaSai);
        _con = pegaConexoes(listaCon);
      }
      
    // ** MÉTODOS GERAIS DE ELEMENTOS ** 

    public int id()
      { return _id; }

    public String nome()
      { return ("e" + _id); }

    public String toString()
      { return nome(); }
    
    public Bairro bairro()
      { return null; }

    public Ponto centro()
      { return _centro; }
      
    public void insere(Retangulo r)
      { r.insereBola(_centro.x, _centro.y, RAIO_NOMINAL); }

    public boolean intercepta(Retangulo r)
      { return r.contem(_centro.x, _centro.y); }

    public double distancia(Ponto p)
      { return Ponto.distancia(p, _centro); }

    // ** MÉTODOS PÚBLICOS ESPECÍFICOS **
    
    public Conexao[] conexoes()
      { return _con; }
    
    public double vcusto(Trecho t1, Trecho t2) 
      // Retorna o custo para fazer a conexao do trecho t1 para t2
      { for(int i = 0; i < _con.length; i++)
          { if ((_con[i].t1 == t1) && (_con[i].t2 == t2))
              { return _con[i].custo; }
          }
        return Double.MAX_VALUE;
      }

    public boolean pode(Trecho t1, Trecho t2)
      // True se a conexao de t1 para t2 e valida
      { for(int i = 0; i < _con.length; i++)
          { if ((_con[i].t1 == t1) && (_con[i].t2 == t2))
              { return true; }
          }
        return false;
      }

    public Trecho[] possibilidades(Trecho t)
      // Dado o trecho t, retorna todos os trechos cuja conexao e valida
      { int n = 0;
        Trecho[] tr;
        for(int i = 0; i < _con.length; i++)
          { if (_con[i].t1 == t) { n++; } }
        tr = new Trecho[n];
        n = 0;
        for(int i = 0; i < _con.length; i++)
          { if (_con[i].t1 == t) { tr[i] = _con[i].t2; n++; } }
        return tr;
      }

    public Trecho[] chegam()
      // Lista dos trechos que chegam a a Esquina
      { return _trChg; }

    public Trecho[] saem()
      // Lista dos trechos que saem da Esquina
      { return _trSai; }

    // ** MÉTODOS INTERNOS **

    private Conexao[] pegaConexoes(Vector listaCon) 
      { int n = listaCon.size();
        Conexao[] c = new Conexao[n];
        for(int i = 0; i < n; i++)
          { c[i] = (Conexao) listaCon.elementAt(i); }
        return c;
      }

    private Trecho[] pegaTrechos(Vector listaTrechos) 
      { int n = listaTrechos.size();
        Trecho[] tr = new Trecho[n];
        for(int i = 0; i < n; i++)
          { tr[i] = (Trecho) listaTrechos.elementAt(i); }
        return tr;
      }

  }