import java.util.Arrays;

public class Jugada {
    String posibleJugada = "CARTA ALTA";

    public Jugada() {

    }

    // ----------------------------------------------------------------------------------------------------
    // ---------------------- Metodos Auxiliares ----------------------

    // Metodo para Crear el Array con los objetos Carta
    public String[] crearArray(Carta carta1, Carta carta2, Carta carta3, Carta carta4, Carta carta5) {
        String[] mano = new String[5];
        mano[0] = carta1.valorPalo();
        mano[1] = carta2.valorPalo();
        mano[2] = carta3.valorPalo();
        mano[3] = carta4.valorPalo();
        mano[4] = carta5.valorPalo();
        return mano;
    }

    // Metodo para separar los los valores numericos de los palos
    public int[] valoresNumericosEnArray(String[] mano) {
        int[] valorNumerico = new int[5];

        for (int i = 0; i < mano.length; i++) {
            // Guardo en var tipo String el primer caracter del String, 
            // que seria el valor numerico de la mano
            String valorNumericoString = String.valueOf(mano[i].charAt(0));

            // Reasignamos el valor a entero en caso que encontremos alguna de las letras posibles
            switch (valorNumericoString) {
                case "A":
                    valorNumerico[i] = 1;
                    break;
                case "T":
                    valorNumerico[i] = 10;
                    break;
                case "J":
                    valorNumerico[i] = 11;
                    break;
                case "Q":
                    valorNumerico[i] = 12;
                    break;
                case "K":
                    valorNumerico[i] = 13;
                    break;
                default:
                    // En caso de no encontrar ninguna letra, convertimos el string a entero
                    valorNumerico[i] = Integer.parseInt(valorNumericoString);
                    break;
            }
        }
        // Ordeno el Array Numerico de menor a mayor
        Arrays.sort(valorNumerico);
        return valorNumerico;
    }

    // Metodo para separar los los palos de los valores numericos
    public String[] palosEnUnArray(String[] mano) {
        String[] valorPalo = new String[5];
        for (int i = 0; i < mano.length; i++) {
            String valorPaloString = String.valueOf(mano[i].charAt(1));
            valorPalo[i] = valorPaloString;
        }
        return valorPalo;
    }

    // Metodo para retornar el contador de coincidencias
    // Esta forma de comparar los elementos del array, se realiza de la misma forma en todos los casos excepto en el metodo
    // EscaleraDeColor. Por esta razon, creamos esta funcion para ejecutarse varias veces sin la necesidad de repetir codigo.
    // En realidad, esta es la intencion de todos los metodos auxiliares.
    public int contadorDeCartasCoincidentes(int[] mano) {
        int contador = 0;
        for (int i = 0; i < mano.length - 1; i++) {
        // Si el numero en la posicion [i] es igual al que esta en la sig. posicion, el contador se aumenta.
            if (mano[i] == mano[i + 1]) {
                contador++;
            }
        }
        return contador;
    }

    // Metodo para ejecutar todos los metodos de comprobacion
    public void ejecutarComprobaciones(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5) 
    {
        escaleraColor(c1, c2, c3, c4, c5);
        poker(c1, c2, c3, c4, c5);
        full(c1, c2, c3, c4, c5);
        trio(c1, c2, c3, c4, c5);
        parDoble(c1, c2, c3, c4, c5);
        par(c1, c2, c3, c4, c5);
    }

    // Metodo para imprimir que jugada seria. (Poker, Escalera de color, full, etc.)
    public void imprimirResultado () 
    {
        System.out.println(this.posibleJugada);
    } 

    // ----------------------------------------------------------------------------------------------------
    // ---------------------- Metodos De Comprobacion ----------------------

    //                          Metodo Escalera De Color
    public void escaleraColor(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5) {
        String[] mano = crearArray(c1, c2, c3, c4, c5);

        int[] manoNumerica = valoresNumericosEnArray(mano);
        String[] manoPalos = palosEnUnArray(mano);

        // Impresion de la mano para que se vea en onsola y se compruebe si esta bien la Jugada 
        for ( int i = 0; i  < manoNumerica.length; i++) 
        {
            System.out.println("Linea 110 " + manoNumerica[i]);
        }

        int contador1 = 0;
        for (int i = 0; i < manoNumerica.length - 1; i++) {
            // Si el dado en la posicion [0] es 1 y le sumas 1, el resultado debe ser igual
            // al dado de la posicion siguiente
            if (manoNumerica[i] + 1 == manoNumerica[i + 1]) {
                contador1++;
            }
        }

        int contador2 = 0;
        for (int i = 0; i < manoPalos.length - 1; i++) {
            if (manoPalos[i].equals(manoPalos[i + 1])) {
                contador2++;
            }
        }

        //              ----------- Comprobaciones -----------
        if ((contador1 == 4 && contador2 == 4) || (contador1 == 3 && contador2 == 4 && manoNumerica[0] == 1 && manoNumerica[4] == 13)) 
        {
            this.posibleJugada = "ESCALERA DE COLOR";
        } else if (contador1 == 4 && contador2 < 4)
        {
            this.posibleJugada = "ESCALERA";
        } else if (contador2 == 4 && contador1 < 4) {
            this.posibleJugada = "COLOR";
        }
    }

    // ------------------------------------------------------------------------------------
    //                              Metodo POKER
    public void poker(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5) 
    {
        String[] mano = crearArray(c1, c2, c3, c4, c5);

        int[] manoNumerica = valoresNumericosEnArray(mano);
        int contador = contadorDeCartasCoincidentes(manoNumerica);

        //              ----------- Comprobaciones -----------
        if (contador == 3 && manoNumerica[1] == manoNumerica[2] && manoNumerica[2] == manoNumerica[3]) {
            this.posibleJugada = "POKER";
        }
    }

    // ------------------------------------------------------------------------------------
    //                              Metodo FULL
    public void full(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5) 
    {
        String[] mano = crearArray(c1, c2, c3, c4, c5);

        int[] manoNumerica = valoresNumericosEnArray(mano);
        int contador = contadorDeCartasCoincidentes(manoNumerica);

        //              ----------- Comprobaciones -----------
        if ((contador == 3 && manoNumerica[2] != manoNumerica[3] && manoNumerica[3] == manoNumerica[4])  || (contador == 3 && manoNumerica[2] != manoNumerica[1] && manoNumerica[0] == manoNumerica[1])) {
            this.posibleJugada = "FULL";
        }
    }

    // ------------------------------------------------------------------------------------
    //                              Metodo TRIO
    public void trio(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5)  
    {
        String[] mano = crearArray(c1, c2, c3, c4, c5);

        int[] manoNumerica = valoresNumericosEnArray(mano);
        int contador = contadorDeCartasCoincidentes(manoNumerica);

        // TRIO: tres cartas del mismo valor y dos de un valor diferente
        // Las 3 opciones posibles son:
        // 1,1,1,2,4
        // 1,2,4,4,4
        // 1,2,2,2,4

        //              ----------- Comprobaciones -----------
        if ( (contador == 2 && manoNumerica[0] == manoNumerica[1] && manoNumerica[1] == manoNumerica[2] 
        && manoNumerica[2] != manoNumerica[3] && manoNumerica[3] != manoNumerica[4] ) || 
        
        (contador == 2 && manoNumerica[0] != manoNumerica[1] && manoNumerica[1] != manoNumerica[2]
        && manoNumerica[2] == manoNumerica[3] && manoNumerica[3] == manoNumerica[4]) || 
        
        (contador == 2 && manoNumerica[0] != manoNumerica[1] && manoNumerica[1] == manoNumerica[2] 
        && manoNumerica[2] == manoNumerica[3] && manoNumerica[3] != manoNumerica[4]) ) 
        {
            this.posibleJugada = "TRIO";
        }


    }

    public void parDoble(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5) 
    {
        String[] mano = crearArray(c1, c2, c3, c4, c5);

        int[] manoNumerica = valoresNumericosEnArray(mano);
        int contador = contadorDeCartasCoincidentes(manoNumerica);

        // PAR DOBLE: dos cartas del mismo valor, otras dos cartas del mismo valor diferente al anterior y una carta desemparda
        // Las 3 opciones posibles son:
        // 1,1,2,2,4
        // 1,2,2,4,4
        // 1,1,2,4,4

        //              ----------- Comprobaciones -----------
        if ( (contador == 2 && manoNumerica[0] == manoNumerica[1] && manoNumerica[1] != manoNumerica[2] && 
              manoNumerica[2] == manoNumerica[3] && manoNumerica[3] != manoNumerica[4]) ||

              (contador == 2 && manoNumerica[0] != manoNumerica[1] && manoNumerica[1] == manoNumerica[2] && 
              manoNumerica[2] != manoNumerica[3] && manoNumerica[3] == manoNumerica[4]) ||

              (contador == 2 && manoNumerica[0] == manoNumerica[1] && manoNumerica[1] != manoNumerica[2] && 
              manoNumerica[2] != manoNumerica[3] && manoNumerica[3] == manoNumerica[4]) 
            )     
        {
            this.posibleJugada = "PAR DOBLE";
        }
    }

    public void par(Carta c1, Carta c2, Carta c3, Carta c4, Carta c5) 
    {
        String[] mano = crearArray(c1, c2, c3, c4, c5);
        int[] manoNumerica = valoresNumericosEnArray(mano);
        int contador = contadorDeCartasCoincidentes(manoNumerica);

        // Par (one pair) es una mano formada por dos cartas del mismo valor más tres cartas adicionales de valor distinto de la pareja 
        // y distintas entre sí. 
        // Las 4 opciones disponibles son:        
        // 1,1,2,3,4 
        // 1,2,3,4,4
        // 1,2,2,3,4
        // 1,2,3,3,4

        //              ----------- Comprobaciones -----------
        if ( (contador == 1 && manoNumerica[0] == manoNumerica[1] && manoNumerica[1] != manoNumerica[2] && 
              manoNumerica[2] != manoNumerica[3] && manoNumerica[3] != manoNumerica[4]) ||

              (contador == 1 && manoNumerica[0] != manoNumerica[1] && manoNumerica[1] != manoNumerica[2] && 
              manoNumerica[2] != manoNumerica[3] && manoNumerica[3] == manoNumerica[4]) ||

              (contador == 1 && manoNumerica[0] != manoNumerica[1] && manoNumerica[1] == manoNumerica[2] && 
              manoNumerica[2] != manoNumerica[3] && manoNumerica[3] != manoNumerica[4]) ||

              (contador == 1 && manoNumerica[0] != manoNumerica[1] && manoNumerica[1] != manoNumerica[2] && 
              manoNumerica[2] == manoNumerica[3] && manoNumerica[3] != manoNumerica[4])
            )     
        {
            this.posibleJugada = "PAR";
        }
    }
}