#include <algorithm>
#include "Creature.hpp"
#include "../Models/Battle.hpp"

using namespace CreatureLib;

Battling::Creature::Creature(const Library::CreatureSpecies* species, const Library::SpeciesVariant* variant,
                             uint8_t level, uint32_t experience, Core::StatisticSet<uint8_t> statExp,
                             Core::StatisticSet<uint8_t> statPotential, uint32_t uid, Library::Gender gender,
                             uint8_t coloring, const Library::Item *heldItem, std::string nickname, int8_t talent,
                             std::vector<LearnedAttack *> attacks)
                             :
                             __Species(species),
                             __Variant(variant),
                             __Level(level),
                             __Experience(experience),
                             __StatExperience(statExp),
                             __StatPotential(statPotential),
                             __UniqueIdentifier(uid),
                             __Gender(gender),
                             __Coloring(coloring),
                             __HeldItem(heldItem),
                             _nickname(nickname),
                             _talentIndex(talent),
                             _attacks(attacks)
                             {}



void Battling::Creature::ChangeLevel(int8_t amount) {
    this->__Level += amount;
    RecalculateFlatStats();
}

void Battling::Creature::SetBattle(Battling::Battle *battle) {
    this->_battle = battle;
}

void Battling::Creature::SetBattleLibrary(Battling::BattleLibrary *library) {
    this->_library = library;
}

const std::string &Battling::Creature::GetNickname() const {
    if (_nickname.empty())
        return __Species->GetName();
    return _nickname;
}

const std::string &Battling::Creature::GetTalent() const {
    return __Variant->GetTalent(_talentIndex);
}

void Battling::Creature::SetBattleData(Battling::Battle *battle, Battling::BattleSide *side) {
    _battle = battle;
    _side = side;
}

//region Stat APIs

void Battling::Creature::ChangeStatBoost(Core::Statistic stat, int8_t diffAmount){
    if (diffAmount > 0)
        this->_statBoost.IncreaseStatBy(stat, diffAmount);
    else
        this->_statBoost.DecreaseStatBy(stat, diffAmount);
    this->RecalculateBoostedStat(stat);
}

uint32_t Battling::Creature::GetFlatStat(Core::Statistic stat) const{
    return _flatStats.GetStat(stat);
}

uint32_t Battling::Creature::GetBoostedStat(Core::Statistic stat) const{
    return _boostedStats.GetStat(stat);
}

uint32_t Battling::Creature::GetBaseStat(Core::Statistic stat) const {
    return __Variant->GetStatistic(stat);
}

uint32_t Battling::Creature::GetStatPotential(Core::Statistic stat) const {
    return __StatPotential.GetStat(stat);
}

uint32_t Battling::Creature::GetStatExperience(Core::Statistic stat) const {
    return __StatExperience.GetStat(stat);
}

int8_t Battling::Creature::GetStatBoost(Core::Statistic stat) const {
    return _statBoost.GetStat(stat);
}

void Battling::Creature::RecalculateFlatStats() {
    this->_flatStats = this->_library->GetStatCalculator()->CalculateFlatStats(this);
    RecalculateBoostedStats();
}
void Battling::Creature::RecalculateBoostedStats() {
    this->_boostedStats = this->_library->GetStatCalculator()->CalculateFlatStats(this);
}

void Battling::Creature::RecalculateFlatStat(Core::Statistic stat) {
    auto s = this->_library->GetStatCalculator()->CalculateFlatStat(this, stat);
    this->_flatStats.SetStat(stat, s);
    RecalculateBoostedStat(stat);
}

void Battling::Creature::RecalculateBoostedStat(Core::Statistic stat) {
    auto s = this->_library->GetStatCalculator()->CalculateBoostedStat(this, stat);
    this->_boostedStats.SetStat(stat, s);
}

//endregion

Battling::Battle *Battling::Creature::GetBattle() const{
    return _battle;
}

Battling::BattleSide *Battling::Creature::GetBattleSide() const {
    return _side;
}

bool Battling::Creature::IsFainted() const {
    return this->__CurrentHealth <= 0;
}

void Battling::Creature::Damage(uint32_t damage, Battling::DamageSource source) {
    if (damage > __CurrentHealth){
        damage = __CurrentHealth;
    }
    // HOOK: On Damage
    __CurrentHealth -= damage;
}

const std::vector<uint8_t>& Battling::Creature::GetTypes() const {
    //HOOK: override types.
    return this->__Variant->GetTypes();
}

bool Battling::Creature::HasType(uint8_t type) const {
    auto t = GetTypes();
    return std::find(t.begin(), t.end(), type) != t.end();
}