package juego;

public class CuatroEnLinea {
    private String jugadorRojo;
    private String jugadorNegro;
    private String jugadorGanador;

    private Casillero[][] tablero;
    private int jugadaNumero = 0;
    private boolean huboGanador = false;

    public CuatroEnLinea(int filas, int columnas, String jugadorRojo, String jugadorNegro) {
		//*Crea un objeto de la clase Mensajes.
		Mensajes mensaje = new Mensajes();

		if (filas < 4 || columnas < 4){
			mensaje.startWhitError();
			throw new Error("Tanto las filas como las columnas deben ser mayores o iguales a 4");

		}
		this.jugadorNegro = jugadorNegro;
		this.jugadorRojo = jugadorRojo;
		this.tablero = new Casillero[columnas][filas];
		for (int i = 0; i < columnas; i++){
			for(int j =0; j < filas; j++){
				tablero[i][j] = Casillero.VACIO;


			}
		}
		mensaje.start();
	}

    /**
     * post: devuelve la cantidad máxima de fichas que se pueden apilar en el
     * tablero.
     */
    public int contarFilas() {
        return tablero.length;
    }

    /**
     * post: devuelve la cantidad máxima de fichas que se pueden alinear en el
     * tablero.
     */
    public int contarColumnas() {
        return tablero[0].length;
    }

    /**
     * pre : fila está en el intervalo [1, contarFilas()], columnas está en el
     * intervalo [1, contarColumnas()]. post: indica qué ocupa el casillero en
     * la posición dada por fila y columna.
     *
     * @param fila
     * @param columna
     */
    public Casillero obtenerCasillero(int fila, int columna) {
        fila--;
        columna--;

        if ((fila < 0) || (fila >= contarFilas()) || (columna < 0)
                || (columna >= contarColumnas())) {
            throw new Error(
                    "El índice de fila/columna está fuera del intervalo.");
        }

        return tablero[fila][columna];
    }

    /**
     * pre : el juego no terminó, columna está en el intervalo [1,
     * contarColumnas()] y aún queda un Casillero.VACIO en la columna indicada.
     * post: deja caer una ficha en la columna indicada.
     *
     * @param columna
     */
    public void soltarFicha(int columna) {
	columna--;  //*Se resta uno a la columna dado que el parámetro esperado sera una unidad superior*/


        int ultimoLugarVacio = 0; //*Guarda posicion del ultimo lugar vacio encontrado*/
        boolean lugarVacio = false;

        for (int i = 0; i < tablero.length; i++) { //*Se recorre el arreglo de abajo para arriba buscando el ultimo lugar vacio*//
            if (tablero[i][columna] == Casillero.VACIO) {
                lugarVacio = true; //Si cumple la condicion lugarVacio es verdadero*/
                ultimoLugarVacio = i;  //* Se guarda la posicion del lugar vacio/*
                i = tablero.length; 	//* Termina el ciclo for*/
            }
        }

        boolean puedeSoltar = (termino() == false) && (columna >= 0) //*Comprueba la condicion del juego y la jugada que se pretende hacer*/
                && (columna < contarColumnas()) && lugarVacio;

        if (puedeSoltar) {
            if (ultimoLugarVacio < tablero.length) {
                for (int i = ultimoLugarVacio + 1; i < tablero.length; i++) {
                    if (tablero[i][columna] == Casillero.VACIO) {
                        ultimoLugarVacio = i;
                    }
                }
            }

            tablero[ultimoLugarVacio][columna] = ((jugadaNumero % 2) == 0 ? Casillero.ROJO
                    : Casillero.AMARILLO);

            procesarGanador();
            jugadaNumero++;
        }
    }

    /**
     * post: indica si el juego terminó porque uno de los jugadores ganó o no
     * existen casilleros vacíos.
     */
    public boolean termino() {
        if (hayGanador()) {
            return true;
        }

        for (int i = 0; i < contarFilas(); i++) {
            for (int j = 0; j < contarColumnas(); j++) {
                if (tablero[i][j] == Casillero.VACIO) {
                    return false;
                }
            }
        }

        return true;
    }

    //Con el casillero podemos saber qué jugador de qué color fue el ganador:
    private boolean hayCuatroCasillerosSeguidos(Casillero color, int x, int y) {
        if (tablero[x][y] == color) {
            int horizontal = 1;
            int vertical = 1;
            int diagonalDerecha = 1;
            int diagonalIzquierda = 1;

            for (int i = 1; i < 4; i++) {
                boolean puedeEnX = ((x + i) < contarFilas());
                boolean puedeEnY = ((y - i) >= 0);

                if (puedeEnX){
                    if (tablero[x + i][y] == color) {
                        horizontal++;
                        if (horizontal == 4)
                            return true;
                    }
                }

                if (puedeEnY){
                    if (tablero[x][y - i] == color) {
                        vertical++;
                        if (vertical == 4)
                            return true;
                    }
                }

                if (puedeEnX && ((y + i) < contarColumnas())){
                    if (tablero[x + i][y + i] == color) {
                        diagonalDerecha++;
                        if (diagonalDerecha == 4)
                            return true;
                    }
                }

                if (((x - i) > 0) && ((y + i) < contarColumnas())){
                    if (tablero[x - i][y + i] == color) {
                        diagonalIzquierda++;
                        if (diagonalIzquierda == 4)
                            return true;
                    }
                }
            }

        }

        return false;
    }

    /**
     * post: indica si el juego terminó y tiene un ganador.
     */
    private void procesarGanador() {
        for (int x = 0; x < contarFilas(); x++) {
            for (int y = 0; y < contarColumnas(); y++) {
                if ((jugadaNumero % 2) == 0) {
                    if (hayCuatroCasillerosSeguidos(Casillero.ROJO, x, y)){
                        jugadorGanador = jugadorRojo;
                        huboGanador = true;
                    }
                } else {
                    if (hayCuatroCasillerosSeguidos(Casillero.AMARILLO, x, y)){
                        jugadorGanador = jugadorNegro;
                        huboGanador = true;
                    }
                }
            }
        }
    }

    /**
     * post: indica si el juego terminó y tiene un ganador.
     */
    public boolean hayGanador() {
        return huboGanador;
    }

    /**
     * pre : el juego terminó. post: devuelve el nombre del jugador que ganó el
     * juego.
     */
    public String obtenerGanador() {
        return jugadorGanador;
    }
}