/**
 * Representa uno de los dos triangulos (que forman un cuadrado) que forman
 * una cara de una pieza del cubo rubik. Usada para dibujar el cubo rubik en
 * pantalla.
 * El orden en que se definan sus vertices indicara hacia donde 'mira' esta
 * cara, esta caracteristica es importante para saber si esta cara debe
 * ser dibujada o no.
 * En este proyecto se definio que todas las caras miren 'hacia afuera' de
 * su 'Pieza'.
 * Un observador que ve el lado externo de la cara, vera que los vertices siguen
 * un orden antihorario.
 * @author Carlos Cortes
 */
public class Cara3D
{
   /**
    * Pieza a la que pertenece esta cara.
    */
   private Pieza piezaBase;
   
   /**
    * Identificafion de los tres vertices que definen esta cara.
    */
   private int[] vertice = {0,0,0};
   
   /**
    * Define el color de esta cara.
    */
   private int color;
   
   /**
    * Crea e inicializa una Cara3D, con las caracteristicas especificadas.
    * @param ba Pieza a la que pertenece esta cara.
    * @param v0 Primer vertice.
    * @param v1 Segundo vertice.
    * @param v2 Tercer vertice.
    * @param col Color de la cara (definido en Triangulo.java).
    */
   public Cara3D(Pieza ba, int v0, int v1, int v2, int col)
   {
      piezaBase = ba;
      vertice[0] = v0;
      vertice[1] = v1;
      vertice[2] = v2;
      color = col;
   }
   
   /**
    * Crea e inicializa una Cara3D, con las caracteristicas especificadas.
    * Usado por 'clone()'.
    * @param pBase Pieza a la que pertenece esta cara.
    * @param ve Arreglo que contiene los tres vertices.
    * @param co Color de la cara (definido en Triangulo.java).
    */
   private Cara3D(Pieza pBase, int[] ve, int co)
   {
      piezaBase = pBase;
      vertice = ve;
      color = co;
   }
   
   /**
    * Cambia la Pieza a la que pertenece esta cara.
    * @param pB Pieza a la que pertenecera esta cara.
    */
   public void setPieza(Pieza pB)
   {
      piezaBase = pB;
   }
   
   /**
    * Cambia el arreglo que identifica los vertices de esta cara.
    * @param ve Arreglo que identifica los vertices de esta cara.
    */
   public void setVerticeArray(int[] ve)
   {
      vertice = ve;
   }
   
   /**
    * Cambia el color de esta cara.
    * @param co Nuevo color de esta cara.
    */
   public void setColor(int co)
   {
      color = co;
   }
   
   /**
    * Retorna el arraglo que identifica los vertices de esta cara.
    * @return El arraglo que identifica los vertices de esta cara.
    */
   public Point3D[] getVertices()
   {
      Point3D[] vertArray = {null,null,null};
      
      vertArray[0] = piezaBase.getVerticeArray()[ vertice[0] ];
      vertArray[1] = piezaBase.getVerticeArray()[ vertice[1] ];
      vertArray[2] = piezaBase.getVerticeArray()[ vertice[2] ];
      
      return vertArray;
   }
   
   /**
    * Retorna el color de esta cara.
    * @return El color de esta cara.
    */
   public int getColor()
   {
      return color;
   }
   
   /**
    * Retorna un vector (Point3D) normal a esta cara y que apunta hacia su lado
    * exterior.
    * @return un vector (Point3D) normal a esta cara y que apunta hacia su lado
    *         exterior.
    */
   public Point3D getVectorNormal()
   {
      Point3D v1, v2;
      
      Pieza pTemp = piezaBase.clone();
      pTemp.normalizar();
      Point3D[] vTemp = pTemp.getVerticeArray();
      
      v1 = vTemp[ vertice[0] ].clone();
      v1.menos(vTemp[ vertice[1] ]);
      v2 = vTemp[ vertice[2] ].clone();
      v2.menos(vTemp[ vertice[1] ]);
      v2.pCruz(v1);
      v2.hacerUnitario();
      return v2;
   }
   
   /**
    * Retorna una copia de esta cara, cuidando de no perder la referencia a su
    * Pieza base original.
    */
   public Cara3D clone()
   {
      int[] ve = {0,0,0};
      
      ve[0] = vertice[0];
      ve[1] = vertice[1];
      ve[2] = vertice[2];
      
      return new Cara3D(piezaBase, ve, color);
   }
   
   /**
    * Retorna un Point3D que define la posicion de esta cara en el espacio 3D.
    */
   public Point3D getCentro()
   {
      Point3D[] ve = {null,null};
      ve[0] = piezaBase.getVerticeArray()[ vertice[0] ].clone();
      ve[1] = piezaBase.getVerticeArray()[ vertice[2] ].clone();
      
      ve[0].normalizar(piezaBase.getEjes());
      ve[1].normalizar(piezaBase.getEjes());
      
      float _x = (ve[0].getX() + ve[1].getX()) / 2;
      float _y = (ve[0].getY() + ve[1].getY()) / 2;
      float _z = (ve[0].getZ() + ve[1].getZ()) / 2;
      
      return new Point3D(_x, _y, _z);
   }
}