#include <stdlib.h>

#include "structures.h"

#include "constantes.h"

#include "target.h"
#include "character.h"

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

static int compute_cure(const struct character_t *src, const struct character_t *dest)
{
    int avg, max, min;

    /* TODO maybe we should use the dest to compute the cure ? */
    (void) dest;

    avg = src->magic * 20;
    min = avg - avg / 4;
    max = avg + avg / 4;

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

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

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

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

    __attack(surfaces, positions, src, dest->chr);
}

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

    /* TODO remove the MP */

    if (dest->is_chr) {
        damages = compute_damages(src, dest->chr, DAMAGES_MAGICAL, elem);
        damage_target_hp(surfaces, positions, dest->chr, damages);
    } else {
        for (int i = 0; i < dest->team->chr_cnt; ++i) {
            struct character_t *target = &dest->team->chrs[i];

            if (!target->alive)
                continue;

            damages = compute_damages(src, target, DAMAGES_MAGICAL, elem);
            damage_target_hp(surfaces, positions, target, damages / 3);
        }
    }
}

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

    (void) data;

    if (dest->is_chr) {
        cure = compute_cure(src, dest->chr);
        cure_target_hp(surfaces, positions, dest->chr, cure);
    } else {
        for (int i = 0; i < dest->team->chr_cnt; ++i) {
            struct character_t *target = &dest->team->chrs[i];

            if (!target->alive)
                continue;

            cure = compute_cure(src, target);
            cure_target_hp(surfaces, positions, target, cure / 3);
        }
    }
}


static
void __use_potion(SURFACES *surfaces, POSITIONS *positions, struct character_t *src, struct character_t *dest, int type)
{
    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_potion(SURFACES *surfaces, POSITIONS *positions, struct character_t *src, struct target_t *dest, void *data)
{
    __use_potion(surfaces, positions, src, dest->chr, *((int *)data));
}

static
void __use_ether(SURFACES *surfaces, POSITIONS *positions, struct character_t *src, struct character_t *dest, int type)
{
    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);
}

void use_ether(SURFACES *surfaces, POSITIONS *positions, struct character_t *src, struct target_t *dest, void *data)
{
    __use_ether(surfaces, positions, src, dest->chr, *((int *)data));
}