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

#define HAUTEUR 40
#define LARGEUR 60
#define CYCLE 100000L
#define TAILLE_CASE 20
#define SCORE_TO_WIN 50

/* Enumeration des différentes directions possibles */
enum Direction { UP = 2, DOWN = 3, LEFT = 0, RIGHT = 1 };

/* Structure pour stocker les coordonnées des segments du serpent */
typedef struct {
    int posx, posy;
} SnakePoint;

/* Fonction pour concevoir le graphique */
void graphique() {
    InitialiserGraphique();
    CreerFenetre(10, 10, 1240, 940);
    EcrireTexte(500, 400, "Le jeu va commencer !", 2);
    sleep(1);
    EffacerEcran(CouleurParComposante(0, 0, 0));
}

void AffichageBasique() {
    ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
    RemplirRectangle(10, 10, 1175, 775);
}

void AfficheTemps(int minute, int seconde) {
    char temps[6];
    snprintf(temps, 6, "%02d:%02d", minute, seconde);

    ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
    RemplirRectangle(20, 870, 70, 40);

    ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
    EcrireTexte(20, 900, temps, 2);
}

/* Fonction pour afficher le serpent */
void serpent(SnakePoint *snake, int taille) {
    for (int i = 0; i < taille; i++) {
        couleur s = CouleurParComposante(255, 255, 0);
        ChoisirCouleurDessin(s);
        RemplirRectangle(snake[i].posx * TAILLE_CASE, snake[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
    }
}

/* Fonction pour générer les pommes */
void genererPommes(SnakePoint *pommes) {
    for (int i = 0; i < 5; i++) {
        pommes[i].posx = rand() % (LARGEUR - 2) + 1;
        pommes[i].posy = rand() % (HAUTEUR - 2) + 1;
        couleur p = CouleurParComposante(255, 0, 0);
        ChoisirCouleurDessin(p);
        RemplirRectangle(pommes[i].posx * TAILLE_CASE, pommes[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
    }
}

/* Fonction pour gérer le mouvement de la tête du serpent */
void mouvementTete(SnakePoint *snake, int *taille, int *score, int *dir) {
    if (ToucheEnAttente()) {
        int touche = Touche();
        switch (touche) {
            case XK_Left:
                *dir = LEFT;
                break;
            case XK_Right:
                *dir = RIGHT;
                break;
            case XK_Up:
                *dir = UP;
                break;
            case XK_Down:
                *dir = DOWN;
                break;
        }
    }

    /* Déplace la tête en fonction de la direction */
    if (*dir == LEFT) {
        snake[0].posx -= 1;
    } else if (*dir == RIGHT) {
        snake[0].posx += 1;
    } else if (*dir == UP) {
        snake[0].posy -= 1;
    } else if (*dir == DOWN) {
        snake[0].posy += 1;
    }
}

/* Fonction pour gérer le mouvement du corps du serpent */
void mouvementCorps(SnakePoint *snake, int taille) {
    /* Déplace le corps du serpent en suivant la tête */
    for (int i = taille - 1; i > 0; i--) {
        snake[i] = snake[i - 1];
    }
}

/* Fonction pour gérer les collisions */
int gererCollisions(SnakePoint *snake, int *taille, int *score, SnakePoint *pommes, int *aMangerPomme) {
  int i;
    /* Vérifie la collision avec la pomme */
        if (snake[0].posx == pommes[i].posx && snake[0].posy == pommes[i].posy) {
            /* Augmente le score et génère une nouvelle pomme */
            *score += 5;
            pommes[i].posx = rand() % (LARGEUR - 2) + 1;
            pommes[i].posy = rand() % (HAUTEUR - 2) + 1;
            *aMangerPomme = 1;
            return 1; /* Le serpent a mangé une pomme */
        }
    

    /* Vérifie la collision avec la paroi intérieure du rectangle */
    if (snake[0].posx <= 0 || snake[0].posx >= LARGEUR - 1 || snake[0].posy <= 0 || snake[0].posy >= HAUTEUR - 1) {
        return -1; /* Collision avec la paroi */
    }
    return 0; /* Pas de collision */
}

int main() {
    /* Initialisation du jeu */
    graphique();
    SnakePoint snake[LARGEUR * HAUTEUR];
    SnakePoint pommes[5];
    int taille = 1;
    int score = 0;
    int dir = RIGHT; // Ajout de la direction initiale
    int aMangerPomme = 0;
    srand(time(NULL));

    /* Position initiale du serpent au milieu du tableau */
    snake[0].posx = LARGEUR / 2;
    snake[0].posy = HAUTEUR / 2;

    graphique();
    AffichageBasique();
    genererPommes(pommes);

    unsigned long suivant = Microsecondes() + CYCLE;
    int perdu = 0;
    int temps[2] = {0, 0}, seconde_actuel, old_seconde;

    while (!perdu) {
        /* Calcul du temps */
        if (Microsecondes() > suivant) {
            suivant = Microsecondes() + CYCLE;
            seconde_actuel = (suivant / 1000000) % 10;
            if (seconde_actuel != old_seconde) {
                old_seconde = seconde_actuel;
                if ((temps[1] + 1) == 60) {
                    temps[0]++;
                    temps[1] = 0;
                } else {
                    temps[1]++;
                }
                /* Affichage du temps */
                AfficheTemps(temps[0], temps[1]);
            }

            /* Déplacement du serpent */
            mouvementTete(snake, &taille, &score, &dir);
            mouvementCorps(snake, taille);
            perdu = gererCollisions(snake, &taille, &score, pommes, &aMangerPomme);
            serpent(snake, taille);

          
        }
    }
      /* Génération de nouvelles pommes si le serpent en a mangé une */
            if (aMangerPomme) {
                aMangerPomme = 0; // Réinitialise la variable après avoir généré les pommes
		genererPommes(pommes);
		perdu = 0; /* enlever ça pour faire des obstacle*/
            }

    if (perdu == -1) {
        printf("Vous avez perdu ! Collision avec la paroi.\n");
	 FermerGraphique();
	*score =0;
    }

   

    return EXIT_SUCCESS;
}