#include "CreatePokemon.hpp"

PkmnLib::Battling::CreatePokemon*
PkmnLib::Battling::CreatePokemon::WithRandomIndividualValues(CreatureLib::Core::Random rand) {
    _ivHp = rand.Get(0, 32);
    _ivAttack = rand.Get(0, 32);
    _ivDefense = rand.Get(0, 32);
    _ivSpAtt = rand.Get(0, 32);
    _ivSpDef = rand.Get(0, 32);
    _ivSpeed = rand.Get(0, 32);
    return this;
}

PkmnLib::Battling::CreatePokemon*
PkmnLib::Battling::CreatePokemon::WithIndividualValue(CreatureLib::Core::Statistic stat, uint8_t value) {
    switch (stat) {
        case PkmnLib::Library::Statistic::HealthPoints: _ivHp = value; break;
        case PkmnLib::Library::Statistic::PhysicalAttack: _ivAttack = value; break;
        case PkmnLib::Library::Statistic::PhysicalDefense: _ivDefense = value; break;
        case PkmnLib::Library::Statistic::SpecialAttack: _ivSpAtt = value; break;
        case PkmnLib::Library::Statistic::SpecialDefense: _ivSpDef = value; break;
        case PkmnLib::Library::Statistic::Speed: _ivSpeed = value; break;
    }
    return this;
}

PkmnLib::Battling::CreatePokemon* PkmnLib::Battling::CreatePokemon::WithEffortValue(CreatureLib::Core::Statistic stat,
                                                                                    uint8_t value) {
    switch (stat) {
        case PkmnLib::Library::Statistic::HealthPoints: _evHp = value; break;
        case PkmnLib::Library::Statistic::PhysicalAttack: _evAttack = value; break;
        case PkmnLib::Library::Statistic::PhysicalDefense: _evDefense = value; break;
        case PkmnLib::Library::Statistic::SpecialAttack: _evSpAtt = value; break;
        case PkmnLib::Library::Statistic::SpecialDefense: _evSpDef = value; break;
        case PkmnLib::Library::Statistic::Speed: _evSpeed = value; break;
    }
    return this;
}

PkmnLib::Battling::Pokemon* PkmnLib::Battling::CreatePokemon::Build() {
    auto rand = CreatureLib::Core::Random();
    const PkmnLib::Library::PokemonSpecies* species = nullptr;
    if (!this->_library->GetSpeciesLibrary()->TryGetPkmnSpecies(this->_species, species)) {
        throw CreatureException("Invalid species: " + _species);
    }
    auto forme = species->GetForme(this->_forme);
    int8_t ability;
    if (this->_ability.empty()) {
        ability = forme->GetRandomTalent(&rand);
    } else {
        ability = forme->GetTalentIndex(this->_ability);
    }
    auto identifier = this->_identifier;
    if (identifier == 0) {
        identifier = rand.Get();
    }
    auto gender = this->_gender;
    if (gender == static_cast<CreatureLib::Library::Gender>(-1)) {
        gender = species->GetRandomGender(rand);
    }
    const Library::Item* heldItem = nullptr;
    if (!this->_heldItem.empty()) {
        if (!_library->GetItemLibrary()->TryGetItem(this->_heldItem, heldItem)) {
            throw CreatureException("Unknown Item: " + this->_heldItem);
        }
    }
    auto experience = _library->GetGrowthRateLibrary()->CalculateExperience(species->GetGrowthRate(), _level);

    auto attacks = std::vector<CreatureLib::Battling::LearnedAttack*>(_attacks.size());
    for (size_t i = 0; i < attacks.size(); i++) {
        auto kv = _attacks[i];
        attacks[i] = new LearnedMove(std::get<0>(kv), std::get<1>(kv));
    }
    auto ivs = CreatureLib::Core::StatisticSet(_ivHp, _ivAttack, _ivDefense, _ivSpAtt, _ivSpDef, _ivSpeed);
    auto evs = CreatureLib::Core::StatisticSet(_evHp, _evAttack, _evDefense, _evSpAtt, _evSpDef, _evSpeed);

    if (_nature == 255) {
        _nature = _library->GetNatureLibrary()->GetRandomNature(rand);
    }

    auto shiny = false;
    if (_shininessSet) {
        shiny = _isShiny;
    } else {
        shiny = rand.Get(_library->GetSettings()->GetShinyRate()) == 0;
    }

    auto pkmn = new Pokemon(_library, species, forme, _level, experience, identifier, gender, shiny, heldItem,
                            _nickname, ability, attacks, ivs, evs, _nature);
    pkmn->Initialize();
    return pkmn;
}
PkmnLib::Battling::CreatePokemon* PkmnLib::Battling::CreatePokemon::WithNature(const std::string& nature) {
    _nature = _library->GetNatureLibrary()->GetNatureIdByName(nature);
    return this;
}
PkmnLib::Battling::CreatePokemon* PkmnLib::Battling::CreatePokemon::WithIndividualValues(uint8_t hp, uint8_t att,
                                                                                         uint8_t def, uint8_t spAtt,
                                                                                         uint8_t spDef, uint8_t speed) {
    _ivHp = hp;
    _ivAttack = att;
    _ivDefense = def;
    _ivSpAtt = spAtt;
    _ivSpDef = spDef;
    _ivSpeed = speed;
    return this;
}
PkmnLib::Battling::CreatePokemon* PkmnLib::Battling::CreatePokemon::WithEffortValues(uint8_t hp, uint8_t att,
                                                                                     uint8_t def, uint8_t spAtt,
                                                                                     uint8_t spDef, uint8_t speed) {
    _evHp = hp;
    _evAttack = att;
    _evDefense = def;
    _evSpAtt = spAtt;
    _evSpDef = spDef;
    _evSpeed = speed;
    return this;
}
PkmnLib::Battling::CreatePokemon* PkmnLib::Battling::CreatePokemon::WithForme(const std::string& forme) {
    _forme = forme;
    return this;
}
PkmnLib::Battling::CreatePokemon* PkmnLib::Battling::CreatePokemon::WithGender(CreatureLib::Library::Gender gender) {
    _gender = gender;
    return this;
}
PkmnLib::Battling::CreatePokemon* PkmnLib::Battling::CreatePokemon::IsShiny(bool value) {
    _shininessSet = true;
    _isShiny = value;
    return this;
}
PkmnLib::Battling::CreatePokemon* PkmnLib::Battling::CreatePokemon::WithHeldItem(const std::string& item) {
    _heldItem = item;
    return this;
}
PkmnLib::Battling::CreatePokemon*
PkmnLib::Battling::CreatePokemon::LearnMove(const std::string& moveName, CreatureLib::Battling::AttackLearnMethod method) {
    const PkmnLib::Library::MoveData* move;
    if (!_library->GetMoveLibrary()->TryGetMove(moveName, move)){
        throw CreatureException("Invalid Move given: " + moveName);
    }
    if (_attacks.size() >= _library->GetSettings()->GetMaximalMoves()){
        throw CreatureException("This pokemon already has the maximal allowed moves.");
    }
    _attacks.emplace_back(move, method);
    return this;
}