import java.util.*;

import javax.jws.Oneway;


public class Aplicacion {


    public static void main(String[] args) {


        System.out.println("Bienvenido al programa!");

        /** Aquí tenemos el Arraylist */
        ArrayList<Objeto> miArrayList = new ArrayList<Objeto>();

        boolean salir = false;

        while(!salir){

            System.out.println("========== MENÚ ==========");
            System.out.println("1) Ingresar ##OBJETO## ");
            System.out.println("2) Buscar y mostrar datos de un ##OBJETO## por su ##IDENTIFICADOR## ");
            System.out.println("3) Encontrar el objeto que cumpla ##CARACTERÍSTICA (MÁS GRANDE, MÁS CHICO, ETC.## ");
            System.out.println("4) Encontrar el ##TOTAL DE ALGO## ");



            int op1 = Leer.datoInt();

            switch(op1){

            /****************************************/
            /** INICIO DEL CASO 1: INGRESAR OBJETO **/
            /****************************************/
            case 1:{
                /** Supongamos que tenemos la clase Objeto y dos clases que heredan de ésta: Tipo1 y Tipo2.*/

                /** Es posible que en vez de crear directamente algo tipo Objeto, tengamos que crearlo
                 * a partir de una clase que hereda de objeto. En ese caso usamos un switch como el siguiente
                 * ANTES de crear objetoNuevo*/

                /** Primero, declaramos la variable que indicará el nombre de nuestro objeto y le damos un valor inicial*/
                Objeto nuevoObjeto = null;



                /** El while sirve para verificar que se ingresó una opción correcta.*/
                while(nuevoObjeto==null){

                    /** Ahora le pediremos al usuario que indique qué tipo de objeto desea crear*/
                    // System.out.println("Elija el tipo de objeto");
                    // System.out.println("1) Objeto del tipo 1"); // Ejemplo: Trabajador a honorario
                    // System.out.println("2) Objeto del tipo 2"); // Ejemplo: Trabajador a plazo fijo
                    int tipoDeObjeto = Leer.datoInt();

                    /** Hacemos un switch sobre la opción que eligió el usuario */
                    switch(tipoDeObjeto){

                    case 1:{
                        /** Pedimos al usuario los datos necesarios para crear un objeto tipo 1 */
                        // int precio = Leer.datoInt();
                        // String nombre = Leer.dato();
                        // double estatura = Leer.datoDouble();

                        /** Creamos el objeto usando los parámetros de la clase Tipo1 (la cual hereda de Objeto) */
                        // Objeto nuevoObjeto = new Tipo1(precio,nombre,estatura);
                    }break;

                    case 2:{
                        /** Pedimos al usuario los datos necesarios para crear un objeto tipo 2 */
                        // int precio = Leer.datoInt();
                        // String nombre = Leer.dato();
                        // double estatura = Leer.datoDouble();
                        // double peso = Leer.datoDouble();
                        // String fechaNacimiento = Leer.dato();

                        /** Creamos el objeto usando los parámetros de la clase Tipo2 (la cual hereda de Objeto) */
                        // Objeto nuevoObjeto = new Tipo2(precio,nombre,estatura,peso,fechaNacimiento);
                    }break;
                    }

                    /**Si llegado a este punto, el objeto todavía es null, significa que el usuario ingresó
                     * una opción que no era ni "1" ni "2" y por lo tanto no se entró a ningún caso del switch.
                     * En tal caso, volveremos al inicio del while*/
                    if(nuevoObjeto==null){
                        System.out.println("Elija una opción válida");
                    }

                } /**Justo aquí termina el while(objeto==null)*/

                /** Saliendo del while, el objeto ya fue creado*/

                /** Ahora, verificamos que no haya duplicados llamando al método revisarSiHayDuplicados.
                 * Este métdodo recibe un ArrayList y un Objeto. Si hay un duplicado del objeto en el ArrayList
                 * devuelve true. En caso contrario, false. */
                boolean hayDuplicados = revisarSiHayDuplicados(miArrayList , nuevoObjeto);

                /** Si es que no hay duplicados, metemos el objeto en el ArrayList */
                if( !hayDuplicados ){
                    miArrayList.add( nuevoObjeto );
                    System.out.println("Se agregó exitosamente el objeto");
                }
                /**En caso contrario, le indicamos al usuario*/
                else{
                    System.out.println("Se trató de ingresar, pero se encontró duplicado.");
                }



            }break;
            /****************************************/
            /**   FIN DEL CASO 1: INGRESAR OBJETO  **/
            /****************************************/




            /****************************************/
            /** INICIO DEL CASO 2: BUSCAR OBJETO   **/
            /****************************************/
            case 2:{

                /** Pedimos al usuario que ingrese el identificador*/
                System.out.println("Ingrese identificador");

                /**Si el identificador es un int*/
                int id = Leer.datoInt();

                /**Si es un string */
                // String id = Leer.dato();

                /** Buscamos el objeto por su identificador*/
                Objeto encontrado = null;
                for(int i=0; i<miArrayList.size();i++){

                    /** Si el identificador es un int ...*/
                    if( miArrayList.get(i).getIDENTIFICADOR()  == id ){
                        encontrado = miArrayList.get(i);
                    }

                    /**Si el id es un string...*/
                    //  if( miArrayList.get(i).getIDENTIFICADOR().equals(id) ){
                    //  encontrado = miArrayList.get(i);
                    //  }

                }
                /** Si al salir del for, "encontrado todavía es null, significa que no lo encontramos*/
                if( encontrado == null ){
                    System.out.println("Objeto no encontrado");
                }
                /**En caso contrario, mostramos los datos del objeto */
                else{

                // System.out.println(" Nombre: "+encontrado.getNombre() );
                // System.out.println(" Precio: "+encontrado.gePrecio() );
                // etc...

                }




            }break;

            /****************************************/
            /**   FIN DEL CASO 2: BUSCAR OBJETO    **/
            /****************************************/




            /***********************************************************/
            /**   INICIO DEL CASO 3: BUSCAR POR UNA CARACTERÍSTICA    **/
            /***********************************************************/
            case 3:{
                /** En general, estos hay que verlos caso a caso. De todos modos a continuación
                 * pondremos el siguiente ejemplo:
                 *
                 *  "Buscar el objeto del Tipo1 que tenga el mayor precio y mostrar sus datos"*/


                /**Primero hacemos las variables que almacenarán dichos datos*/
                int mayorPrecio = 0;
                String nombre = "Ninguno";
                double estatura = 0;

                /**Hacemos un for que recorre todo el arreglo*/
                for(int i=0; i<miArrayList.size();i++){

                    /**Si es que el objeto actual es del Tipo1*/
                    if( miArrayList.get(i) instanceof Tipo1){

                        /** Si es que el precio del objeto actual es mayor
                         * al más grande que hayamos visto hasta ahora, lo reemplazamos */
                        int precioActual = miArrayList.get(i).getPrecio();
                        if( precioActual > mayorPrecio){
                            mayorPrecio = precioActual;
                            nombre = miArrayList.get(i).getNombre();
                            estatura = miArrayList.get(i).getEstatura();
                        }

                    }
                }

                /**Saliendo del for mostramos los datos */
                System.out.println("Datos:");
                System.out.println("Precio más alto:" +mayorPrecio);
                System.out.println("Nombre:"+nombre);
                System.out.println("Estatura:"+estatura);



            }break;
            /***********************************************************/
            /**   FIN DEL CASO 3: BUSCAR POR UNA CARACTERÍSTICA       **/
            /***********************************************************/




            /****************************************************************/
            /**   INICIO DEL CASO 4: USAR TODOS LOS ELEMENTOS PARA ALGO    **/
            /****************************************************************/
            case 4:{

                /** Al igual que el caso 3, aquí se ve caso a caso */

                /** A modo de ejemplo, mostremos el total de la suma
                 * de todos los pesos de los objetos del Tipo2 */

                /**Primero creamos la variable*/
                double totalPeso = 0;

                /**El típico for */
                for(int i=0 ; i<miArrayList.size() ; i++){

                    /**Si el objeto actual es del Tipo2, sumamos su peso */
                    if( miArrayList.get(i)   instanceof   Tipo2){

                        /** Hacemos un casteo porque solamente los objetos Tipo2 tienen
                         * el método getPeso() */

                        totalPeso = totalPeso + ((Tipo2) miArrayList.get(i)).getPeso();

                    }

                }

                System.out.println("El total es "+totalPeso);




            }break;
            /****************************************************************/
            /**   FIN DEL CASO 4: USAR TODOS LOS ELEMENTOS PARA ALGO       **/
            /****************************************************************/



            case 5:{
                salir = true;
            }break;

            }




        }
        System.out.println("Adiós!");



    }

    public static boolean revisarSiHayDuplicados( ArrayList<Objeto> unArrayList , Objeto unObjeto ){

        for(int i=0; i<unArrayList.size(); i++){

            /** Si el identificador es un número...*/
            if( unArrayList.get(i).getIDENTIFICADOR()  ==  unObjeto.getIDENTIFICADOR() ){
                return true;
            }

            /** En cambio, si el identificador es un String... */
            // if( unArrayList.get(i).getIDENTIFICADOR() .equals(  unObjeto.getIDENTIFICADOR() ) ){
            //  return true;
            // }
        }

        /** En cualquier caso, si salimos del for significa que no hay duplicados */
        return false;

    }

}