#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, struct team_t *enemy)
{
    int degats;
    struct character_t *target;
    enum action_state_t ret = ACTION_CANCELED;
    unsigned int continuer = 1;
    int clan=ENNEMI;
    int selection = 0;
    SDL_Event event;
    int delay=1;
    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadreactions,surfaces->Pecran,&positions->Vpositioncadreactions);
    while(!enemy->chrs[selection].alive)
        selection++;
    Fchangercurseurennemis (surfaces,positions, &enemy->chrs[selection]);
    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:
                SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadrecible,surfaces->Pecran,&positions->Vpositioncadrecible);

                if (clan == ENNEMI) {
                    target = &enemy->chrs[selection];
                } else {
                    target = &ally->chrs[selection];
                }

                degats = compute_damages(&ally->chrs[ally->chr_cur], target, DAMAGES_PHYSICAL, ELEMENT_NONE);

                damage_target_hp(surfaces, target, degats);

                SDL_Flip(surfaces->Pecran);

                ret = ACTION_PERFORMED;
                continuer=0;
                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(const struct character_t *src, const struct character_t *dest,
        enum damages_type_t type, enum element_t element)
{
    int avg;
    int min;
    int max;

    /* we optimize if the target is invulnerable */
    if (element != ELEMENT_NONE && dest->affinities[element] == AFFINITY_INVULNERABILITY)
        return 0;

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

    if (element != ELEMENT_NONE) {
        switch (dest->affinities[element]) {
            case AFFINITY_SENSITIVE:
                avg *= 2;
                break;
            case AFFINITY_RESISTANCE:
                avg /= 2;
                break;
            case AFFINITY_INVULNERABILITY:
                avg = 0;
                break;
            case AFFINITY_ABSORPTION:
                avg = -avg;
                break;
            default:
                abort();
        }

        avg *= (dest->affinities[element] - 1);
    }

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

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

int Fcalculerdegats(struct team_t *ally, 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[ally->chr_cur].strength*60-ennemis[selection].defense*50;
        else
            degats=ally->chrs[ally->chr_cur].strength*60-ally->chrs[selection].defense*50;
    }
    else
    {
        if(camp==ENNEMI)
            degats=ally->chrs[ally->chr_cur].magic*60-ennemis[selection].defensemagique*50;
        else
            degats=ally->chrs[ally->chr_cur].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, struct team_t *enemy)
{
    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, enemy, 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, struct team_t *enemy)
{
    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, enemy);

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

    return ret;
}

enum action_state_t Fselectionnerobjet(SURFACES *surfaces,POSITIONS *positions, struct team_t *ally, struct team_t *enemy)
{
    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, enemy, &ally->objects,selection);
                    else if(selection==ETHER)
                        ret = Fether(surfaces,positions, ally, enemy, &ally->objects,selection);
                    else if(selection==POTIONPLUS)
                        ret = Fpotion(surfaces,positions, ally, enemy, &ally->objects,selection);

                }
                else if(page==1)
                {
                    if(selection==ETHERPLUS)
                        ret = Fether(surfaces,positions, ally, enemy, &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, struct team_t *enemy, OBJET *objets,int type)
{
    struct character_t *target;
    enum action_state_t ret = ACTION_CANCELED;
    int continuer=1;
    SDL_Event event;
    int selection=0;
    int delay=1;
    int soins=0;
    int clan=ALLIE;

    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:
                        SDL_BlitSurface(surfaces->Pfondjeu,&positions->Vpositioncadrecible,surfaces->Pecran,&positions->Vpositioncadrecible);

                        if (clan == ENNEMI) {
                            target = &enemy->chrs[selection];
                        } else {
                            target = &ally->chrs[selection];
                        }

                        if (type == POTION)
                            soins = 1000;
                        else if (type == POTIONPLUS)
                            soins = 4000;

                        cure_target_hp(surfaces, target, soins);

                        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, struct team_t *enemy, OBJET *objets,int type)
{
    struct character_t *target;
    enum action_state_t ret = ACTION_CANCELED;
    int continuer=1;
    SDL_Event event;
    int delay=1;
    int selection=0;
    int soins=0;
    int clan=ALLIE;

    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:
                            SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadrecible,surfaces->Pecran,&positions->Vpositioncadrecible);

                            if (clan == ENNEMI) {
                                target = &enemy->chrs[selection];
                            } else {
                                target = &ally->chrs[selection];
                            }

                            if (type == ETHER)
                                soins = 10;
                            else if (type == ETHERPLUS)
                                soins = 40;

                            cure_target_mp(surfaces, target, soins);

                            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;
}