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

void attack(SURFACES *surfaces, POSITIONS *positions, struct character_t *src, struct character_t *dest, void *data)
{
    int damages;

    (void) data;

    damages = compute_damages(src, dest, DAMAGES_PHYSICAL, ELEMENT_NONE);
    damage_target_hp(surfaces, positions, dest, damages);
}

void cast_element(SURFACES *surfaces, POSITIONS *positions, struct character_t *src, struct character_t *dest, void *data)
{
    int damages;
    enum element_t elem = *((enum element_t *)data);

    /* TODO remove the MP */

    damages = compute_damages(src, dest, DAMAGES_MAGICAL, elem);
    damage_target_hp(surfaces, positions, dest, damages);
}

void cast_cure(SURFACES *surfaces, POSITIONS *positions, struct character_t *src, struct character_t *dest, void *data)
{
    int cure;

    (void) data;

    cure = compute_cure(src, dest);
    cure_target_hp(surfaces, positions, dest, cure);
}

void use_potion(SURFACES *surfaces, POSITIONS *positions, struct character_t *src, struct character_t *dest, void *data)
{
    int type = *((int *)data);
    int cure;

    switch (type) {
        case POTION:
            cure = 1000;
            src->team->objects.potions--;
            break;
        case POTIONPLUS:
            cure = 4000;
            src->team->objects.potionsplus--;
            break;
        default:
            abort();
    }

    cure_target_hp(surfaces, positions, dest, cure);
}

void use_ether(SURFACES *surfaces, POSITIONS *positions, struct character_t *src, struct character_t *dest, void *data)
{
    int type = *((int *)data);
    int cure;

    switch (type) {
        case ETHER:
            cure = 10;
            src->team->objects.ethers--;
            break;
        case ETHERPLUS:
            cure = 40;
            src->team->objects.ethersplus--;
            break;
        default:
            abort();
    }

    cure_target_mp(surfaces, positions, dest, cure);
}

enum action_state_t Fattaquer(SURFACES *surfaces,POSITIONS *positions, struct team_t *ally, struct team_t *enemy, void *data)
{
    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);

    (void) data;

    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 Fpotion(SURFACES *surfaces,POSITIONS *positions, struct team_t *ally, struct team_t *enemy, void *data)
{
    struct character_t *target;
    SDL_Event event;
    int selection=0;
    int soins=0;
    int clan=ALLIE;

    int type = *((int *)data);

    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, void *data)
{
    struct character_t *target;
    SDL_Event event;
    int selection=0;
    int soins=0;
    int clan=ALLIE;

    int type = *((int *)data);

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