#include<SDL/SDL.h>
  #include<SDL/SDL_ttf.h>
  #include"Graphique/libgraph.h"
  #include<stdbool.h>
  #include "main.h"
  #include <stdio.h>
  #include <stdlib.h>
  
  static SDL_Surface *surface;
  
  int vaisseauID = -1;
  int envahisseurID = -1;
  int missileID = -1;
  int bombeID = -1;
  
  
  void initListe(listeEntites* liste) {
      liste->tete = NULL;
  }
  
  
  void ajouterEntite(listeEntites* liste, int x, int y, int type, int etat) {
      entite* nouvelleEntite = (entite*)malloc(sizeof(entite));
      if (!nouvelleEntite) {
          fprintf(stderr, "Erreur : impossible d'allouer la mémoire pour une nouvelle entité.\n");
          exit(EXIT_FAILURE);
      }
      nouvelleEntite->x = x;
      nouvelleEntite->y = y;
      nouvelleEntite->type = type;
      nouvelleEntite->etat = etat;
      nouvelleEntite->suivante = liste->tete;
      liste->tete = nouvelleEntite;
      printf("Ajouté entité de type %d à (%d, %d)\n", type, x, y);
  }
  
  
  void initEnvahisseurs(listeEntites* liste, int nbEnvahisseurs, int y) {
      for (int i = 0; i < nbEnvahisseurs; i++) {
          ajouterEntite(liste, i * 40, y, 1, 1); // Type 1 pour envahisseur
      }
      printf("Initialisé %d envahisseurs à la position y = %d\n", nbEnvahisseurs, y);
  }
  
  
  void initVaisseau(entite* vaisseau, int x, int y) {
      vaisseau->x = x;
      vaisseau->y = y;
      vaisseau->type = 0;
      vaisseau->etat = 1;
      vaisseau->suivante = NULL;
      printf("Initialisé vaisseau à (%d, %d)\n", x, y);
  }
  
  
  void deplacerEnvahisseurs(listeEntites* envahisseurs, int largeurEcran, int* direction, bool* bordAtteint) {
      entite* courant = envahisseurs->tete;
      while (courant != NULL) {
          courant->x += *direction * 10;
  
  
          if (courant->x <= 0 || courant->x >= largeurEcran - 40) {
              *bordAtteint = true;
          }
  
          courant = courant->suivante;
      }
  
  
      if (*bordAtteint) {
          *direction = -*direction;
          courant = envahisseurs->tete;
          while (courant != NULL) {
              courant->y += 10;
              courant = courant->suivante;
          }
          *bordAtteint = false;
          printf("Les envahisseurs ont changé de direction\n");
      }
  }
  
  
  void gererEntrees(entite* vaisseau, listeEntites* missiles) {
      const Uint8* etatClavier = SDL_GetKeyState(NULL);
  
      if (etatClavier[SDLK_LEFT]) {
          vaisseau->x -= 10;
      }
      if (etatClavier[SDLK_RIGHT]) {
          vaisseau->x += 10;
      }
      if (etatClavier[SDLK_SPACE]) {
  
          ajouterEntite(missiles, vaisseau->x + 20, vaisseau->y - 10, 2, 1);
          printf("Missile tiré à (%d, %d)\n", vaisseau->x + 20, vaisseau->y - 10);
      }
  }
  
  
  bool collision(entite* a, entite* b) {
      return (a->x < b->x + 40 &&
              a->x + 40 > b->x &&
              a->y < b->y + 40 &&
              a->y + 40 > b->y);
  }
  
  entite* collisionAvecListe(entite* ent, listeEntites* liste) {
      entite* courant = liste->tete;
      while (courant != NULL) {
          if (collision(ent, courant)) {
              return courant;
          }
          courant = courant->suivante;
      }
      return NULL;
  }
  
  
  int chargerSprites() {
      vaisseauID = chargerLutin("invader_canon.bmp", 0);
      envahisseurID = chargerLutin("invader_monstre1_1.bmp", 1);
      missileID = chargerLutin("invader_missile.bmp", 2);
      bombeID = chargerLutin("invader_bombe.bmp", 3);
  
      if (vaisseauID < 0) {
          fprintf(stderr, "Erreur : échec du chargement du lutin vaisseau.\n");
          return 0;
      }
      if (envahisseurID < 0) {
          fprintf(stderr, "Erreur : échec du chargement du lutin envahisseur.\n");
          return 0;
      }
      if (missileID < 0) {
          fprintf(stderr, "Erreur : échec du chargement du lutin missile.\n");
          return 0;
      }
      if (bombeID < 0) {
          fprintf(stderr, "Erreur : échec du chargement du lutin bombe.\n");
          return 0;
      }
      printf("Sprites chargés avec succès\n");
      return 1;
  }
  
  
  void afficherEntite(entite* ent) {
      int lutinID;
      switch (ent->type) {
          case 0: lutinID = vaisseauID; break;
          case 1: lutinID = envahisseurID; break;
          case 2: lutinID = missileID; break;
          case 3: lutinID = bombeID; break;
          default:
              fprintf(stderr, "Erreur : type de lutin inconnu %d.\n", ent->type);
              return;
      }
      afficherLutin(lutinID, ent->x, ent->y);
      printf("Affichage de l'entité de type %d à (%d, %d)\n", ent->type, ent->x, ent->y);
  }
  
  
  int main() {
      if (!creerSurface(800, 600, "Space Invaders")) {
          fprintf(stderr, "Erreur lors de la création de la surface graphique.\n");
          return EXIT_FAILURE;
      }
  
      if (!chargerSprites()) {
          fprintf(stderr, "Erreur lors du chargement des sprites.\n");
          fermerSurface();
          return EXIT_FAILURE;
      }
  
     listeEntites envahisseurs;
     listeEntites missiles;
      initListe(&envahisseurs);
     initListe(&missiles);
  
      entite vaisseau;
      initVaisseau(&vaisseau, 380, 550);
  
      initEnvahisseurs(&envahisseurs, 10, 50);
  
      int direction = 1;
      bool bordAtteint = false;
  
  
  
  while(!getchar())
  {
      deplacerEnvahisseurs(&envahisseurs, 800, &direction, &bordAtteint);
      entite* missile = missiles.tete;
          while (missile != NULL) {
              entite* cible = collisionAvecListe(missile, &envahisseurs);
              if (cible != NULL) {
                  missile->etat = 0;
                  cible->etat = 0;
                  printf("Collision détectée entre missile et envahisseur\n");
              }
              missile = missile->suivante;
          }
  
  
  
  
  
  
          entite* courant = envahisseurs.tete;
          while (courant != NULL) {
              if (courant->etat == 1) {
                  afficherEntite(courant);
              }
              courant = courant->suivante;
          }
  
          if (vaisseau.etat == 1) {
              afficherEntite(&vaisseau);
          }
  
          missile = missiles.tete;
          while (missile != NULL) {
              if (missile->etat == 1) {
                  afficherEntite(missile);
              }
              missile = missile->suivante;
          }
  
          SDL_Flip(surface);
      }
  
      fermerSurface();
      return 0;
  
  
  }
  // calcul de collision entre l'ensemble des missiles et la liste d'entité