#include <SDL/SDL.h>
#include "structures.h"
#include "constantes.h"
#include "prototypes.h"
#include <stdio.h>
#include <stdlib.h>

enum action_state_t Fattaquer(SURFACES *surfaces,POSITIONS *positions, struct team_t *ally, int Vtourallie,ENNEMIS ennemis[],int Vnbennemis)
{
    int max;
    int min;
    enum action_state_t ret = ACTION_CANCELED;
    unsigned int continuer = 1;
    int degats;
    unsigned int Bdegats=DEGATS;
    int clan=ENNEMI;
    int selection = 0;
    SDL_Event event;
    int delay=1;
    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadreactions,surfaces->Pecran,&positions->Vpositioncadreactions);
    while(ennemis[selection].etat==MORT)
        selection++;
    Fchangercurseurennemis (surfaces,positions,selection,ennemis);
    while (continuer)
    {
        SDL_Flip (surfaces->Pecran);
        SDL_WaitEvent (&event);
        switch (event.type)
        {
            case SDL_KEYDOWN:
            switch (event.key.keysym.sym)
            {
                case SDLK_ESCAPE:
                case SDLK_a:
                delay=0;
                continuer = 0;
                if(clan==ENNEMI)
                {
                    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadrecible,surfaces->Pecran,&positions->Vpositioncadrecible);
                    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncurseurennemis,surfaces->Pecran,&positions->Vpositioncurseurennemis);
                }
                else
                    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncurseurallies,surfaces->Pecran,&positions->Vpositioncurseurallies);
                SDL_Flip (surfaces->Pecran);
                break;
                SELECTION_CIBLE()
                case SDLK_RETURN:
                case SDLK_f:
                continuer=0;
                max=Fcalculerdegats(ally, Vtourallie,&min,ennemis,selection,clan,TYPE_ATTAQUE);
                degats=(rand()%(max-min+1))+min;
                if(degats<0)
                    degats=0;
                if(clan==ENNEMI) // si l'action se fait sur un ennemi
                {
                    if(Bdegats==DEGATS) // si on inflige des degats
                        ennemis[selection].pv-=degats; // on vire des pv
                    else // si c'est un soin pour x raison
                        ennemis[selection].pv+=degats; // on rajoute des pv
                    if(ennemis[selection].pv<=0)
                    {
                        ennemis[selection].pv=0;
                        ennemis[selection].etat=MORT;
                        positions->Vpositionmort.x=positions->Vpositionennemis[selection].x+surfaces->Tennemi[selection]->w/2-surfaces->Pmort->w/2;
                        positions->Vpositionmort.y=positions->Vpositionennemis[selection].y+surfaces->Tennemi[selection]->h/2-surfaces->Pmort->h/2;
                        SDL_BlitSurface(surfaces->Pmort,NULL,surfaces->Pecran,&positions->Vpositionmort);
                    }
                    else if(ennemis[selection].pv>ennemis[selection].pvinitiaux)
                        ennemis[selection].pv=ennemis[selection].pvinitiaux;
                    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncurseurennemis,surfaces->Pecran,&positions->Vpositioncurseurennemis);
                }
                else // sinon si on actionne sur un allié
                {
                    struct character_t *chr = &ally->chrs[selection];

                    if(Bdegats==DEGATS)
                        chr->hp -= degats;
                    else
                        chr->hp += degats;
                    if(chr->hp <= 0)
                    {
                        chr->hp = 0;
                        chr->alive = false;
                        positions->Vpositionmort.x=positions->Vpositionpersos[selection].x+surfaces->Tperso[selection]->w/2-surfaces->Pmort->w/2;
                        positions->Vpositionmort.y=positions->Vpositionpersos[selection].y+surfaces->Tperso[selection]->h/2-surfaces->Pmort->h/2;
                        SDL_BlitSurface(surfaces->Pmort,NULL,surfaces->Pecran,&positions->Vpositionmort);
                    }
                    else if (chr->hp > chr->max_hp)
                        chr->hp = chr->max_hp;
                    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncurseurallies,surfaces->Pecran,&positions->Vpositioncurseurallies);
                }
                if(Bdegats==DEGATS)
                    Fafficherdegats (surfaces,positions,degats,clan,selection, ally);
                else
                    Faffichersoins (surfaces,positions,degats,clan,selection, ally);
                if(clan==ENNEMI) // si l'ennemi est visé
                {
                    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadrecible,surfaces->Pecran,&positions->Vpositioncadrecible);
                    SDL_Flip (surfaces->Pecran); // on supprime le cadre cible de l'ecran
                }
                ret = ACTION_PERFORMED;
                break;
                default:
                break;
            }
            break;

        }
    }
    if (delay)
        SDL_Delay(1000);
    SDL_BlitSurface(surfaces->Pfondjeu,&positions->Vpositiondegats,surfaces->Pecran,&positions->Vpositiondegats);
    SDL_Flip(surfaces->Pecran);

    return ret;
}

int compute_damages(struct character_t *src, struct character_t *dest,
        enum damages_type_t type)
{
    int avg;
    int min;
    int max;

    if (type == DAMAGES_PHYSICAL) {
        avg = src->strength * 60 - dest->defense * 50;
    } else if (type == DAMAGES_MAGICAL) {
        avg = src->magic * 60 - dest->spirit * 50;
    }

    min = avg - avg / 4;
    max = avg + avg / 4;

    return rand() % (max - min + 1) + min;
}

int Fcalculerdegats(struct team_t *ally, int Vtourallie,int *min,ENNEMIS ennemis[],int selection,int camp,int type)
{
    unsigned int degats;
    int max;
    int taux;

    if(type==TYPE_ATTAQUE)
    {
        if(camp==ENNEMI)
            degats=ally->chrs[Vtourallie].strength*60-ennemis[selection].defense*50;
        else
            degats=ally->chrs[Vtourallie].strength*60-ally->chrs[selection].defense*50;
    }
    else
    {
        if(camp==ENNEMI)
            degats=ally->chrs[Vtourallie].magic*60-ennemis[selection].defensemagique*50;
        else
            degats=ally->chrs[Vtourallie].magic*60-ally->chrs[selection].spirit*50;
    }
    taux=degats/4;
    max=degats+taux;
    *min=degats-taux;

    return max;
}

enum action_state_t Fselectionnermagienoire(SURFACES *surfaces,POSITIONS *positions, struct team_t *ally, int Vtourallie,ENNEMIS ennemis[],int Vnbennemis)
{
    SDL_Event event;
    unsigned int continuer=1;
    enum action_state_t ret = ACTION_CANCELED;
    int nbactions=5;
    int page=0;
    int selection=0;

    while (continuer)
    {
        Fchangeractionselectionnee(surfaces,positions,selection,page,nbactions,MAGIE_NOIRE,NULL);
        SDL_WaitEvent (&event);
        switch (event.type)
        {
            case SDL_KEYDOWN:
            switch (event.key.keysym.sym)
            {
                case SDLK_a:
                case SDLK_ESCAPE:
                continuer=0;
                break;
                case SDLK_k:
                case SDLK_UP:
                if(selection!=0)
                    selection--;
                else
                    selection=nbactions-1;
                page=selection/3;
                Fchangeractionselectionnee(surfaces,positions,selection,page,nbactions,MAGIE_NOIRE,NULL);
                break;
                case SDLK_j:
                case SDLK_DOWN:
                if (selection!=nbactions-1)
                    selection++;
                else
                    selection=0;
                page=selection/3;
                Fchangeractionselectionnee(surfaces,positions,selection,page,nbactions,MAGIE_NOIRE,NULL);
                break;
                case SDLK_f:
                case SDLK_RETURN:
                SDL_BlitSurface(surfaces->Pfondjeu,&positions->Vpositiondegats,surfaces->Pecran,&positions->Vpositiondegats);
                SDL_Flip(surfaces->Pecran);
                ret = Fmagieelement(surfaces,positions, ally, Vtourallie,ennemis,Vnbennemis,selection);

                if (ret == ACTION_PERFORMED) {
                    continuer = 0;
                }

                break;
                default:
                break;
            }
        }
    }

    return ret;
}

enum action_state_t Fselectionnermagieblanche(SURFACES *surfaces,POSITIONS *positions, struct team_t *ally, int Vtourallie,ENNEMIS ennemis[],int Vnbennemis)
{
    enum action_state_t ret = ACTION_CANCELED;
    int continuer=1;
    int nbactions=1;
    int page=0;
    int selection=0;
    SDL_Event event;

    while (continuer)
    {
        Fchangeractionselectionnee(surfaces,positions,selection,page,nbactions,MAGIE_BLANCHE,NULL);
        SDL_WaitEvent (&event);
        switch (event.type)
        {
            case SDL_KEYDOWN:
            switch (event.key.keysym.sym)
            {
                case SDLK_ESCAPE:
                case SDLK_a:
                continuer=0;
                break;
                case SDLK_UP:
                case SDLK_k:
                if (selection!=0)
                    selection--;
                else
                    selection=nbactions-1;
                page=selection/3;
                Fchangeractionselectionnee(surfaces,positions,selection,page,nbactions,MAGIE_BLANCHE,NULL);
                break;
                case SDLK_DOWN:
                case SDLK_j:
                if(selection!=nbactions-1)
                    selection++;
                else
                    selection=0;
                page=selection/3;
                Fchangeractionselectionnee(surfaces,positions,selection,page,nbactions,MAGIE_BLANCHE,NULL);
                break;
                case SDLK_f:
                case SDLK_RETURN:
                SDL_BlitSurface(surfaces->Pfondjeu,&positions->Vpositiondegats,surfaces->Pecran,&positions->Vpositiondegats);
                SDL_Flip(surfaces->Pecran);
                if(selection==SOIN)
                    ret = Fmagiesoin(surfaces,positions, ally, Vtourallie,ennemis,Vnbennemis);

                    if (ret == ACTION_PERFORMED) {
                        continuer = 0;
                    }
                break;
                default:
                break;
            }
        }
    }

    return ret;
}

enum action_state_t Fselectionnerobjet(SURFACES *surfaces,POSITIONS *positions, struct team_t *ally, int Vtourallie,ENNEMIS ennemis[],int Vnbennemis)
{
    enum action_state_t ret = ACTION_CANCELED;
    SDL_Event event;
    unsigned int continuer=1;
    int nbactions=4;
    int page=0;
    int selection=0;

    while (continuer)
    {
        Fchangeractionselectionnee(surfaces,positions,selection,page,nbactions,OBJETS, &ally->objects);
        SDL_WaitEvent (&event);
        switch (event.type)
        {
            case SDL_KEYDOWN:
            switch (event.key.keysym.sym)
            {
                case SDLK_ESCAPE:
                case SDLK_a:
                continuer=0;
                break;
                case SDLK_UP:
                case SDLK_k:
                if(selection!=0)
                    selection--;
                else
                    selection=nbactions-1;
                page=selection/3;
                Fchangeractionselectionnee(surfaces,positions,selection,page,nbactions,OBJETS, &ally->objects);
                break;
                case SDLK_DOWN:
                case SDLK_j:
                if (selection!=nbactions-1)
                    selection++;
                else
                    selection=0;
                page=selection/3;
                Fchangeractionselectionnee(surfaces,positions,selection,page,nbactions,OBJETS, &ally->objects);
                break;
                case SDLK_RETURN:
                case SDLK_f:
                SDL_BlitSurface(surfaces->Pfondjeu,&positions->Vpositiondegats,surfaces->Pecran,&positions->Vpositiondegats);
                SDL_Flip(surfaces->Pecran);
                if(page==0)
                {
                    if(selection==POTION)
                        ret = Fpotion(surfaces,positions, ally,Vtourallie,ennemis,Vnbennemis, &ally->objects,selection);
                    else if(selection==ETHER)
                        ret = Fether(surfaces,positions, ally,Vtourallie,ennemis,Vnbennemis, &ally->objects,selection);
                    else if(selection==POTIONPLUS)
                        ret = Fpotion(surfaces,positions, ally,Vtourallie,ennemis,Vnbennemis, &ally->objects,selection);

                }
                else if(page==1)
                {
                    if(selection==ETHERPLUS)
                        ret = Fether(surfaces,positions, ally,Vtourallie,ennemis,Vnbennemis, &ally->objects,selection);
                }

                if (ret == ACTION_PERFORMED) {
                    continuer = 0;
                }

                break;
                default:
                break;
            }
        }
    }

    return ret;
}

enum action_state_t Fpotion(SURFACES *surfaces,POSITIONS *positions, struct team_t *ally, int Vtourallie,ENNEMIS ennemis[],int Vnbennemis,OBJET *objets,int type)
{
    enum action_state_t ret = ACTION_CANCELED;
    int continuer=1;
    SDL_Event event;
    int selection=0;
    int delay=1;
    int soins=0;
    int Bdegats=SOINS;
    int clan=ALLIE;

    /* since the item does not depend on a specific character .. */
    (void) Vtourallie;

    if(type==POTION&&objets->potions<=0)
        return ACTION_ERROR;
    else if(type==POTIONPLUS&&objets->potionsplus<=0)
        return ACTION_ERROR;

    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadreactions,surfaces->Pecran,&positions->Vpositioncadreactions);
    while (!ally->chrs[selection].alive)
        selection++;
    Fchangercurseurpersos (surfaces,positions,selection);
    while(continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                    case SDLK_a:
                        delay=0;
                        continuer = 0;
                        if(clan==ENNEMI)
                        {
                            SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadrecible,surfaces->Pecran,&positions->Vpositioncadrecible);
                            SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncurseurennemis,surfaces->Pecran,&positions->Vpositioncurseurennemis);
                        }
                        else
                            SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncurseurallies,surfaces->Pecran,&positions->Vpositioncurseurallies);
                        SDL_Flip (surfaces->Pecran);
                        break;
                        SELECTION_CIBLE()
                    case SDLK_RETURN:
                    case SDLK_f:
                            if(type==POTION)
                                soins=1000;
                            else if(type==POTIONPLUS)
                                soins=4000;
                            if(clan==ENNEMI)
                            {
                                if(Bdegats==DEGATS)
                                    ennemis[selection].pv-=soins;
                                else
                                    ennemis[selection].pv+=soins;
                                if(ennemis[selection].pv<=0)
                                {
                                    ennemis[selection].pv=0;
                                    ennemis[selection].etat=MORT;
                                    positions->Vpositionmort.x=positions->Vpositionennemis[selection].x+surfaces->Tennemi[selection]->w/2-surfaces->Pmort->w/2;
                                    positions->Vpositionmort.y=positions->Vpositionennemis[selection].y+surfaces->Tennemi[selection]->h/2-surfaces->Pmort->h/2;
                                    SDL_BlitSurface(surfaces->Pmort,NULL,surfaces->Pecran,&positions->Vpositionmort);
                                }
                                else if(ennemis[selection].pv>ennemis[selection].pvinitiaux)
                                    ennemis[selection].pv=ennemis[selection].pvinitiaux;
                                SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncurseurennemis,surfaces->Pecran,&positions->Vpositioncurseurennemis);
                            }
                            else
                            {
                                struct character_t *chr = &ally->chrs[selection];

                                if (Bdegats == DEGATS)
                                    chr->hp -= soins;
                                else
                                    chr->hp+=soins;
                                if (chr->hp <= 0) {
                                    chr->hp = 0;
                                    chr->alive = false;
                                    positions->Vpositionmort.x=positions->Vpositionpersos[selection].x+surfaces->Tperso[selection]->w/2-surfaces->Pmort->w/2;
                                    positions->Vpositionmort.y=positions->Vpositionpersos[selection].y+surfaces->Tperso[selection]->h/2-surfaces->Pmort->h/2;
                                    SDL_BlitSurface(surfaces->Pmort,NULL,surfaces->Pecran,&positions->Vpositionmort);
                                } else if (chr->hp > chr->max_hp)
                                    chr->hp = chr->max_hp;
                                SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncurseurallies,surfaces->Pecran,&positions->Vpositioncurseurallies);
                            }
                            if(Bdegats==DEGATS)
                                Fafficherdegats (surfaces,positions,soins,clan,selection, ally);
                            else
                                Faffichersoins (surfaces,positions,soins,clan,selection, ally);
                            if(clan==ENNEMI)
                            {
                                SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadrecible,surfaces->Pecran,&positions->Vpositioncadrecible);
                                SDL_Flip (surfaces->Pecran);
                            }
                            continuer=0;
                            ret = ACTION_PERFORMED;
                            if(type==POTION)
                                objets->potions--;
                            else if(type==POTIONPLUS)
                                objets->potionsplus--;
                            break;
                    default:
                            break;
                }
                break;
        }
    }
    if (delay)
        SDL_Delay(1000);
    SDL_BlitSurface(surfaces->Pfondjeu,&positions->Vpositiondegats,surfaces->Pecran,&positions->Vpositiondegats);
    SDL_Flip(surfaces->Pecran);

    return ret;
}

enum action_state_t Fether(SURFACES *surfaces,POSITIONS *positions, struct team_t *ally, int Vtourallie,ENNEMIS ennemis[],int Vnbennemis,OBJET *objets,int type)
{
    enum action_state_t ret = ACTION_CANCELED;
    int continuer=1;
    SDL_Event event;
    int delay=1;
    int selection=0;
    int soins=0;
    int Bdegats=SOINS;
    int clan=ALLIE;

    (void) Vtourallie;

    if(type==ETHER&&objets->ethers<=0)
        return ACTION_ERROR;
    else if(type==ETHERPLUS&&objets->ethersplus<=0)
        return ACTION_ERROR;

    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadreactions,surfaces->Pecran,&positions->Vpositioncadreactions);
    while (!ally->chrs[selection].alive)
        selection++;
    Fchangercurseurpersos (surfaces,positions,selection);
    while(continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                    case SDLK_a:
                        delay=0;
                        continuer = 0;
                        if(clan==ENNEMI)
                        {
                            SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadrecible,surfaces->Pecran,&positions->Vpositioncadrecible);
                            SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncurseurennemis,surfaces->Pecran,&positions->Vpositioncurseurennemis);
                        }
                        else
                            SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncurseurallies,surfaces->Pecran,&positions->Vpositioncurseurallies);
                        SDL_Flip (surfaces->Pecran);
                        break;
                        SELECTION_CIBLE()
                    case SDLK_RETURN:
                    case SDLK_f:
                            if(type==ETHER)
                                soins=10;
                            else if(type==ETHERPLUS)
                                soins=40;
                            if(clan==ENNEMI)
                            {
                                if(Bdegats==DEGATS)
                                    ennemis[selection].pm-=soins;
                                else
                                    ennemis[selection].pm+=soins;
                                if(ennemis[selection].pm<=0)
                                {
                                    ennemis[selection].pm=0;
                                    ennemis[selection].etat=MORT;
                                    positions->Vpositionmort.x=positions->Vpositionennemis[selection].x+surfaces->Tennemi[selection]->w/2-surfaces->Pmort->w/2;
                                    positions->Vpositionmort.y=positions->Vpositionennemis[selection].y+surfaces->Tennemi[selection]->h/2-surfaces->Pmort->h/2;
                                    SDL_BlitSurface(surfaces->Pmort,NULL,surfaces->Pecran,&positions->Vpositionmort);
                                }
                                else if(ennemis[selection].pm>ennemis[selection].pminitiaux)
                                    ennemis[selection].pm=ennemis[selection].pminitiaux;
                                SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncurseurennemis,surfaces->Pecran,&positions->Vpositioncurseurennemis);
                            }
                            else
                            {
                                struct character_t *chr = &ally->chrs[selection];
                                if(Bdegats==DEGATS)
                                    chr->mp-=soins;
                                else
                                    chr->mp+=soins;
                                if(chr->mp<=0)
                                {
                                    chr->mp=0;
                                    positions->Vpositionmort.x=positions->Vpositionpersos[selection].x+surfaces->Tperso[selection]->w/2-surfaces->Pmort->w/2;
                                    positions->Vpositionmort.y=positions->Vpositionpersos[selection].y+surfaces->Tperso[selection]->h/2-surfaces->Pmort->h/2;
                                    SDL_BlitSurface(surfaces->Pmort,NULL,surfaces->Pecran,&positions->Vpositionmort);
                                }
                                else if(chr->mp > chr->max_mp)
                                    chr->mp = chr->max_mp;
                                SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncurseurallies,surfaces->Pecran,&positions->Vpositioncurseurallies);
                            }
                            if(Bdegats==DEGATS)
                                Fafficherdegats (surfaces,positions,soins,clan,selection, ally);
                            else
                                Faffichersoins (surfaces,positions,soins,clan,selection, ally);
                            if(clan==ENNEMI)
                            {
                                SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadrecible,surfaces->Pecran,&positions->Vpositioncadrecible);
                                SDL_Flip (surfaces->Pecran);
                            }
                            continuer=0;
                            ret = ACTION_PERFORMED;
                            if(type==ETHER)
                                objets->ethers--;
                            else if(type==ETHERPLUS)
                                objets->ethersplus--;
                            break;
                    default:
                            break;
                }
                break;
        }
    }
    if (delay)
        SDL_Delay(1000);
    SDL_BlitSurface(surfaces->Pfondjeu,&positions->Vpositiondegats,surfaces->Pecran,&positions->Vpositiondegats);
    SDL_Flip(surfaces->Pecran);

    return ret;
}