#include <stdio.h>
#include <stdlib.h>
#include "bec.h"
#include "interface.h"


void init_damier(damier* jeu)
{
    jeu->nb_blanc = 17;
    jeu->nb_noir = 17;
    int i,j ;
//On initialise le tableau
    for(i=0 ;i<=8 ;i++)
    {
        for(j=0 ;j<=8 ;j++)
        {
            jeu->plateau[i][j] = 'O' ;
        }
    }
//On remplie la partie haute du damier par des pions noirs
    for(i=0 ;i<2 ;i++)
    {
        for(j=0 ;j<=8 ;j++)
        {
            jeu->plateau[i][j] = 'n';
        }
    }
//On remplie la partie basse du damier par des pions blancs
    for(i=7 ;i<=8 ;i++)
    {
        for(j=0 ;j<=8 ;j++)
        {
            jeu->plateau[i][j] = 'b' ;
        }
    }
    jeu->plateau[0][4]='N';
    jeu->plateau[8][4]='B';
}


int testdeplacement(deplacement d, joueur jc, damier* jeu)
{
    if(jeu->plateau[d.case_f.lig][d.case_f.col]!='O')
    {
        return -1;
    }

    if(jeu->plateau[d.case_i.lig][d.case_i.col]=='N' || jeu->plateau[d.case_i.lig][d.case_i.col]=='B')
    {
       return 2;

    }
    if(jeu->plateau[d.case_i.lig][d.case_i.col]!=jc.couleur)
    {
        return -1;
    }
    if(d.case_f.lig==4 && d.case_f.col==4)
    {
        return -1;
    }
    if(d.case_f.lig>d.case_i.lig+1)
    {
        return -1;
    }
    if(d.case_f.lig<d.case_i.lig-1)
    {
        return -1;
    }
    if(d.case_f.col>d.case_i.col+1)
    {
        return -1;
    }
    if(d.case_f.col<d.case_i.col-1)
    {
        return -1;
    }
    if(d.case_f.lig!=d.case_i.lig && d.case_f.col!=d.case_i.col)
    {
        return -1;
    }
    if(d.case_f.lig>8 || d.case_f.lig<0 || d.case_f.col>8 || d.case_f.col<0)
    {
        return -1;
    }
    if(d.case_i.lig>8 || d.case_i.lig<0 || d.case_i.col>8 || d.case_i.col<0)
    {
        return -1;
    }
    return 0;
}

int prisepion(Case c, damier* jeu)
{
    char pion ; // pion : pièce qui peut prendre et piece(lig,col) : celle qui peut être prise
    int prise=0;




    if (jeu->plateau[c.lig][c.col]=='n')
    {
        pion='b';
    }
    if(jeu->plateau[c.lig][c.col]=='b')
    {
        pion='n';
    }
    if (jeu->plateau[c.lig][(c.col)+1] ==pion  && jeu->plateau[c.lig][(c.col)+2]=='O')
	{
	    prise=prise+1;

	}
    if (jeu->plateau[c.lig][(c.col)-1] == pion && jeu->plateau[c.lig][(c.col)-2]=='O')
	{
	    prise=prise+1;

	}
    if (jeu->plateau[(c.lig)+1][c.col] == pion && jeu->plateau[(c.lig)+2][c.col]=='O')
	{
	    prise=prise+1;

	}
    if (jeu->plateau[(c.lig)-1][c.col] == pion && jeu->plateau[(c.lig)-2][c.col]=='O')
	{
	    prise=prise+1;

	}

	return prise;
}
Case prisepion2(Case c, damier* jeu,Case ncase_i[4])
{
    char pion ; // pion : pièce qui peut prendre et piece(lig,col) : celle qui peut être prise
    int prise=0;
    int k;

    for(k=0;k<4;k++)
    {
        ncase_i[k].lig=0;
        ncase_i[k].col=0;
    }
    k=0;

    if (jeu->plateau[c.lig][c.col]=='n')
    {
        pion='b';
    }
    else
    {
        pion='n';
    }

    if (jeu->plateau[c.lig][(c.col)-1] == pion && jeu->plateau[c.lig][(c.col)-2]=='O')
	{
	    prise=prise+1;
        ncase_i[k].lig=c.lig;
        ncase_i[k].col=c.col-2;
       k++;
	}
	if (jeu->plateau[c.lig][(c.col)+1] == pion && jeu->plateau[c.lig][(c.col)+2]=='O')
	{
	    prise=prise+1;
        ncase_i[k].lig=c.lig;
        ncase_i[k].col=c.col+2;
        k++;
	}
    if (jeu->plateau[(c.lig)+1][c.col] == pion && jeu->plateau[(c.lig)+2][c.col]=='O')
	{
	    prise=prise+1;
        ncase_i[k].lig=c.lig+2;
        ncase_i[k].col=c.col;
        k++;
	}
    if (jeu->plateau[(c.lig)-1][c.col] == pion && jeu->plateau[(c.lig)-2][c.col]=='O')
	{
	    prise=prise+1;
        ncase_i[k].lig=c.lig-2;
        ncase_i[k].col=c.col;
        k++;
	}

	return *ncase_i;
}

void deplace_pion(Case c,joueur jc,deplacement d,damier* jeu,int prise)
{


        jeu->plateau[d.case_i.lig][d.case_i.col] = 'O' ;
        jeu->plateau[d.case_f.lig][d.case_f.col] = jc.couleur ;
        if(prise!=0)
        {
            if(jc.couleur == 'b')
            {
                jeu->nb_noir-- ;
            }
            else
            {
                jeu->nb_blanc-- ;
            }



        jeu->plateau[(d.case_f.lig + d.case_i.lig)/2]
        [(d.case_f.col + d.case_i.col)/2]='O';
        }
}


//Fonction qui doit definir le chemin de la dame
deplacement parcours_dame(deplacement d,damier* jeu)
{
    if(jeu->plateau[d.case_i.lig][d.case_i.col]=='B') // tour : fonction qui retourne 1 si c'est au joueur 1 de jouer et 2 sinon
    {
        int l=d.case_i.lig;
	    int p=d.case_i.col;  //coordonnees de la dame
	    if(l>=5 && p<=4)
        {
            d.case_f.lig=l-1;
            d.case_f.col=p-1;
        }
	    else if(l==4 && p==0)
        {
            d.case_f.lig=3;
            d.case_f.col=0;
        }
	    else if(l<=2 && p<=2)
        {
            d.case_f.lig=l-1;
            d.case_f.col=p+1;
        }
	    else if(l<=3 && p<4)
        {
            d.case_f.lig=l+1;
            d.case_f.col=p+1;
        }
        else if(l==3 && p==4)
        {
            d.case_f.lig=4;
            d.case_f.col=4;
        }

    }
	if(jeu->plateau[d.case_i.lig][d.case_i.col]=='N')
    {
        int a=d.case_i.lig;
	    int b=d.case_i.col;
	    printf("%d%d",a,b);
	    if(a<4)
        {
            d.case_f.lig=a+1;
            d.case_f.col=b+1;
            printf("%d%d",d.case_f.lig,d.case_f.col);
		}
	     if(a==4 && b!=4)
        {
            d.case_f.lig=5;
            d.case_f.col=8;
		}
	     if(a>4 && b>6)
        {
            d.case_f.lig=a+1;
		    d.case_f.col=b-1;
        }
	     if(a>4 && b<=6)
        {
            d.case_f.lig=a-1;
            d.case_f.col=b-1;
        }
         if(a==5 && b==4)
        {
            d.case_f.lig=4;
            d.case_f.col=4;
        }
    }
    return d;
}

int testdeplacement2(deplacement d, damier* jeu){

if(jeu->plateau[d.case_i.lig][d.case_i.col]=='B')
    {
      if(d.case_i.lig>4)
         {
           if(jeu->plateau[d.case_i.lig-1][d.case_i.col-1]!='O')
                  return -1;
         }

      if(d.case_i.lig==4 && d.case_i.col!=4)
         {
        if(jeu->plateau[d.case_i.lig-1][d.case_i.col]!='O')
                  return -1;
         }

      if(d.case_i.lig<4 && d.case_i.col<2)
         {
        if(jeu->plateau[d.case_i.lig-1][d.case_i.col+1]!='O')
                  return -1;
         }

      if(d.case_i.lig<3 && d.case_i.col>=2)
         {
        if(jeu->plateau[d.case_i.lig+1][d.case_i.col+1]!='O')
                  return -1;
         }

      if(d.case_i.lig==3 && d.case_i.col==4)
         {
        if(jeu->plateau[d.case_i.lig+1][d.case_i.col]!='O')
                  return -1;
         }
return 0;
    }

if(jeu->plateau[d.case_i.lig][d.case_i.col]=='N')
    {
      if(d.case_i.lig<4)
         {
           if(jeu->plateau[d.case_i.lig+1][d.case_i.col+1]!='O')
                  return -1;
         }

      if(d.case_i.lig==4 && d.case_i.col!=4)
         {
        if(jeu->plateau[d.case_i.lig+1][d.case_i.col]!='O')
                  return -1;
         }

      if(d.case_i.lig>4 && d.case_i.col>6)
         {
        if(jeu->plateau[d.case_i.lig+1][d.case_i.col-1]!='O')
                  return -1;
         }

      if(d.case_i.lig>5 && d.case_i.col<=6)
         {
        if(jeu->plateau[d.case_i.lig-1][d.case_i.col-1]!='O')
                  return -1;
         }

      if(d.case_i.lig==5 && d.case_i.col==4)
         {
        if(jeu->plateau[d.case_i.lig-1][d.case_i.col]!='O')
                  return -1;
         }
return 0;

    }

}

void deplace_dame(deplacement d,damier* jeu)
{
if(jeu->plateau[d.case_i.lig][d.case_i.col]=='B')
   {

        jeu->plateau[d.case_i.lig][d.case_i.col] = 'O' ;
        jeu->plateau[d.case_f.lig][d.case_f.col] = 'B' ;
   }

if(jeu->plateau[d.case_i.lig][d.case_i.col]=='N')
   {
        jeu->plateau[d.case_i.lig][d.case_i.col] = 'O' ;
        jeu->plateau[d.case_f.lig][d.case_f.col]='N';
   }
}

void saisiedeplacement(Case c,joueur jc,damier* jeu)
{

    deplacement d,d1;

    printf("selectionner votre pion");
    scanf("%d",&d.case_i.lig);

    scanf("%d",&d.case_i.col);
    c.lig=d.case_i.lig;
    c.col=d.case_i.col;
    if(jeu->plateau[d.case_i.lig][d.case_i.col]=='N' || jeu->plateau[d.case_i.lig][d.case_i.col]=='B' )
    {
        int test2=testdeplacement2(d,jeu);
         if(test2==0)
              {
            d1=parcours_dame(d,jeu);
            deplace_dame(d1,jeu);
              }
            else{
                printf("deplacement impossible");
                }

    }
        else {
    printf("selectionner ou aller");
    scanf("%d",&d.case_f.lig);
    scanf("%d",&d.case_f.col);

    int test=testdeplacement(d,jc,jeu);
    if (test==-1)
    {
        printf("deplacement imposssssible\n");
    }
    else
    {int prise=prisepion(c,jeu);
      deplace_pion(c,jc,d,jeu,prise);
    }
            }
}

void affich(damier* jeu)
{
    int i,j;
    for(i=0;i<=8;i++)
      {
          for(j=0;j<=8;j++)
          {
              printf("%c\t",jeu->plateau[i][j]);
          }
          printf("\n");
      }
}
damier copie_damier(damier* jeu)
{
int i,j;
    damier cjeu;
    for(i=0;i<=8;i++)
    {
        for(j=0;j<=8;j++)
        {
            cjeu.plateau[i][j]=jeu->plateau[i][j];
        }
    }
    return cjeu;
}

int max_pion_prises(Case case_i, joueur jc, damier* jeu,
listeCases** rafle_max,int* n) {
int prises1 = 0 ; //0 si on peut pas prendre en case_i, 1 sinon
int prises_p ; //Nombre de prises max en n_case[i]
int prises_max = 0 ; //Nombre max de prises possibles trouvé
int np ; //Nb de possibilité de prendre le max de pions en n_case[i]
int nb; //Contient le nombre de possibilité de prises en case_i
//Variable d’indice, de boucle
int i,t,ind=0 ;
//Variable servant au calcul
Case n_case[4];
deplacement d ;
damier cjeu ;
listeCases* r ;
prisepion2(case_i,jeu,n_case);
nb=prisepion(case_i,jeu);


if (nb!=0) {
//Le pions situé en case_i peut prendre nb pions
//On créé un copie du jeu qui va nous permettre de simuler les coups sans affecter le damier originel
cjeu = copie_damier(jeu);
//On peut prendre un pion -> prises =1
prises1++;
//Pour chaque possibilité de prises, on calcul le nombre de prises maximales que l’on peut faire
for(i=0 ;i<nb ;i++) {
    nb=prisepion(case_i,jeu);

//On initialise le nombre de façon de faire
np = 1;
// On alloue de la place
r = (listeCases*) malloc(sizeof(listeCases)) ;
r[0] = (listeCases) malloc(sizeof(struct element)) ;
//On crée une variable déplacement et on effectue le deplacement
d.case_f = n_case[i] ;

d.case_i = case_i ;
deplace_pion(case_i,jc,d,&cjeu,1) ;
//Calcul du nombre de prises max a partir de cette position
prises_p = max_pion_prises(n_case[i],jc,&cjeu,&r,&np) ;


if(prises_p == prises_max && prises_p>0) {

// Il y a d’autre possibilité de prendre prises_max pion, mais en passant par un autre endroit
for(t=0 ;t<np ;t++) {
// Pour chaque nouvelle possibilité on crée une nouvelle cases dans rafle_max
(*rafle_max)[ind] = (listeCases) malloc(sizeof(struct element)) ;
//On lui affecte les valeurs
(*rafle_max)[ind]->suivante = r[t] ;
(*rafle_max)[ind]->c = case_i ;
ind++ ;
}
// Correction de l’ind
ind-- ;
// On ajoute au nombre de possibilité les np que l’on vient de trouver
*n=*n+np ;
}


if(prises_p == 0 && prises_max==0) {

// On ne peut plus prendre de pion
// On crée le dernier element de la liste
r[0]->c = n_case[i] ;
r[0]->suivante = 0 ;
// On créé une nouvelle case dans le tableau
(*rafle_max)[ind] = (listeCases) malloc(sizeof(struct element)) ;
// On lui affecte les valeurs correspondante
(*rafle_max)[ind]->suivante = r[0] ;
(*rafle_max)[ind]->c = case_i ;

// L’indice augmente de 1 car on a trouvé un moyen de faire prises_max
ind++ ;
*n=ind;
}

if(prises_p > prises_max) {

// On a trouvé np moyen de faire plus de prises
//Il y a np moyen
*n = np ;
prises_max = prises_p ;
//On met dans le tableau tous les possibilités qu’on a trouvées
for(ind=0 ;ind<np ;ind++) {
(*rafle_max)[ind] = (listeCases) malloc(sizeof(struct element)) ;
(*rafle_max)[ind]->suivante = r[ind] ;
(*rafle_max)[ind]->c = case_i ;

}
}
}
}
else {
//Si on ne peut pas prendre, on est en fin de liste, d’où suivante pointe vers nil
for(t=0 ;t<ind ;t++)
(*rafle_max)[t]->suivante = 0 ;
}

//On retourne le nombre de prises maximales
return (prises1 + prises_max) ;
}

void afficherafle(listeCases raflemax)
{
  listeCases x=raflemax;

   while(x!=0)
   {
    printf("%d\t%d",x->c.lig,x->c.col);

    x=x->suivante;

   }
}

void effectuerafle(listeCases raflemax,joueur jc,damier* jeu)
{
    deplacement d;
  listeCases x=raflemax;

   while(x->suivante!=0)
   {
    d.case_i.lig=x->c.lig;
    d.case_i.col=x->c.col;
    d.case_f.lig=x->suivante->c.lig;
    d.case_f.col=x->suivante->c.col;

    deplace_pion(x->c,jc,d,jeu,1);

    x=x->suivante;

   }
}

void affichechoixrafle(listeCases* rafle,int n,joueur jc,damier* jeu)
{
int i;
     for(i=0;i<n;i++)
      {
       afficherafle(rafle[i]);
      }
     printf("choisirrafle avec i de 0 a %d",n-1);
     scanf("%d",&i);

     effectuerafle(rafle[i],jc,jeu);

}

//Fonction qui parcourt le damier en cherchant si une rafle maximale est possible, retourne la valeur de la rafle maximale
int coupobligatoire(joueur jc, damier*jeu,listeCases** rafle_max,int *n)
{
    int k,rafle=0;
    Case c1;
    Case c;
    int prise[18];
    for(k=0;k<18;k++)
    {
        prise[k]=0;
    }
    k=0;

    for(c1.lig=0;c1.lig<=8;c1.lig++)
    {
        for(c1.col=0;c1.col<=8;c1.col++)
            {
             if(jeu->plateau[c1.lig][c1.col]==jc.couleur)
              {
                c=c1;
                prise[k]=max_pion_prises(c1, jc, jeu, rafle_max,n);
               if(prise[k]>rafle)
                {
                 rafle=prise[k];
                }
                k=k+1;
              }
            }
    }

    return rafle;
}

//Fonction qui définit au hasard si ce sont les blancs ou les noirs qui commencent à jouer en premier
joueur premier_joueur(joueur* j1, joueur* j2)
{
    joueur jc;
	int nb = 0;
	srand(time(NULL));
	//on prend un nombre au hasard entre 1 et 2
	nb = (rand() % (2))+1;
	if(nb==1)
	{
		(*j1).couleur='b';
		(*j2).couleur='n';

	}
	else
	{
		(*j1).couleur='n';
		(*j2).couleur='b';

	}
return *j1;
}