#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é