/**
 * Program: Solo, a computer solitarie card game.
 * By: MD, md@tomatesasesinos.com
 * Copyright 2007
 *
 * License: GPL http://www.gnu.org/licences/gpl.html
 * 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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 *
 * File: graficos.h
 * Contents: The main program
 */

#include "globals.h"

int main(int argc, char *argv[])
{
	iniciarJuego();

	solitarioSDL();

	return 0;
}

void iniciarJuego(void)
{
	int i,j;

	//Iniciamos la semilla aleatoria
	srand(time(0));

	//Llenando baraja
	for(i=0;i<52;i++) baraja[i]=i;
	
	//Limpiando de cartas el tablero
	for(i=0;i<POSICIONESTABLERO;i++)
	{
		cartasTablero[i]=0;
		for(j=0;j<52;j++)	tablero[i][j].numCarta=SINCARTA;
	}
	
	repartirCartas();
}

void repartirCartas(void)
{
	int repartidas;
	int total;
	int naipe;
	int posicion;
	int reparto[POSICIONESTABLERO]={24,0,0,0,0,0,1,2,3,4,5,6,7,0}; //Forma de repartir las cartas en la mesa
	int bocaArriba[POSICIONESTABLERO]={0,0,0,0,0,0,1,1,1,1,1,1,1,0}; //Posiciones en el tablero donde hay una carta boca arriba
	int donde=0;

	for(repartidas=0;repartidas<52;repartidas++)
	{
		total=52-repartidas;

		/*DEBUGEO*/
		/*naipe=repartidas;*/
		/**/
		if(total>1) posicion=rand()%total;
		else posicion=0;
		naipe=quitarBaraja(posicion);
		/**/

		if(reparto[donde]==1)
		{	if(bocaArriba[donde]) meterPos(donde,naipe,BOCARRIBA);
			else meterPos(donde,naipe,BOCABAJO);
		}else meterPos(donde,naipe,BOCABAJO);
		reparto[donde]--;
		if(reparto[donde]==0)
		{
			while((donde<13)&&(reparto[donde]==0)) donde++;
		}
	}
}

int quitarBaraja(int pos)
{
	int retorno=baraja[pos];
	int i;
	
	for(i=pos;i<51;i++)
	{
		baraja[i]=baraja[i+1];
	}
	baraja[i]=SINCARTA;
	
	return retorno;
}

void sacarCartaSacar(void)
{
	meterPos(OLVIDAR,tablero[SACAR][0].numCarta,BOCARRIBA);
	retirarPos(SACAR);
}

void retirarPos(int posTablero)
{
	int i;

	if((posTablero>=COLUMNA1)&&(tablero[posTablero][0].bocaArriba)) escalerasTablero[posTablero-COLUMNA1]--;
	
	for(i=0;i<51;i++)
	{
		tablero[posTablero][i]=tablero[posTablero][i+1];
	}
	tablero[posTablero][51].numCarta=SINCARTA;
	cartasTablero[posTablero]--;
}

void rellenarPilaSacar(void)
{
	int i;

	//Es diferente las posiciones en una matriz a la cantidad, para 3 elementos hay 0,1,2 posiciones por eso cartasTablero[OLVIDAR] se usa con < en el for y con -1 en las cuentas

	for(i=0;i<cartasTablero[OLVIDAR];i++)
	{
		tablero[SACAR][cartasTablero[OLVIDAR]-1-i].numCarta=tablero[OLVIDAR][i].numCarta;
		tablero[SACAR][cartasTablero[OLVIDAR]-1-i].bocaArriba=BOCABAJO;
		tablero[OLVIDAR][i].numCarta=SINCARTA;
	}
	cartasTablero[SACAR]=cartasTablero[OLVIDAR];
	cartasTablero[OLVIDAR]=0;
}

void moverCarta(int origen,int destino)
{
	meterPos(destino,tablero[origen][0].numCarta,BOCARRIBA);
	retirarPos(origen);
}

void moverCartaLegal(int origen,int destino)
{
	int naipeOrigen=tablero[origen][0].numCarta;
	int paloOrigen=naipeOrigen/13;
	int numNaipeOrigen=naipeOrigen%13; //Numero de la carta dentro del palo

	int naipeDestino=tablero[destino][0].numCarta;
	int paloDestino=naipeDestino/13;
	int numNaipeDestino=naipeDestino%13; //Numero de la carta dentro del palo

	int legal=0;
	
	if((destino<FINMONTONES)&&((numNaipeDestino+1)==numNaipeOrigen)) //Para colocar en los montones de los palos y ademas sincarta+1==as
	{
		if(numNaipeDestino==SINCARTA) legal=1;
		else
		{
			if(paloOrigen==paloDestino) legal=1;
		}
	}else
	{
		if((tablero[destino][0].numCarta==SINCARTA)&&(numNaipeOrigen==REY)) legal=1;
		else
		{
			if(!tablero[destino][0].bocaArriba)
			{
				if(numNaipeOrigen==REY) legal=1;
			}else
			{
				if(((paloOrigen%2)!=(paloDestino%2))&&((numNaipeOrigen+1)==numNaipeDestino)) legal=1;
			}
		}
	}

	if(legal) moverCarta(origen,destino);
}

void moverGrupoCartasLegal(int origen,int profundidadOrigen,int destino)
{
	int naipeOrigenPrimero=tablero[origen][profundidadOrigen].numCarta;
	int paloOrigenPrimero=naipeOrigenPrimero/13;
	int numNaipeOrigenPrimero=naipeOrigenPrimero%13; //Numero de la carta dentro del palo

	int naipeDestino=tablero[destino][0].numCarta;
	int paloDestino=naipeDestino/13;
	int numNaipeDestino=naipeDestino%13; //Numero de la carta dentro del palo

	int legal=0;

	int i;

	if(destino>=COLUMNA1) //No se pueden arrastrar gurpos de cartas en escalera a los palos
	{
		if((naipeDestino==SINCARTA)&&(numNaipeOrigenPrimero==REY)) legal=1;
		else
		{
			if(!tablero[destino][0].bocaArriba)
			{
				if(numNaipeOrigenPrimero==REY) legal=1;
			}else
			{
				if(((paloOrigenPrimero%2)!=(paloDestino%2))&&((numNaipeOrigenPrimero+1)==numNaipeDestino)) legal=1;
			}
		}
	}

	if(legal)
	{
		for(i=profundidadOrigen;i>=0;i--) meterPos(destino,tablero[origen][i].numCarta,BOCARRIBA);
		for(i=0;i<=profundidadOrigen;i++) retirarPos(origen);
	}
}

int moverPalos(int posTablero)
{
	int retorno=0;
	int naipe=tablero[posTablero][0].numCarta;
	int palo=naipe/13;
	int numNaipe=naipe%13; //Numero de la carta dentro del palo
	int i;

	for(i=PALO1;i<FINMONTONES;i++)
	{
		if(numNaipe>0)
		{
			if((tablero[i][0].numCarta/13)==palo)
			{
				//Para ver si es justo el anterior al que intentamos colocar
				if((tablero[i][0].numCarta%13)+1==numNaipe) break;
			}
		}else
		{
			if(tablero[i][0].numCarta==SINCARTA) break;
		}
		
	}

	if(i!=FINMONTONES)
	{
		meterPos(i,tablero[posTablero][0].numCarta,BOCARRIBA);
		retirarPos(posTablero);

		retorno=1;
	}

	return retorno;
}

void meterPos(int posTablero,int naipe,int bocaArriba)
{
	hacerSitio(posTablero);
	tablero[posTablero][0].numCarta=naipe;
	tablero[posTablero][0].bocaArriba=bocaArriba;
	cartasTablero[posTablero]++;
	if((posTablero>=COLUMNA1)&&(bocaArriba)) escalerasTablero[posTablero-COLUMNA1]++;
}

void hacerSitio(int posTablero)
{
	int i;
	
	for(i=50;i>=0;i--)
	{
		tablero[posTablero][i+1]=tablero[posTablero][i];
	}
}


int victoria(void)
{
	int retorno=1;
	int i;

	for(i=PALO1;i<FINMONTONES;i++)
	{
		if(tablero[i][0].numCarta%13!=REY) retorno=0;
	}
	
	return retorno;
}