import java.awt.Point;

/**
 * Esta clase tiene como finalidad comprobar empiricamente las clases y sus
 * metodos particulares asociados al desarrollo de la tarea 1 del ramos DPOO
 * dictado durante el primer semestre del 2006 por el profesor <b> Agustin
 * Gonzalez<b>
 * 
 * @author Miguel Rebolledo - 20-04-2006
 * @version 1.0
 */
public class TestTarea1
{
    /*
     * Variables que indicaran si confiar en metodos equals de cada clase hecha
     * por el alumno.
     */
    private static boolean eqR = true;

    private static boolean eqT = true;

    private static boolean eqL = true;

    private static boolean eqC = true;

    TestTarea1()
    {
    }

    /**
     * Metodo principal de la presente clase que permite transformar a esta
     * clase en una aplicacion o comienzo de esta.
     * 
     * @param args
     *            Argumentos que se pasan por linea de comandos en la consola.
     */
    public static void main(String[] args)
    {
        // Ingresar datos de partida de cada Forma.
        double ancho = 10.0, alto = 10.0, radio = 10.0;
        Point a = new Point(0, 0), b = new Point(10, 10), c = new Point(0, 20);

        // Creación de las figuras originales.
        /*
         * rectángulo inicialmente centrado en (0,0), e inclincación 0 grados.
         */
        Rectangulo ra = new Rectangulo(ancho, alto);
        /*
         * Círculo de radio dado y centro en (0,0).
         */
        Circulo ca = new Circulo(radio);
        /*
         * triángulo en algún punto del espacio R2 con vértices a,b,c.
         */
        Triangulo ta = new Triangulo(a, b, c);
        /* Línea que va desde punto a a punto b. */
        Linea la = new Linea(a, b);

        // Arreglo con originales
        Forma[] original = { ra, ca, ta, la };
        boolean[] eqStatus = { eqR, eqC, eqT, eqL };

        // Generacion de Arreglo con los clones de prueba.
        Forma[] clonados = clonar(original);
        boolean[] clonStatus = { true, true, true, true };

        // comprobacion de metodos equals
        comprobarEquals();

        // comprobar metodos de clonacion
        comprobarClones(original, clonados, clonStatus);

        // comprobacion de metodos trasladar
        comprobarTrasladar(original, clonStatus, eqStatus);

        // comprobacion de los metodos rotar
        comprobarRotar(original, clonStatus, eqStatus);

        // comprobacion de los metodos escalar
        comprobarEscalar(original);
    }

    /**
     * Este metodo se crea con la finalidad de comprobar la confiabilidad del
     * metodo equals dado que es crucial para posteriores verificaciones de los
     * demas metodos. El resultado de estas comprobaciones repercutira en las
     * variables de confianza del metodo equals eqX para la clase X. Se imprime
     * en consola los resultados de manera de hacer visible los hechos que
     * pasaran mientras se desarrolla la ejecucion de la aplicacion.
     */
    private static void comprobarEquals()
    {
        // Creación y comprobacion del metodo de cada Clase.
        // Comprobacion de equals de Rectangulo.
        if ((new Rectangulo(1.0D, 1.0D)).equals(new Rectangulo(1.0D, 2.0D)))
        {
            System.out.println("Clase Rectangulo tiene ERROR en EQUALS");
            eqR = false;
        }
        else
        {
            System.out.println("Clase Rectangulo tiene OK EQUALS");
        }
        // Comprobacion de equals de Circulo.
        if ((new Circulo(2.0D)).equals(new Circulo(3.0D)))
        {
            System.out.println("Clase Circulo tiene ERROR en EQUALS");
            eqC = false;
        }
        else
        {
            System.out.println("Clase Circulo tiene OK EQUALS");
        }
        // Comprobacion de equals de Triangulo.
        if ((new Triangulo(new Point(1, 1), new Point(1, 3), new Point(2, 2)))
                .equals(new Triangulo(new Point(1, 1), new Point(1, 3),
                        new Point(3, 2))))
        {
            System.out.println("Clase Triangulo tiene ERROR en EQUALS");
            eqT = false;
        }
        else
        {
            System.out.println("Clase Triangulo tiene OK EQUALS");
        }
        // Comprobacion de equals de Linea.
        if ((new Linea(new Point(0, 0), new Point(2, 2))).equals(new Linea(
                new Point(0, 4), new Point(2, 2))))
        {
            System.out.println("Clase Linea tiene ERROR en EQUALS");
            eqL = false;
        }
        else
        {
            System.out.println("Clase Linea tiene OK EQUALS");
        }
    }

    /**
     * Este metodo se utilizara para verificar si las clases utilizan de buena
     * manera el metodo clone. Para poder ejecutar este metodos es impresindible
     * que el metodo equals() sea confiable de manera que se pueda basar en su
     * algoritmo de comprobacion para determinar el resultado de una cloncion.
     * Es resultado de esta operacion se verifica por pantalla por cada una de
     * las formas que se entrega como argumentos. Si se entrega un par de
     * arreglos con distinto tamaño no realiza nada y retorna.
     * 
     * @param a
     *            Arreglo de Formas para comparar con b
     * @param b
     *            Arreglo de Formas para comparar con a
     * @param clonStatus
     *            Arreglo donde se guardara el estado de cada clonacion
     */
    private static void comprobarClones(Forma[] a, Forma[] b,
            boolean[] clonStatus)
    {
        if (a.length != b.length)
        {
            System.out.println("Los Arreglos tienen distinto formato,"
                    + " revisar la creacion de las Formas y "
                    + "su inclucion en los Arreglos");
        }
        else
        {
            int veces = a.length;
            for (int i = 0; i < veces; i++)
            {
                /*
                 * Se verifica que se confiable el metodo equals de la
                 * respectiva clase que entra en clonacion. Si es confiable dara
                 * el paso a probar la clonacion
                 */
                if (((a[i].getClass().getName().equals("Rectangulo")) & (eqR))
                        || ((a[i].getClass().getName().equals("Circulo")) & (eqC))
                        || ((a[i].getClass().getName().equals("Linea")) & (eqL))
                        || ((a[i].getClass().getName().equals("Triangulo")) & (eqT)))
                {
                    if (((a[i]).equals(b[i])) & ((b[i]).equals(a[i])))
                    {
                        System.out.println("La clase "
                                + a[i].getClass().getName()
                                + " realiza OK CLONE");
                    }
                    else
                    {
                        System.out.println("Error en CLONE de la clase "
                                + a[i].getClass().getName());
                        clonStatus[i] = false;

                    }
                }
                /*
                 * Si no es confiable se pasa por alto esta prueba.
                 */
                else
                {
                    System.out.println("NO SE REALIZO el metodo clone() de "
                            + a[i].getClass().getName());
                    clonStatus[i] = false;
                }
            }
        }
    }

    /**
     * Metodo creado para clonar una arreglo de formas de manera que cada tipo
     * de Forma sea clonado con su respectivo metodo.
     * 
     * @param ori
     *            Arreglo de tipo Forma[] a clonar
     * @return Forma[] clonado del argumento, mediante el especifico clone
     *         respectivo a cada tipo de Forma.
     */
    private static Forma[] clonar(Forma[] ori)
    {
        Forma[] salida = new Forma[ori.length];
        // para cada unno de los tipos de clonaciones se realiza su respectivo
        // metodo clone()
        for (int i = 0; i < ori.length; i++)
        {
            if (ori[i].getClass().getName().equals("Rectangulo"))
                salida[i] = (Rectangulo) ((Rectangulo) ori[i]).clone();
            else if (ori[i].getClass().getName().equals("Circulo"))
                salida[i] = (Circulo) ((Circulo) ori[i]).clone();
            else if (ori[i].getClass().getName().equals("Triangulo"))
                salida[i] = (Triangulo) ((Triangulo) ori[i]).clone();
            else if (ori[i].getClass().getName().equals("Linea"))
                salida[i] = (Linea) ((Linea) ori[i]).clone();
        }
        return salida;
    }

    /**
     * Este metodo se cre con la finalidad de comprobar el metodo de traslado de
     * una Forma cuyo metodo de equals o clone es confiable. El resultado de
     * esta operacion dependera de los que se aplique en cada tipo de Forma
     * propuesta a evaluar este metodo.
     * 
     * @param ori
     *            Forma[] con los tipos de Forma a evaluar el metodo trasladar()
     * @param cStatus
     *            Estado booleano de la confiabilidad de los metodos clone.
     * @param eStatus
     *            estado booleano de la confiabilidad de los metodos equals.
     */
    private static void comprobarTrasladar(Forma[] ori, boolean[] cStatus,
            boolean[] eStatus)
    {
        Forma[] clones = clonar(ori);
        for (int i = 0; i < ori.length; i++)
        {
            /*
             * metodo equals y/o clone no confiables
             */
            if ((cStatus[i] & !eStatus[i]) || (!cStatus[i] & !eStatus[i]))
            {
                System.out.println("La clase " + ori[i].getClass().getName()
                        + " NO se le puede corregir TRASLADAR");
            }
            /*
             * Solo se puede utilizar el metodo equals
             */
            else if (!cStatus[i] & eStatus[i])
            {
                System.out.println("Se revisa Clase "
                        + ori[i].getClass().getName() + "sin clone()");
                System.out.println("ANTES DE TRASLADAR");
                System.out.println((ori[i]).toString());
                (ori[i]).trasladar(2.0, 2.0);
                System.out
                        .println("DESPUES DE TRASLADAR x factor=(2.0,2.0) \n");
                System.out.println((ori[i]).toString());
            }
            /*
             * Se puede utilizar clone y luego trasladar la figura y devolverla
             * para comprobar con el original
             */
            else if (cStatus[i] & eStatus[i])
            {
                System.out.println("Se revisa Clase "
                        + ori[i].getClass().getName() + " con clone()");
                clones[i].trasladar(2.0, 2.0);
                System.out.println("Se ha trasladado");
                clones[i].trasladar(-2.0, -2.0);
                if (clones[i].equals(ori[i]))
                    System.out.println("La CLase "
                            + ori[i].getClass().getName()
                            + " realiza OK TRASLADAR()");
                else
                    System.out.println("La CLase "
                            + ori[i].getClass().getName()
                            + " NO realiza OK TRASLADAR()");
            }
        }

    }

    /**
     * Esta clase tiene como finalidad comprobar la implementacion del metodo
     * rotar() en cada figura que se crea pasa a traves del arreglo de Formas en
     * el argumento del metodo.
     * 
     * @param ori
     *            Forma[] con los tipos de Forma a evaluar el metodo trasladar()
     * @param cStatus
     *            Estado booleano de la confiabilidad de los metodos clone.
     * @param eStatus
     *            Estado booleano de la confiabilidad de los metodos equals.
     */

    private static void comprobarRotar(Forma[] ori, boolean[] cStatus,
            boolean[] eStatus)
    {
        Forma[] clones = clonar(ori);
        for (int i = 0; i < ori.length; i++)
        {
            /*
             * metodo equals y/o clone no confiables
             */
            if ((cStatus[i] & !eStatus[i]) || (!cStatus[i] & !eStatus[i]))
            {
                System.out.println("La clase " + ori[i].getClass().getName()
                        + " NO se le puede corregir ROTAR");
            }
            /*
             * Solo se puede utilizar el metodo equals
             */
            else if (!cStatus[i] & eStatus[i])
            {
                System.out.println("Se revisa Clase "
                        + ori[i].getClass().getName() + "sin clone()");
                System.out.println("ANTES DE ROTAR");
                System.out.println(ori[i].toString());
                ori[i].rotar(new Point(0, 0), 2 * Math.PI);
                System.out.println("DESPUES DE ROTAR x rotar"
                        + "(new Point(0,0), 2*Math.PI)");
                System.out.println(ori[i].toString());
            }
            /*
             * Se puede utilizar clone y luego rotar la figura y devolverla para
             * comprobar con el original
             */
            else if (cStatus[i] & eStatus[i])
            {
                System.out.println("Se revisa Clase "
                        + ori[i].getClass().getName()
                        + " con clone()\n INICIAL:");
                System.out.println(clones[i].toString());
                //se rotan dos veces en PI grados respecto a (0,0)
                clones[i].rotar(new Point(0, 0), Math.PI);
                System.out.println("Se ha rotado en PI");
                clones[i].rotar(new Point(0, 0), Math.PI);
                if (clones[i].equals(ori[i]))
                    System.out.println("La CLase "
                            + ori[i].getClass().getName()
                            + " realiza OK ROTAR()");
                else
                {
                    System.out.println("La CLase "
                            + ori[i].getClass().getName()
                            + " NO realiza OK ROTAR()");
                    System.out.println(clones[i].toString());
                }

            }
        }

    }

    private static void comprobarEscalar(Forma[] ori)
    {
        for (int i = 0; i < ori.length; i++)
        {
            System.out.println("Escalando Clase " + ori[i].getClass().getName()
                    + "\n Datos iniciales: ");
            System.out.println(ori[i].toString());
            ori[i].escalar(new Point(0, 0), 2);
            System.out.println("Se ha ESCALADO escalar(new Point(0,0), 2)");
            System.out.println(ori[i].toString());
        }

    }
}