#include <stdio.h>
#include <stdlib.h>

typedef struct {
int lig,col ;
} Case ;


typedef struct {
Case case_i,case_f ;
} deplacement ;


typedef struct {
char nom ;
char couleur ;
} joueur ;


typedef struct {
char plateau[9][9] ; // Représente l’état du plateau
int nb_noir ; // Représente le nombre de pion noir
int nb_blanc ; // Représente le nombre de pion blanc
} damier ;

typedef struct element *listeCases ;
struct element {
Case c ;
listeCases suivante ;
} ;




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] = ' ' ;
        }
    }
//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, char couleur, damier* jeu)
{
    if(jeu->plateau[d.case_f.lig][d.case_f.col]!=' ')
    {
        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]!=couleur)
    {printf("fffff");
        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]==' ')
	{
	    prise=prise+1;
printf("ohh");
	}
    if (jeu->plateau[c.lig][(c.col)-1] == pion && jeu->plateau[c.lig][(c.col)-2]==' ')
	{
	    prise=prise+1;
printf("ohhh");
	}
    if (jeu->plateau[(c.lig)+1][c.col] == pion && jeu->plateau[(c.lig)+2][c.col]==' ')
	{
	    prise=prise+1;
printf("ohhhh");
	}
    if (jeu->plateau[(c.lig)-1][c.col] == pion && jeu->plateau[(c.lig)-2][c.col]==' ')
	{
	    prise=prise+1;
printf("ohhhhh");
	}

	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]==' ')
	{
	    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]==' ')
	{
	    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]==' ')
	{
	    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]==' ')
	{
	    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,char couleur,deplacement d,damier* jeu,int prise)
{


        jeu->plateau[d.case_i.lig][d.case_i.col] = ' ' ;
        jeu->plateau[d.case_f.lig][d.case_f.col] = couleur ;
        if(prise!=0)
        {
            if(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]=' ';
        }
}


//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]!=' ')
                  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]!=' ')
                  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]!=' ')
                  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]!=' ')
                  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]!=' ')
                  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]!=' ')
                  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]!=' ')
                  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]!=' ')
                  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]!=' ')
                  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]!=' ')
                  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] = ' ' ;
        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] = ' ' ;
        jeu->plateau[d.case_f.lig][d.case_f.col]='N';
   }
}

void saisiedeplacement(Case c,char couleur,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,couleur,jeu);
    if (test==-1)
    {
        printf("deplacement imposssssible\n");
    }
    else
    {int prise=prisepion(c,jeu);
      deplace_pion(c,couleur,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, int couleur, 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);

printf("tupac%d",(n_case)[0].lig);
printf("fifty%d",n_case[0].col);
printf("tupac%d",(n_case)[1].lig);
printf("fifty%d",n_case[1].col);
printf("tupac%d",(n_case)[2].lig);
printf("fifty%d",n_case[2].col);
printf("tupac%d",(n_case)[3].lig);
printf("fifty%d",n_case[3].col);
nb=prisepion(case_i,jeu);

printf("%d",nb);
if (nb!=0) {printf("ahhhhh");
//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);
    printf("oula");
//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] ;
printf("%d",n_case[i].lig);
printf("%d",n_case[i].col);
d.case_i = case_i ;
printf("%d",case_i.lig);
printf("%d",case_i.col);
printf("%c",jeu->plateau[case_i.lig][case_i.col]);
deplace_pion(case_i,couleur,d,&cjeu,1) ;
//Calcul du nombre de prises max a partir de cette position
prises_p = max_pion_prises(n_case[i],couleur,&cjeu,&r,&np) ;
printf("pipet%dteeeeeeeeeeeeeeee",prises_p);

if(prises_p == prises_max && prises_p>0) {
    printf("hola");
// 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) {
    printf("hole");
// 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) {
    printf("allo");
// 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 ;
}
printf("%d",prises1);
printf("%d",prises_max);
//On retourne le nombre de prises maximales
return (prises1 + prises_max) ;
}

void afficherafle(listeCases raflemax)
{
  listeCases x=raflemax;
printf("oui");
   while(x!=0)
   {printf("non");
    printf("%d\t%d",x->c.lig,x->c.col);
    printf("okk");
    x=x->suivante;
    printf("car");
   }
}

void effectuerafle(listeCases raflemax,char couleur,damier* jeu)
{
    deplacement d;
  listeCases x=raflemax;
printf("oui");
   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;
    printf("ccc");
    deplace_pion(x->c,couleur,d,jeu,1);
    printf("okk");
    x=x->suivante;
    printf("car");
   }
}

void affichechoixrafle(listeCases* rafle,int n,char couleur,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],couleur,jeu);

}

int main()
{

int quitter=0;
 damier jeu;
char couleur;
Case c;
listeCases* rafle_max;
int n;
couleur='n';
init_damier(&jeu);
affich(&jeu);

while(quitter==0)
{
saisiedeplacement(c,couleur,&jeu);
affich(&jeu);
printf("quitter?");
scanf("%d",&quitter);
scanf("%d",&c.lig);
scanf("%d",&c.col);
int ni=max_pion_prises(c, couleur, &jeu,
&rafle_max,&n);
printf("%d",ni);
printf("%d",n);
if(ni!=0)
{
affichechoixrafle(rafle_max,n,couleur,&jeu);
affich(&jeu);
}
if(couleur=='n')
  {
    couleur='b';
  }
else{
    couleur='n';
    }
}
return 0;
}