// main.cxx : fichier principal du jeu d'echec
//
// auteur : MEHEUST Aurélien
//



# include <iostream>
#include <string>
# include "AbstractCharacter.hxx"
# include "Character.hxx"
#include "Pawn.hxx"
#include "Math.hxx"
#include "Player.hxx"
#include "Game.hxx"
#include "Ui.hxx"



using namespace std;


class Character *making_Character(string);


int main(int argc, char* argv[])
{
	// texte d'introduction du programme de jeu d'echec
	cout << "TP C++ (1/2) -- JEU D'ECHECS -- Groupe 3CT105 (Mulot, Fanet, Meheust)" << endl;
	cout << endl;



	// declaration des 2 joueurs
	PLAYER *Player[PLAYER_LAST];

	Player[WHITE_PLAYER]=new PLAYER(WHITE);
	Player[BLACK_PLAYER]=new PLAYER(BLACK);

	// declaration des 2 joueurs fictifs utilisés pour verifier 
	// si les coups de chacun sont faisables.
	PLAYER *test_white;
	PLAYER *test_black;
	
	// declaration des 2 pointeurs pour le joueur attaquant et le defenseur
	PLAYER *offensive ;
	PLAYER *defensive ;

	// Declaration du pointeur qui recevra les resultats de 
	// l'ensemble de la ligne d'instruction PGN
	Double_Strike *pgn_result = NULL;

	// Declaration du pointeur qui recevra les resultats de 
	// l'instruction PGN pour l'attaquant uniquement
	Strike *offensive_strike = NULL;

	// Declaration du pointeur pour la piece déplacée lors du tour d'un joueur
	Character* piece_played=NULL;

	// declaration de la chaine qui contiendra la ligne courante 
	// du fichier ou du clavier
	string line;

	// declaration de la variable de boucle for utilisée pour l'analyse alternée 
	// des coups de chacun des 2 joueurs
	int tour=1;

	// variable booléenne de test si il y a echec ou non, erreur ou non dans le coup 
	bool test=false;
	bool echec=false;

	// instanciation d'un objet de type Game pour gerer la partie
	Game game;

	// création de l'interface d'entrée/ sortie soit par fichier, soit par l'entrée standard
	Ui *in;
	Ui *out;




	// si on saisit quelque chose en parametre, le premier correspond au fichier en lecture
	if (argc >= ONE_ARG_INPUT)
	{
		in= Ui::Create(argv[1],1);
	}
	// sinon on utilise le clavier comme entrée
	else
	{
		in= Ui::Create("",1);
	}

	// s'il est saisi, le second parametre correpond au nom du fichier d'ecriture
	if (argc >= TWO_ARG_INPUT)
	{
		out= Ui::Create(argv[FILE_ON_OUTPUT],FILE_ON_OUTPUT);
	}
	// sinon, on affiche par défaut les résultats à l'écran
	else
	{
		out= Ui::Create("",FILE_ON_OUTPUT);
	}



	// création de l'echiquier de debut de partie en vue de son affichage
	out->Update_Chessboard(Player[WHITE_PLAYER],Player[BLACK_PLAYER]);

	// affichage en sortie fichier ou ecran de l'echiquier de depart
	out->Display_Chessboard();



	// boucle principale du programme
	// on la quitte quand on ne lit plus rien dans le fichier...
	//...OU qu'on ne saisit rien au clavier
	//...OU qu'on saisit "quit" au clavier !!!
	while(1)
	{
		// la chaine line contient la ligne courante du fichier/clavier
		line = in->Read();

		// si on saisit rien ou "quit" ou qu'on est arrivé à la fin du fichier
		// alors on quitte l'application
		if (line == "" || line == "quit") break;



		// on affiche à l'ecran ou on inscrit dans le fichier de sortie
		// la saisie precedente suivie d'un espace
		out->Display(line);
		out->Display("   ");

		// on decode l'instruction au format lue en entrée
		// et on inscrit le resultat de l'analyse dans le Double_Strike pgn_result
		pgn_result=out->Sort(line);

		


		// si aucune erreur de saisie d'instruction au format pgn n'est décelé
		// OU que l'on a pas saisi d'instruction classique du type "N. xxx yyy"
		// (d'ou le fait que le prochain traitement est inutile...)
		if(!pgn_result->get_Error())
		{
			// on va tester si les coups saisis sont realisables
			// pour cela, on passe par des pointeurs PLAYER * qui vont etre des doublures des vrais joueurs, 
			// tout ceci, dans le but de verifier l'integrité avant de modifier DEFINITIVEMENT les donnees
			test_white = new PLAYER( Player[WHITE_PLAYER] );
			test_black = new PLAYER( Player[BLACK_PLAYER] );




			// boucle de test de validité du coup de chaque joueur à partir des données
			// de pgn_result...
			for(tour=1; tour<=2; tour++)
			{
				// on commence par le coup du joueur BLANC
				if(tour==1)
				{
					offensive=test_white;
					defensive=test_black;
					offensive_strike=pgn_result->get_White();

				}
				// ensuite au deuxieme passage, on traite le coup du joueur NOIR
				else
				{
					defensive=test_white;
					offensive=test_black;
					offensive_strike=pgn_result->get_Black();
				}


				// identification des differents coups spéciaux réalisables

				// si une petite roque est demandée
				if(offensive_strike->get_Little_Roque())
				{




				}

				// si une grande roque est demandée
				else if(offensive_strike->get_Great_Roque())
				{




				}
				
				// cas où une prise en passant est effectuée
				else if(offensive_strike->get_En_Passant())
				{




				}

				// cas ou une promotion est detectée
				else if(offensive_strike->get_Promotion())
				{
				
				
				
				
				
				}

				// cas de base où aucun coup spécial n'est réalisé par l'attaquant
				else
				{
					test=game.Move(offensive,defensive,offensive_strike);
				}


                //test de l'echec uniquement si la variable test vaut 1
                if(test)
                {
					echec=game.Echec(offensive,defensive);
                }

                // si test vaut 0 et echec 1 suite a l'appel de game.echec alors...
                if(!test || echec)
                {
					out->Display("Coup impossible pour le joueur ");
					if (tour==1) out->Display_Line("BLANC");
					else out->Display_Line("NOIR");

					// on quitte la boucle de traitement des coups
					break;
                } 
			}
			// fin de la boucle de test de validité du coup des 2 joueurs

			
			// on desalloue la memoire aux deux joueurs fictifs...
			delete(test_white);
			delete(test_black);


			// on ne modifie reellement l' echiquier
			// QUE si le coup de CHAQUE joueur est valide
			if(test && !echec)
			{
				// boucle de traitement du coup de chaque joueur à partir des données
				// de pgn_result...
				for(tour=1; tour<=2; tour++)
				{
					// on commence par le coup du joueur BLANC
					if(tour==1)
					{
						offensive=Player[WHITE_PLAYER];
						defensive=Player[BLACK_PLAYER];
						offensive_strike=pgn_result->get_White();

					}
					// ensuite au deuxieme passage, on traite le coup du joueur NOIR
					else
					{
						defensive=Player[WHITE_PLAYER];
						offensive=Player[BLACK_PLAYER];
						offensive_strike=pgn_result->get_Black();
					}


					// identification des differents coups spéciaux réalisables

					// si une petite roque est demandée
					if(offensive_strike->get_Little_Roque())
					{




					}

					// si une grande roque est demandée
					else if(offensive_strike->get_Great_Roque())
					{




					}
					
					// cas où une prise en passant est effectuée
					else if(offensive_strike->get_En_Passant())
					{




					}

					// cas ou une promotion est detectée
					else if(offensive_strike->get_Promotion())
					{
					
					
					
					
					
					}

					// cas de base où aucun coup spécial n'est réalisé par l'attaquant
					else
					{
						test=game.Move(offensive,defensive,offensive_strike);
					}

/*
					//test de l'echec uniquement si la variable test vaut 1
					if(test)
					{
						echec=game.Echec(offensive,defensive);
					}

					// si test vaut 0 ou que echec vaut 1 suite a l'appel de game.echec alors...
					if(!test || !echec)
					{
						out->Display("Coup impossible pour le joueur ");
						if (tour==1) out->Display_Line("BLANC");
						else out->Display_Line("NOIR");

						// on quitte la boucle de traitement des coups
						break;
					} 
*/
				}
				// fin de la boucle de traitement du coup des 2 joueurs

				// actualisation de l'echiquier en vue de son affichage
				out->Update_Chessboard(Player[WHITE_PLAYER],Player[BLACK_PLAYER]);

				// affichage en sortie fichier ou a l'ecran de l'echiquier actualisé
				out->Display_Chessboard();

			}
			// fin du if correspondant a 2 coups valides


		}	
	}


	return 0;

}