#include "comp/entity.h"
#include "comp/fighter.h"
#include "comp/visible.h"
#include "enemies.h"
#include <stdlib.h>
#include <math.h>
#include <stdarg.h>
#include <gint/defs/util.h>

fighter_stats_t fighter_stats_add(int amount, ...)
{
    va_list args;
    va_start(args, amount);

    fighter_stats_t m = { 0 };

    for(int i = 0; i < amount; i++) {
        fighter_stats_t op = va_arg(args, fighter_stats_t);
        m.HP  += op.HP;
        m.ATK += op.ATK;
        m.DEF += op.DEF;
        m.MAG += op.MAG;
    }

    va_end(args);
    return m;
}

fighter_stats_t fighter_stats_instantiate(fighter_stats_t const *base,
    fighter_stats_t const *slope, int level)
{
    fighter_stats_t m;
    m.HP  = base->HP  + level * slope->HP;
    m.ATK = base->ATK + level * slope->ATK;
    m.DEF = base->DEF + level * slope->DEF;
    m.MAG = base->MAG + level * slope->MAG;
    return m;
}

void fighter_set_stats(fighter_t *f, fighter_stats_t const *stats)
{
    f->HP_max = stats->HP;
    f->ATK    = stats->ATK;
    f->MAG    = stats->MAG;
    f->DEF    = stats->DEF;
}

void fighter_increase_stats(fighter_t *f, fighter_stats_t const *growth)
{
    int previous_HP_max = f->HP_max;
    f->HP_max += growth->HP;
    f->HP     += (f->HP_max - previous_HP_max);
    f->ATK    += growth->ATK;
    f->MAG    += growth->MAG;
    f->DEF    += growth->DEF;
}

int fighter_damage(entity_t *e, int base_damage)
{
    fighter_t *f = getcomp(e, fighter);

    if(f->HP == 0) return 0;

    base_damage = max(base_damage - f->DEF, 0);

    int variation = (base_damage >= 4) ? (rand() % (base_damage / 4)) : 0;
    int damage = (base_damage * 7) / 8 + variation;
    damage = max(damage, 1);

    if(f->HP < damage) f->HP = 0;
    else f->HP -= damage;

    if(f->enemy) {
        if(f->HP == 0)
            visible_set_anim(e, f->enemy->id->anim_death, 4);
        else
            visible_set_anim(e, f->enemy->id->anim_hit, 3);
    }
    else {
        visible_set_anim(e, &anims_player_Hit, 3);
    }

    return damage;
}

void fighter_effect_stun(entity_t *e, fixed_t duration)
{
    fighter_t *f = getcomp(e, fighter);
    f->stun_delay = max(f->stun_delay, duration);
}

void fighter_effect_invulnerability(entity_t *e, fixed_t duration)
{
    fighter_t *f = getcomp(e, fighter);
    f->invulnerability_delay = max(f->invulnerability_delay, duration);
}

void fighter_effect_speed(entity_t *e, fixed_t duration)
{
    fighter_t *f = getcomp(e, fighter);
    f->speed_delay = max(f->speed_delay, duration);
}

void fighter_destroy(entity_t *e)
{
    fighter_t *f = getcomp(e, fighter);
    free(f->enemy);
}