//Copyright 2010 Alvaro Diaz Sanchez
/*This program is free software: you can redistribute it and/or modify it under the terms of the GNU 
General Public License as published by the Free Software Foundation, either version 3 of the License, 
or (at your option) any later version.
This program is distributed in the hope that it will be useful, 
but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program. 
If not, see <http://www.gnu.org/licenses/>
*/
                            /*Fichero jugador.cpp*/

/**
    @file jugador.cpp
    @author Alvaro Diaz Sanchez
    @brief Fichero con definiciones de la clase Jugador asociado a la biblioteca libconectan.a
    */ 

#include <iostream>
#include <ctime>

/*******************************************************/
#include "jugador.h"
#include "graficos.h"
/******************************************************/
using namespace std;

bool Jugador :: EsTablero (const Tablero &juego, int x_pixel, int y_pixel)
{
    int filas_ventana, casillas_x, x_tablero_inicio = 0, x_tablero_final, y_tablero_inicio, y_tablero_final, casilla_centrada, alto_ficha, ancho_ficha, t_columnas, alto_cabecera, ancho_cabecera;
    bool es_tablero = false;
    
    alto_ficha = juego.GetAlturaFicha();
    ancho_ficha = juego.GetAnchoFicha();
    alto_cabecera = juego.GetAlturaCabecera();
    ancho_cabecera = juego.GetAnchoCabecera();
    t_columnas = juego.ColumnasTablero();
    filas_ventana = FilasVentana ();
    casillas_x = t_columnas * ancho_ficha;
    y_tablero_inicio = alto_cabecera;
    y_tablero_final = filas_ventana - 40; 
    
    //Comprueba que se encuentre entre las casillas del tablero
    if (casillas_x >= ancho_cabecera)
        x_tablero_final = casillas_x;   
    else{
        casilla_centrada = (ancho_cabecera - casillas_x) / 2;
        x_tablero_inicio = casilla_centrada;
        x_tablero_final = ancho_cabecera - casilla_centrada;
    }

    if (x_tablero_inicio <= x_pixel && x_pixel < x_tablero_final)
        es_tablero = true;

    if (y_tablero_inicio <= y_pixel && y_pixel < y_tablero_final && es_tablero)
        es_tablero = true;
    else
        es_tablero = false;

    return es_tablero;
}

void Jugador :: LocalizarPosicion (const Tablero &juego, int casillas_x, int pixel_x, unsigned int &columna_x)
{
    int filas_ventana, pos_ficha, casilla_centrada, ancho_ficha, alto_cabecera, ancho_cabecera;
    bool acabar = false;
    
    ancho_ficha = juego.GetAnchoFicha();
    alto_cabecera = juego.GetAlturaCabecera();
    ancho_cabecera = juego.GetAnchoCabecera();
    casilla_centrada = (ancho_cabecera - casillas_x) / 2;

    //Transformar las dimensiones en la columna
    if (casillas_x >= ancho_cabecera){
        for (columna_x = 0; !acabar; columna_x++){
            pos_ficha = columna_x * ancho_ficha;
            if (pos_ficha <= pixel_x && pixel_x < pos_ficha + ancho_ficha)
                acabar = true;
        }    
    }
    else{
        for (columna_x = 0; !acabar; columna_x++){
            pos_ficha = (columna_x * ancho_ficha) + casilla_centrada;
            if (pos_ficha <= pixel_x && pixel_x < pos_ficha + ancho_ficha)
                acabar = true;
        }
        
    }

    columna_x--;

}

unsigned int Jugador :: JugadorAleatorio (const Tablero &juego) const
{
    unsigned int columna;
    //Devolver al azar una columna entre 0 y ColumnasConectan(i)
    srand ( time(0) );    

    columna = (0 + (rand() % juego.ColumnasTablero()));

    return (columna);   
}

unsigned int Jugador :: JugadorInteligente (const Tablero &juego, int linea, int valor) const
{

    int fila, columna, iterador, l_iterador, filas = juego.FilasTablero(), columnas = juego.ColumnasTablero();
    unsigned int columna_echar;
    int cadena[columnas];
    bool parar = false;
    
    for (l_iterador = linea - 1; l_iterador >= 1 && !parar; l_iterador--){     
        
        iterador = l_iterador - 1;
        //Elaborar la secuencia de fichas a buscar
        for (columna = 0; columna < l_iterador; columna++)
            cadena[columna] = valor;   

        //Buscar esa secuencia
        for (fila = 0; fila < filas && !parar; fila++){ 
            for (columna = columnas - 1; columna >= 0 && !parar; columna--){
                if (juego.GetTablero (fila, columna)  == cadena[iterador] && juego.GetTablero (fila, (columna - l_iterador)) == 0)
                    iterador--;
                else
                    iterador = l_iterador - 1;
                //Si la encuentra devuelve la columna
                if (iterador < 0){
                    columna_echar = columna - 1;
                    parar = true;
                }
            }
            iterador = l_iterador - 1 ;
        } 
    }
    //Si no encuentra nada echa la ficha al azar
    if (!parar){
        srand ( time(0) );    
        columna_echar = (0 + (rand() % columnas));
    }
    
    return (columna_echar);
}

void Jugador :: JugadorManual (const Tablero &juego, unsigned int &columna_tablero)
{
    int boton, coordenada_x, coordenada_y, casillas_x, t_columnas, ancho_ficha;
    bool tablero;
    
    t_columnas = juego.ColumnasTablero();
    ancho_ficha = juego.GetAnchoFicha();
    casillas_x = t_columnas * ancho_ficha;
    
    //Obtener las coordenadas donde se ha pulsado
    do{
        boton = ObtenerClick (coordenada_x, coordenada_y);
        //Comprobar que sea el tablero
        tablero = EsTablero (juego, coordenada_x, coordenada_y);
        Esperar (200);
    }while (boton !=1 || !tablero);
    //Transforma la coordenada en la columna
    LocalizarPosicion (juego, casillas_x, coordenada_x, columna_tablero);    
}