#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../Graphique/libgraph.h"
#include "../ListeC/Liste.h"
#include "Interactif.h"
#include "../Main/init.h"

#define TailleX 500
#define TailleY 500
#define Sol 475
#define ErreurHitbox 2


int CheckCollisionEntiteEntite(struct entite enti1, int L1, int H1, struct entite enti2, int L2, int H2)
{
    //CheckX
    int gauche1 = enti1.posx - L1/2 + ErreurHitbox;
    int droite1 = enti1.posx + L1/2 - ErreurHitbox;
    int gauche2 = enti2.posx - L2/2 + ErreurHitbox;
    int droite2 = enti2.posx + L2/2 - ErreurHitbox;
    int CheckX = (gauche1 >= gauche2 && gauche1 <= droite2) || (droite1 >= gauche2 && droite1 <= droite2);

    //CheckY
    int haut1 = enti1.posy - H1/2 + ErreurHitbox;
    int bas1  = enti1.posy + H1/2 - ErreurHitbox;
    int haut2 = enti2.posy - H2/2 + ErreurHitbox;
    int bas2  = enti2.posy + H2/2 - ErreurHitbox;
    int CheckY = (haut1 <= bas2 && haut1 >= haut2) || (bas1 <= bas2 && bas1 >= haut2);

    return CheckX && CheckY;
}


struct entite* CheckCollisionListeEntite(struct liste_entite *Liste1,int L1,int H1,struct entite enti2, int L2, int H2)
{
    struct liste_entite *pL1=Liste1;
    while (pL1 != NULL)
    {
        if(CheckCollisionEntiteEntite(pL1->enti,L1,H1,enti2,L2,H2) == 1)
        {
            return &pL1->enti;
        }
        pL1=pL1->suivant;
    }
    return NULL;
}




struct liste_entite* CheckCollisionListeListe(struct liste_entite *Liste1,int L1,int H1,struct liste_entite *Liste2,int L2, int H2)
{
    struct liste_entite *pL2=Liste2;
    while (pL2 != NULL)
    {
        struct entite* collision = CheckCollisionListeEntite(Liste1,L1,H1,pL2->enti,L2,H2);
        if (collision != NULL)
        {
            // Création des nœuds pour les deux entités
            struct liste_entite* Enti1 = malloc(sizeof(struct liste_entite));
            struct liste_entite* Enti2 = malloc(sizeof(struct liste_entite));

            // Remplissage des nœuds avec les entités correspondantes
            Enti1->enti = *collision;
            Enti2->enti = pL2->enti;

            // Relier les nœuds entre eux
            Enti1->suivant = Enti2;
            Enti2->suivant = NULL;

            return Enti1;
        }
        else
            pL2=pL2->suivant;
    }
    return NULL;
}




void SupprimerEntitesEnCollision(struct liste_entite** Liste1, int L1, int H1, struct liste_entite** Liste2, int L2, int H2) 
{
    struct liste_entite* collision = CheckCollisionListeListe(*Liste1, L1, H1, *Liste2, L2, H2);
    
    if (collision != NULL) {
        // Récupération des entités impliquées
        struct entite* enti1 = &collision->enti;
        struct entite* enti2 = &collision->suivant->enti;
        
        // Suppression de l'entité 1 de la liste 1
        SupprimerEntite(Liste1, enti1);
        
        // Suppression de l'entité 2 de la liste 2
        SupprimerEntite(Liste2, enti2);
        
       afficherLutin(bouillie, enti2->posx - hitboxbouillieL/2 + ErreurHitbox, enti2->posy - hitboxbouillieH/2 + ErreurHitbox);
    }
}





void Tirer(struct entite joueur, struct liste_entite **pl)
{
    if (*pl==NULL)
    {
        ajout_tete(pl,creer_entite(joueur.posx,joueur.posy,-1));
    }
}
    
    
void DeplacementTire(int tire, struct liste_entite** l)
{
    struct entite* ml = &(*l)->enti;
    if (ml != NULL) 
    {
        if (ml->posy <= 0) 
        {
            afficherLutin(bouillie, ml->posx - hitboxbouillieL/2 + ErreurHitbox, ml->posy);
            SupprimerEntite(l, ml);
        }
        else
        {
            ml->posy -= 5;
            //Je divise ErreurHitbox par 2 car l'erreur du missile est plus petite que pour les autres images
            afficherLutin(tire, ml->posx - hitboxmissileL/2 + ErreurHitbox/2, ml->posy - hitboxmissileH/2 + ErreurHitbox/2);
        }
    }
}



 
char touche()
{
    char touche;
    evenement even;
    lireEvenement (&even,&touche,NULL);
    return touche;
}



void action(struct entite *joueur, char c, struct liste_entite **tires)
{
    switch (c) 
    {
        case 'd':
            if (joueur->posx <= 9*TailleX/10) 
            {
                joueur->posx += 3;
            }
            break;
        case 'q':
            if (joueur->posx >= TailleX/10) 
            {
                joueur->posx -= 3;
            }
            break;
        case 't':
            Tirer(*joueur, tires);
            break;
        default:
            break;
    }
}



void MakeBombeDroppable(struct liste_entite* enemies, struct liste_entite** bombes)
{
    struct liste_entite* pL = enemies;
    struct liste_entite* Dropable = NULL;
    int taille = 0;
    while (pL != NULL)
    {
        if (pL->enti.dropbombe == 1)
        {
            ajout_tete(&Dropable,pL->enti);
            taille += 1;
        }
        pL=pL->suivant;
    }
    
    if(Dropable == NULL)
    {
        return;
    }
        
    int randomIndex = rand() % taille-1;
    struct liste_entite* pLDropable = Dropable;
    
    for (int i = 0; i <= randomIndex; i++)
    {
        pLDropable = pLDropable->suivant;
    }    
    ajout_tete(bombes,creer_entite(pLDropable->enti.posx,pLDropable->enti.posy,-1));
}


void DeplacementBombe(int bombe, struct liste_entite** l) 
{
    struct liste_entite* ml = *l;
    struct liste_entite* precedent = NULL;
    
    while (ml != NULL) 
    {
        if (ml->enti.posy + hitboxbombeH - ErreurHitbox >= Sol) 
        {
            struct entite* a_supprimer = &ml->enti;
            ml = ml->suivant;
            SupprimerEntite(l, a_supprimer);
        } 
        else 
        {
            ml->enti.posy += 2;
            afficherLutin(bombe, ml->enti.posx - hitboxbombeL/2 + ErreurHitbox, ml->enti.posy);
            precedent = ml;
            ml = ml->suivant;
        }
    }
}