package uniandes.cupi2.asaltoBanco.mundo;

import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;

/**
 * Clase que representa la Boveda del Banco
 * @author Juan
 */
public class BovedaBanco
{
    // ---------------------------------------------------
    // Constantes
    // ---------------------------------------------------

    /**
     * Constante que representa el alto del tablero
     */
    public final static int ALTO = 12;

    /**
     * Constante que representa el ancho del tablero
     */
    public final static int ANCHO = 12;

    /**
     * Constante para mover al noroeste
     */
    public final static String NOROESTE = "Noroeste";

    /**
     * Constante para mover al norte
     */
    public final static String NORTE = "Norte";

    /**
     * Constante para mover al noreste
     */
    public final static String NORESTE = "Noreste";

    /**
     * Constante para mover al oeste
     */
    public final static String OESTE = "Oeste";

    /**
     * Constante para mover al este
     */
    public final static String ESTE = "Este";

    /**
     * Constante para mover al suroeste
     */
    public final static String SUROESTE = "Suroeste";

    /**
     * Constante para mover al sur
     */
    public final static String SUR = "Sur";

    /**
     * Constante para mover al sureste
     */
    public final static String SURESTE = "Sureste";

    // ---------------------------------------------------
    // Atributos
    // ---------------------------------------------------

    /**
     * Fila inicial de la posición del ladrón
     */
    private int filaInicial;

    /**
     * Columna inicial de la posición del ladrón
     */
    private int colInicial;

    /**
     * Fila de la posición del Ladrón
     */
    private int filaLadron;

    /**
     * Columna de la posición del Ladrón
     */
    private int colLadron;

    /**
     * Vidas del ladrón
     */
    private int vidas;

    /**
     * Tablero de juego
     */
    private Casilla[][] casillas;

    // ---------------------------------------------------
    // Constructores
    // ---------------------------------------------------

    /**
     * Crea una nueva boveda
     * @param f Archivo que contiene la localización en el tablero de los elementos del juego
     * @throws Exception <li>Si hay problemas cargando el archivo
     */
    public BovedaBanco( File f ) throws Exception
    {
        // Inicializa el tablero con todas las casillas vacias
        casillas = new Casilla[ALTO][ANCHO];
        for( int i = 0; i < ALTO; i++ )
        {
            for( int j = 0; j < ANCHO; j++ )
            {
                casillas[ i ][ j ] = new Casilla( );
            }
        }
        try
        {
            // Inicializa el juego con los datos del archivo
            Properties p = cargar( f );
            inicializarTablero( p );
            vidas = 3;
        }
        catch( Exception e )
        {
            throw new Exception( "Error al cargar el archivo" );
        }
    }

    /**
     * Carga la información del juego con sus alarmas y demás
     * @param f Archivo que contiene la descripción del juego
     * @return Objeto de la clase Properties con la información del archivo
     * @throws Exception <li>Si el formato es inválido
     */
    private Properties cargar( File f ) throws Exception
    {
        Properties p = new Properties( );
        FileInputStream fs = new FileInputStream( f );
        try
        {
            p.load( fs );
            fs.close( );
        }
        catch( Exception e )
        {
            throw new Exception( "Formato inválido" );
        }
        return p;

    }

    /**
     * Inicializa el tablero con sus elementos
     * @param p Contiene la información cargada del archivo
     */
    private void inicializarTablero( Properties p )
    {
        // Inicializa la entrada del juego
        String strFilaEntrada = p.getProperty( "tablero.entrada.fila" );
        String strColEntrada = p.getProperty( "tablero.entrada.col" );
        int filaEntrada = Integer.parseInt( strFilaEntrada );
        int colEntrada = Integer.parseInt( strColEntrada );
        casillas[ filaEntrada ][ colEntrada ].cambiarTipo( Casilla.ENTRADA );

        // Inicializa la posición del ladrón con respecto a la entrada
        filaLadron = filaEntrada;
        colLadron = colEntrada;
        filaInicial = filaEntrada;
        colInicial = colEntrada;

        // Inicializa la salida del juego
        String strFilaSalida = p.getProperty( "tablero.salida.fila" );
        String strColSalida = p.getProperty( "tablero.salida.col" );
        int filaSalida = Integer.parseInt( strFilaSalida );
        int colSalida = Integer.parseInt( strColSalida );
        casillas[ filaSalida ][ colSalida ].cambiarTipo( Casilla.SALIDA );

        // Inicializa las alarmas del juego
        String strAlarmas = p.getProperty( "tablero.alarmas" );
        int numAlarmas = Integer.parseInt( strAlarmas );
        for( int i = 0; i < numAlarmas; i++ )
        {
            String strFila = p.getProperty( "tablero.alarma" + i + ".fila" );
            String strCol = p.getProperty( "tablero.alarma" + i + ".col" );
            int fila = Integer.parseInt( strFila );
            int col = Integer.parseInt( strCol );
            casillas[ fila ][ col ].cambiarTipo( Casilla.ALARMA );
        }
    }

    // ---------------------------------------------------
    // Métodos
    // ---------------------------------------------------

    /**
     * Retorna la fila de la posición del ladrón<br>
     * @return La fila de la posición del ladrón
     */
    public int darFila( )
    {
        return filaLadron;
    }

    /**
     * Retorna la columna de la posición del ladrón
     * @return La columna de la posición del ladrón
     */
    public int darColumna( )
    {
        return colLadron;
    }

    /**
     * Retorna la fila inicial de la posición del ladrón
     * @return La fila inicial de la posición del ladrón
     */
    public int darFilaInicial( )
    {
        return filaInicial;
    }

    /**
     * Retorna la columna inicial de la posición del ladrón
     * @return La columna inicial de la posición del ladrón
     */
    public int darColumnaInicial( )
    {
        return colInicial;
    }
    /**
     * Retorna las vidas restantes del ladrón
     * @return Las vidas restantes del ladrón
     */
    public int darVidas( )
    {
        return vidas;
    }

    /**
     * Retorna el tablero de juego
     * @return El tablero de juego
     */
    public Casilla[][] darTablero( )
    {
        return casillas;
    }

    /**
     * Retorna el número de alarmas que rodean al ladrón
     * @return El número de alarmas que rodean al ladrón
     */
    public int darAlarmasVecinas( )
    {
        int contador = 0;

        for( int i = filaLadron - 1; i <= ( filaLadron + 1 ); i++ )
        {
            if( i < 0 )
            {
                break;
            }
            for( int j = colLadron - 1; j <= ( colLadron + 1 ); j++ )
            {
                if( j < 0 )
                {
                    break;
                }
                else if( casillas[ i ][ j ].darTipo( ) == Casilla.ALARMA )
                {
                    contador++;
                }
            }
        }
        return contador;
    }

    /**
     * Reinicia la posición del ladrón a su posición inicial<br>
     * <b>post:</b> La posición del ladrón ha sido reiniciada
     */
    public void reiniciarPosicion( )
    {
        filaLadron = filaInicial;
        colLadron = colInicial;
    }

    /**
     * Método que indica si el ladrón puede moverse en la dirección que se da como parametro<br>
     * <b>pre:</b> Se ha designado una de las direcciones posibles ya establecidas para mover al ladrón<br>
     * <b>post:</b> Se sabe si el movimiento del ladrón en la dirección dada es posible o no
     * @param dir Dirección la que se quiere que se mueva el ladrón
     * @return <li><b>true</b> si el ladrón puede moverse en la dirección dada cómo parametro <li><b>false</b> si el ladrón no puede moverse en la dirección dada cómo
     *         parametro
     */
    public boolean podriaMoverse( String dir )
    {
        boolean resp = true;

        if( dir == NOROESTE )
        {
            if( colLadron-- < 0 || filaLadron-- < 0 )
            {
                resp = false;
            }
        }
        else if( dir == NORTE )
        {
            if( filaLadron-- < 0 )
            {
                resp = false;
            }
        }
        else if( dir == NORESTE )
        {
            if( colLadron++ > 12 || filaLadron-- < 0 )
            {
                resp = false;
            }
        }
        else if( dir == ESTE )
        {
            if( colLadron < 0 )
            {
                resp = false;
            }
        }
        else if( dir == OESTE )
        {
            if( colLadron++ > 12 )
            {
                resp = false;
            }
        }
        else if( dir == SUROESTE )
        {
            if( colLadron-- < 0 || filaLadron++ > 12 )
            {
                resp = false;
            }
        }
        else if( dir == SUR )
        {
            if( filaLadron++ > 12 )
            {
                resp = false;
            }
        }
        else if( dir == SURESTE )
        {
            if( colLadron++ > 12 || filaLadron++ > 12 )
            {
                resp = false;
            }
        }

        return resp;
    }

    /**
     * Método que mueve al ladrón en la dirección dada cómo parametro<br>
     * <b>pre:</b> El ladrón se encuentra en algún lugar de la matriz<br>
     * <b>post:</b> El ladrón se ha movido
     * @param dir Dirección en la que se quiere mover al ladrón
     * @throws Exception <li>Si el ladrón no se puede mover en la dirección especificada
     */
    public void moverLadron( String dir ) throws Exception
    {
        boolean movPosible = podriaMoverse( dir );

        if( movPosible == false )
        {
            throw new Exception( "El ladrón no puede moverse en esa dirección debido al tamaño del campo de juego" );
        }
        else
        {
            System.out.println("col:"+ colLadron +", fila:" +filaLadron);
            if( dir.equals( NOROESTE ) )
            {
                colLadron = colLadron--;
                filaLadron = filaLadron--;
            }
            else if( dir.equals( NORTE ) )
            {
                filaLadron = filaLadron--;
            }
            else if( dir.equals( NORESTE ) )
            {
                colLadron = colLadron++;
                filaLadron = filaLadron--;
            }
            else if( dir.equals( OESTE ) )
            {
                System.out.println( colLadron );
                colLadron = colLadron - 1;
                System.out.println( colLadron );
            }
            else if( dir.equals( ESTE ) )
            {
                colLadron = colLadron + 1;
            }
            else if( dir.equals( SUROESTE ) )
            {
                colLadron = colLadron--;
                filaLadron = filaLadron++;
            }
            else if( dir.equals( SUR ) )
            {
                filaLadron = filaLadron--;
            }
            else if( dir.equals( SURESTE ) )
            {
                colLadron = colLadron++;
                filaLadron = filaLadron++;
            }
        }
        System.out.println("col:"+ colLadron +", fila:" +filaLadron);
    }

    /**
     * Método que resta una vida al ladrón cuando este es atrapado<br>
     * <b>post:</b> Una vida ha sido restada
     * @throws Exception <li>Si el ladrón no tiene más vidas
     */
    public void restarVidas( ) throws Exception
    {
        vidas--;

        if( vidas == 0 )
        {
            throw new Exception( "¡Usted no tiene más vidas! \n" + "¡USTED HA PERDIDO!" );
        }
    }
    // ---------------------------------------------------
    // Puntos de extensión
    // ---------------------------------------------------

    /**
     * Método de extensión 1
     * @return Respuesta 1
     */
    public String metodo1( )
    {
        return "Respuesta 1";
    }

    /**
     * Método de extensión 2
     * @return Respuesta 2
     */
    public String metodo2( )
    {
        return "Respuesta 2";
    }
}