#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;
    int clan=ENNEMI;
    int selection = 0;
    SDL_Event event;
    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadreactions,surfaces->Pecran,&positions->Vpositioncadreactions);
    while(!enemy->chrs[selection].alive)
        selection++;
    update_selected_target(surfaces, positions, &enemy->chrs[selection]);

    for (;;) {
        SDL_Flip (surfaces->Pecran);
        SDL_WaitEvent (&event);
        switch (event.type)
        {
            case SDL_KEYDOWN:
            switch (event.key.keysym.sym)
            {
                case SDLK_ESCAPE:
                case SDLK_a:
                    update_selected_target(surfaces, positions, NULL);
                    SDL_Flip(surfaces->Pecran);
                    return ACTION_CANCELED;
                    SELECTION_CIBLE();
                case SDLK_RETURN:
                case SDLK_f:
                    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);

                    update_selected_target(surfaces, positions, NULL);

                    damage_target_hp(surfaces, positions, target, degats);
                    SDL_Flip(surfaces->Pecran);

                    SDL_Delay(1000);

                    SDL_BlitSurface(surfaces->Pfondjeu, &positions->Vpositiondegats, surfaces->Pecran, &positions->Vpositiondegats);

                    SDL_Flip(surfaces->Pecran);

                    return ACTION_PERFORMED;
                default:
                    break;
            }
            break;

        }
    }
}

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 (avg <= 0)
        return 0;

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

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

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

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);
        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);
                        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);
                        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);
        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);
                        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);
                        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);
        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);
                        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);
                        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, selection);
                            else if(selection==ETHER)
                                ret = Fether(surfaces,positions, ally, enemy, selection);
                            else if(selection==POTIONPLUS)
                                ret = Fpotion(surfaces,positions, ally, enemy, selection);

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

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

    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadreactions,surfaces->Pecran,&positions->Vpositioncadreactions);
    while (!ally->chrs[selection].alive)
        selection++;
    update_selected_target(surfaces,positions, &ally->chrs[selection]);
    SDL_Flip(surfaces->Pecran);

    for (;;) {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                    case SDLK_a:
                        update_selected_target(surfaces, positions, NULL);
                        SDL_Flip(surfaces->Pecran);
                        return ACTION_CANCELED;
                        SELECTION_CIBLE();
                    case SDLK_RETURN:
                    case SDLK_f:
                        if (clan == ENNEMI) {
                            target = &enemy->chrs[selection];
                        } else {
                            target = &ally->chrs[selection];
                        }

                        update_selected_target(surfaces, positions, NULL);

                        if (type == POTION) {
                            soins = 1000;
                            ally->objects.potions--;
                        } else if (type == POTIONPLUS) {
                            soins = 4000;
                            ally->objects.potionsplus--;
                        }

                        cure_target_hp(surfaces, positions, target, soins);

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

                        return ACTION_PERFORMED;
                    default:
                        break;
                }
                break;
        }
    }
}

enum action_state_t Fether(SURFACES *surfaces,POSITIONS *positions, struct team_t *ally, struct team_t *enemy, int type)
{
    struct character_t *target;
    SDL_Event event;
    int selection=0;
    int soins=0;
    int clan=ALLIE;

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

    SDL_BlitSurface (surfaces->Pfondjeu,&positions->Vpositioncadreactions,surfaces->Pecran,&positions->Vpositioncadreactions);
    while (!ally->chrs[selection].alive)
        selection++;
    update_selected_target(surfaces,positions, &ally->chrs[selection]);
    SDL_Flip(surfaces->Pecran);

    for (;;) {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                    case SDLK_a:
                        update_selected_target(surfaces, positions, NULL);
                        SDL_Flip(surfaces->Pecran);
                        return ACTION_CANCELED;
                        SELECTION_CIBLE();
                    case SDLK_RETURN:
                    case SDLK_f:
                        if (clan == ENNEMI) {
                            target = &enemy->chrs[selection];
                        } else {
                            target = &ally->chrs[selection];
                        }

                        if (type == ETHER) {
                            soins = 10;
                            ally->objects.ethers--;
                        } else if (type == ETHERPLUS) {
                            soins = 40;
                            ally->objects.ethersplus--;
                        }

                        cure_target_mp(surfaces, positions, target, soins);

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

                        return ACTION_PERFORMED;
                    default:
                        break;
                }
                break;
        }
    }
}