#include <stdio.h>
#include <stdlib.h>
#include "jeu.h"
#include <graph.h> /* Assurez-vous d'inclure la bibliothèque graphique */

/* Fonction pour dessiner un cercle */
void DessinerCercle(int x, int y, int rayon) {
    DessinerArc(x - rayon, y - rayon, 2 * rayon, 2 * rayon, 0, 360); 
}

/* Fonction pour dessiner la grille */
void dessinerGrille(struct EtatJeu etatJeu) {
    int i, j;
    int largeurFenetre = 800; /* Largeur de la fenêtre */
    int hauteurFenetre = 600; /* Hauteur de la fenêtre */
    
    /* Calculer la taille de chaque case pour remplir complètement la fenêtre */
    int tailleCase = (largeurFenetre < hauteurFenetre) ? (largeurFenetre / etatJeu.tailleGrille) : (hauteurFenetre / etatJeu.tailleGrille);
    
    /* Ajuster la taille de la case pour qu'elle prenne tout l'espace */
    if (tailleCase * etatJeu.tailleGrille > hauteurFenetre) {
        tailleCase = hauteurFenetre / etatJeu.tailleGrille;
    }

    /* Dessiner la grille */
    for (i = 0; i < etatJeu.tailleGrille; i++) {
        for (j = 0; j < etatJeu.tailleGrille; j++) {
            int x = j * tailleCase; /* Calculer la position x */
            int y = i * tailleCase; /* Calculer la position y */
            ChoisirCouleurDessin(CouleurParNom("black")); /* Couleur de la grille */
            DessinerRectangle(x, y, tailleCase, tailleCase); /* Dessiner le rectangle pour la case */
            
            /* Dessiner les pièces bloquées */
            if (etatJeu.grille[i][j] == 1) { /* 1 pour l'humain */
                ChoisirCouleurDessin(CouleurParNom("blue"));
                DessinerCercle(x + tailleCase / 2, y + tailleCase / 2, tailleCase / 4); /* Dessiner un cercle bleu */
            } else if (etatJeu.grille[i][j] == 2) { /* 2 pour l'IA */
                ChoisirCouleurDessin(CouleurParNom("red"));
                DessinerCercle(x + tailleCase / 2, y + tailleCase / 2, tailleCase / 4); /* Dessiner un cercle rouge */
            }
        }
    }
}

void gererClicSouris(struct EtatJeu *etatJeu) {
    int x, y;
    int tailleCase;
    int i, j;

    if (SourisCliquee()) {
        x = _X; /* Position X du clic */
        y = _Y; /* Position Y du clic */

        tailleCase = 800 / etatJeu->tailleGrille; /* Taille de chaque case */
        i = y / tailleCase; /* Ligne cliquée */
        j = x / tailleCase; /* Colonne cliquée */

        /* Vérifier si la case est libre */
        if (i < etatJeu->tailleGrille && j < etatJeu->tailleGrille && etatJeu->grille[i][j] == 0) {
            etatJeu->grille[i][j] = 1; /* Marquer la case comme bloquée par l'humain */
            dessinerGrille(*etatJeu); /* Redessiner la grille */
            jouerAvecIA(*etatJeu); /* Appeler la fonction de l'IA pour bloquer une case */
        }
    }
}
/* Fonction pour initialiser l'état du jeu */
struct EtatJeu initialiserJeu(int tailleGrille, int mode) {
    struct EtatJeu etatJeu;
    int i, j;

    etatJeu.tailleGrille = tailleGrille;
    etatJeu.mode = mode;
    etatJeu.tourJoueur = 1; /* Initialiser le joueur courant */
    etatJeu.phase = 0; /* Initialiser la phase */
    etatJeu.positionSourisJoueur1x = -1; /* Initialiser les positions de la souris */
    etatJeu.positionSourisJoueur1y = -1;
    etatJeu.positionSourisJoueur2x = -1;
    etatJeu.positionSourisJoueur2y = -1;

    /* Allouer de la mémoire pour la grille */
    etatJeu.grille = (int**)malloc(tailleGrille * sizeof(int*));
    if (etatJeu.grille == NULL) {
        fprintf(stderr, "Erreur d'allocation mémoire\n");
        exit(1);
    }

    for (i = 0; i < tailleGrille; i++) {
        etatJeu.grille[i] = (int*)malloc(tailleGrille * sizeof(int));
        if (etatJeu.grille[i] == NULL) {
            for (j = 0; j < i; j++) {
                free(etatJeu.grille[j]);
            }
            free(etatJeu.grille);
            fprintf(stderr, "Erreur d'allocation mémoire\n");
            exit(1);
        }
        for (j = 0; j < tailleGrille; j++) {
            etatJeu.grille[i][j] = 0; /* Initialiser les cellules de la grille à 0 */
        }
    }

    return etatJeu;
}

/* Fonction pour jouer avec l'IA */
void jouerAvecIA(struct EtatJeu etatJeu) {
    int i, j;
    /* Logique simple pour que l'IA bloque une case */
    for (i = 0; i < etatJeu.tailleGrille; i++) {
        for (j = 0; j < etatJeu.tailleGrille; j++) {
            if (etatJeu.grille[i][j] == 0) { /* Trouver une case libre */
                etatJeu.grille[i][j] = 2; /* Marquer la case comme bloquée par l'IA */
                dessinerGrille(etatJeu); /* Redessiner la grille */
                return; /* Sortir après avoir bloqué une case */
            }
        }
    }
}
/* Ajouter d'autres fonctions de logique de jeu si nécessaire */