//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 tablero.cpp*/

/**
    @file tablero.cpp
    @author Alvaro Diaz Sanchez
    @brief Fichero con definiciones de la clase Tablero asociado a la biblioteca libconectan.a
    */
 
#include <iostream>
#include <new>
#include <iomanip>
#include <cstdlib>

/*****************************************************/
#include "tablero.h"
#include "graficos.h"
/****************************************************/

using namespace std;

Tablero :: Tablero (int f, int c)
{  
    int f_iterador;
    bool error = false;
    
    //Crear la matriz mediante memoria dinamica
    tablero = new (nothrow) int * [f];
    //Comprobar que se ha reservado con exito
    if(!tablero){
        cerr << "Error en la reserva" << endl;
        tablero = 0;
        exit(1);
    }
    else{
        for (f_iterador=0; f_iterador < f && !error; f_iterador++){
            tablero[f_iterador] = new (nothrow) int [c];
            if(!tablero[f_iterador]){
                cerr << "Error en la reserva" << endl;
                error = true;
            }
        }
    }
    //Asignar las filas y las columnas
    filas = f;
    columnas = c;
    //Crear mediante memoria dinamica el vector filas_restantes
    filas_restantes = new (nothrow) int [c];
    if(!filas_restantes){
        cerr << "Error en la reserva" << endl;
        filas_restantes = 0;
        exit(1);
    }
    
    x_cabecera = 0;
    y_cabecera = 0;
    x_ficha = 0;
    y_ficha = 0;   
}

Tablero :: ~Tablero (void)
{
    int f_iterador;
    //Liberar los recursos de matriz y filas_restantes despues de su uso
    for (f_iterador = 0; f_iterador < filas; f_iterador++)
        delete [] tablero[f_iterador];
        
    delete [] tablero;

    delete [] filas_restantes;
}

void Tablero :: ColocarExtension (const char *extension, char recursos[], char apariencia[])
{   
    const char *terminador = "/";    
    
    //Elabora la ruta hacia las imagenes    
    strcpy (fichero, recursos);
    strcat (fichero, terminador);
    strcat (fichero, apariencia);
    strcat (fichero, extension);
 
}

void Tablero :: TableroQuitaFila (unsigned int columna)
{
    filas_restantes[columna]--;
}

void Tablero :: SetTablero (int fila, unsigned int columna, int valor)
{
    //Insertar un valor en la posicion [fila, columna]
    tablero[fila][columna] = valor;
}

int Tablero :: GetTablero (int fila, int columna) const
{
    //Devolver el valor de la ficha que hay en la celda [fila, columna]
    return (tablero[fila][columna]);
}

int Tablero :: GetAlturaFicha (void) const
{
    return (y_ficha);
}

int Tablero :: GetAnchoFicha (void) const
{
    return (x_ficha);
}

int Tablero :: GetAlturaCabecera (void) const
{
    return (y_cabecera);
}

int Tablero :: GetAnchoCabecera (void) const
{
    return (x_cabecera);
}

int Tablero :: FilasTablero (void) const
{
    //Devolver el numero de filas del tablero virtual
    return (filas);
}

int Tablero :: ColumnasTablero (void) const
{
    //Devolver el numero de columnas del tablero virtual
    return (columnas);
}

void Tablero :: SetFilasRestantes (unsigned int columna, int valor)
{
    filas_restantes[columna] = valor;
}

int Tablero :: GetFilasRestantes (unsigned int columna) const
{
    //Devolver cuantas filas quedan en la columna antes de que se agote el espacio
    return (filas_restantes[columna]);
}

void Tablero :: TableroInsertaFicha (int fila, unsigned int columna, int valor)
{
    //Quita una fila
    TableroQuitaFila (columna);
    //Inserta el valor de la casilla en [fila, columna]
    SetTablero (fila, columna, valor);
    
}

bool Tablero :: TableroCompleto (void) const
{
    int c_iterador;
    bool completo = true;
    //Comprueba si el tablero virtual esta lleno de fichas
    for (c_iterador = 0; c_iterador < columnas && completo; c_iterador++){
        if (filas_restantes[c_iterador] != -1)
            completo = false;
    }

    return completo;
}

void Tablero :: PintarPieTablero (void)
{
    int filas_ventana, columnas_ventana;

    filas_ventana = FilasVentana();
    columnas_ventana = ColumnasVentana();

    //Dibujar el pie de ventana
    RectanguloR (5, filas_ventana - 34, columnas_ventana - 6, filas_ventana - 3, 0, 0 ,0);  

}

void Tablero :: PintaTablero (char recursos[], char apariencia[], int linea) 
{
    int casillas_x, casillas_y, centrado_cab, centrado_v; 
    int coordenada_x = 0 , coordenada_y = 0, fila, columna, filas_ventana, columnas_ventana ;
    SDL_Surface *cab, *v;   
    const char *cabecera = ".cab.bmp";
    const char *vacia = ".v.bmp";
    char titulo[15] =  "Conecta ";
    char linea_n[linea];    
    
    //Colocar el titulo de la ventana
    sprintf (linea_n, "%d", linea);
    strcat (titulo, linea_n);
    
    //Cargar imagenes
    ColocarExtension (cabecera, recursos, apariencia);
    DimensionesBMP (fichero, x_cabecera, y_cabecera);
    cab = LeerImagenBMP (fichero);
       
    ColocarExtension (vacia, recursos, apariencia);
    DimensionesBMP (fichero, x_ficha, y_ficha);
    v = LeerImagenBMP (fichero);    
    
    casillas_x = x_ficha * columnas;
    casillas_y = y_ficha * filas;
    coordenada_y = y_cabecera;  
    
    //Pintar el tablero    
    if (casillas_x >= x_cabecera){
        CrearVentana (casillas_x, y_cabecera + 40 + casillas_y, titulo);
        filas_ventana = FilasVentana();
        columnas_ventana = ColumnasVentana();
        RectanguloR (0,0, columnas_ventana - 1, filas_ventana - 1, 255, 255, 255);
        centrado_cab = (casillas_x - x_cabecera) / 2;
        DibujarImagenBMP (cab, centrado_cab, 0);
        
        for (fila = 0; fila < filas; fila++){
            for (columna = 0; columna < columnas; columna++){
                DibujarImagenBMP (v, coordenada_x, coordenada_y);
                coordenada_x += x_ficha;
            }
            coordenada_x = 0;
            coordenada_y += y_ficha;
        }
    }

    else{
        CrearVentana (x_cabecera, y_cabecera + 40 + casillas_y, titulo);
        filas_ventana = FilasVentana();
        columnas_ventana = ColumnasVentana();
        RectanguloR (0,0, columnas_ventana - 1, filas_ventana - 1, 255, 255, 255);
        DibujarImagenBMP (cab, 0, 0);
        centrado_v = (x_cabecera - casillas_x) / 2;
        coordenada_x = centrado_v;

        for (fila = 0; fila < filas; fila++){
            for (columna = 0; columna < columnas; columna++){
                DibujarImagenBMP (v, coordenada_x, coordenada_y);
                coordenada_x += x_ficha;
            }
            coordenada_x = centrado_v;
            coordenada_y += y_ficha;
        }
    } 

    PintarPieTablero();

    LiberarImagenBMP (cab);
    LiberarImagenBMP (v);

}

void Tablero :: TableroPintaFichaJugador (char recursos[], char apariencia[], int valor, int fila, unsigned int columna)
{
    int coordenada_x, coordenada_y, casillas_x, casilla_centrada;
    SDL_Surface *ficha_color;
    const char *primer_color = ".b.bmp", *segundo_color = ".n.bmp";
    
    //Cargar imagenes dependiendo del color
    if (valor == 1){
        ColocarExtension (primer_color, recursos, apariencia);
        ficha_color = LeerImagenBMP (fichero);
    }
    else{
        ColocarExtension (segundo_color, recursos, apariencia);
        ficha_color = LeerImagenBMP (fichero);
    }

    casillas_x = columnas * x_ficha;
    coordenada_y = y_cabecera + (fila * y_ficha);

    //Pintar la ficha en la casilla
    if (casillas_x >= x_cabecera){
        coordenada_x = columna * x_ficha ;
        DibujarImagenBMP (ficha_color, coordenada_x, coordenada_y);
    }
    else{
        casilla_centrada = (x_cabecera - casillas_x) / 2;
        coordenada_x = casilla_centrada + (columna * x_ficha);
        DibujarImagenBMP (ficha_color, coordenada_x, coordenada_y);
    }

    LiberarImagenBMP (ficha_color);
    
}