/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include "BattlePetMgr.h"
#include "DB2Stores.h"
#include "Containers.h"
#include "Creature.h"
#include "DatabaseEnv.h"
#include "GameTables.h"
#include "GameTime.h"
#include "Item.h"
#include "Log.h"
#include "ObjectAccessor.h"
#include "ObjectMgr.h"
#include "Player.h"
#include "RealmList.h"
#include "Util.h"
#include "World.h"
#include "WorldSession.h"

namespace BattlePets
{
namespace
{
std::unordered_map<uint16 /*BreedID*/, std::unordered_map<BattlePetState /*state*/, int32 /*value*/, std::hash<std::underlying_type<BattlePetState>::type> >> _battlePetBreedStates;
std::unordered_map<uint32 /*SpeciesID*/, std::unordered_map<BattlePetState /*state*/, int32 /*value*/, std::hash<std::underlying_type<BattlePetState>::type> >> _battlePetSpeciesStates;
std::unordered_map<uint32 /*CreatureID*/, BattlePetSpeciesEntry const*> _battlePetSpeciesByCreature;
std::unordered_map<uint32 /*SpellID*/, BattlePetSpeciesEntry const*> _battlePetSpeciesBySpell;
std::unordered_map<uint32 /*SpeciesID*/, std::unordered_set<uint8 /*breed*/>> _availableBreedsPerSpecies;
std::unordered_map<uint32 /*SpeciesID*/, uint8 /*quality*/> _defaultQualityPerSpecies;
}

void BattlePet::CalculateStats()
{
    float health = 0.0f;
    float power = 0.0f;
    float speed = 0.0f;

    // get base breed stats
    auto breedState = _battlePetBreedStates.find(PacketInfo.Breed);
    if (breedState == _battlePetBreedStates.end()) // non existing breed id
        return;

    health = breedState->second[STATE_STAT_STAMINA];
    power = breedState->second[STATE_STAT_POWER];
    speed = breedState->second[STATE_STAT_SPEED];

    // modify stats depending on species - not all pets have this
    auto speciesState = _battlePetSpeciesStates.find(PacketInfo.Species);
    if (speciesState != _battlePetSpeciesStates.end())
    {
        health += speciesState->second[STATE_STAT_STAMINA];
        power += speciesState->second[STATE_STAT_POWER];
        speed += speciesState->second[STATE_STAT_SPEED];
    }

    // modify stats by quality
    for (BattlePetBreedQualityEntry const* battlePetBreedQuality : sBattlePetBreedQualityStore)
    {
        if (battlePetBreedQuality->QualityEnum == PacketInfo.Quality)
        {
            health *= battlePetBreedQuality->StateMultiplier;
            power *= battlePetBreedQuality->StateMultiplier;
            speed *= battlePetBreedQuality->StateMultiplier;
            break;
        }
        // TOOD: add check if pet has existing quality
    }

    // scale stats depending on level
    health *= PacketInfo.Level;
    power *= PacketInfo.Level;
    speed *= PacketInfo.Level;

    // set stats
    // round, ceil or floor? verify this
    PacketInfo.MaxHealth = uint32((round(health / 20) + 100));
    PacketInfo.Power = uint32(round(power / 100));
    PacketInfo.Speed = uint32(round(speed / 100));
}

void BattlePetMgr::Initialize()
{
    if (QueryResult result = LoginDatabase.Query("SELECT MAX(guid) FROM battle_pets"))
        sObjectMgr->GetGenerator<HighGuid::BattlePet>().Set((*result)[0].GetUInt64() + 1);

    for (BattlePetSpeciesEntry const* battlePetSpecies : sBattlePetSpeciesStore)
        if (uint32 creatureId = battlePetSpecies->CreatureID)
            _battlePetSpeciesByCreature[creatureId] = battlePetSpecies;

    for (BattlePetBreedStateEntry const* battlePetBreedState : sBattlePetBreedStateStore)
        _battlePetBreedStates[battlePetBreedState->BattlePetBreedID][BattlePetState(battlePetBreedState->BattlePetStateID)] = battlePetBreedState->Value;

    for (BattlePetSpeciesStateEntry const* battlePetSpeciesState : sBattlePetSpeciesStateStore)
        _battlePetSpeciesStates[battlePetSpeciesState->BattlePetSpeciesID][BattlePetState(battlePetSpeciesState->BattlePetStateID)] = battlePetSpeciesState->Value;

    LoadAvailablePetBreeds();
    LoadDefaultPetQualities();
}

void BattlePetMgr::LoadAvailablePetBreeds()
{
    QueryResult result = WorldDatabase.Query("SELECT speciesId, breedId FROM battle_pet_breeds");
    if (!result)
    {
        TC_LOG_INFO("server.loading", ">> Loaded 0 battle pet breeds. DB table `battle_pet_breeds` is empty.");
        return;
    }

    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
        uint32 speciesId = fields[0].GetUInt32();
        uint16 breedId = fields[1].GetUInt16();

        if (!sBattlePetSpeciesStore.LookupEntry(speciesId))
        {
            TC_LOG_ERROR("sql.sql", "Non-existing BattlePetSpecies.db2 entry {} was referenced in `battle_pet_breeds` by row ({}, {}).", speciesId, speciesId, breedId);
            continue;
        }

        // TODO: verify breed id (3 - 12 (male) or 3 - 22 (male and female)) if needed

        _availableBreedsPerSpecies[speciesId].insert(breedId);
        ++count;
    } while (result->NextRow());

    TC_LOG_INFO("server.loading", ">> Loaded {} battle pet breeds.", count);
}

void BattlePetMgr::LoadDefaultPetQualities()
{
    QueryResult result = WorldDatabase.Query("SELECT speciesId, quality FROM battle_pet_quality");
    if (!result)
    {
        TC_LOG_INFO("server.loading", ">> Loaded 0 battle pet qualities. DB table `battle_pet_quality` is empty.");
        return;
    }

    do
    {
        Field* fields = result->Fetch();
        uint32 speciesId = fields[0].GetUInt32();
        uint8 quality = fields[1].GetUInt8();

        BattlePetSpeciesEntry const* battlePetSpecies = sBattlePetSpeciesStore.LookupEntry(speciesId);
        if (!battlePetSpecies)
        {
            TC_LOG_ERROR("sql.sql", "Non-existing BattlePetSpecies.db2 entry {} was referenced in `battle_pet_quality` by row ({}, {}).", speciesId, speciesId, quality);
            continue;
        }

        if (quality >= AsUnderlyingType(BattlePetBreedQuality::Count))
        {
            TC_LOG_ERROR("sql.sql", "BattlePetSpecies.db2 entry {} was referenced in `battle_pet_quality` with non-existing quality {}).", speciesId, quality);
            continue;
        }

        if (battlePetSpecies->GetFlags().HasFlag(BattlePetSpeciesFlags::WellKnown) && quality > AsUnderlyingType(BattlePetBreedQuality::Rare))
        {
            TC_LOG_ERROR("sql.sql", "Learnable BattlePetSpecies.db2 entry {} was referenced in `battle_pet_quality` with invalid quality {}. Maximum allowed quality is BattlePetBreedQuality::Rare.", speciesId, quality);
            continue;
        }

        _defaultQualityPerSpecies[speciesId] = quality;
    } while (result->NextRow());

    TC_LOG_INFO("server.loading", ">> Loaded {} battle pet qualities.", uint32(_defaultQualityPerSpecies.size()));
}

void BattlePetMgr::AddBattlePetSpeciesBySpell(uint32 spellId, BattlePetSpeciesEntry const* speciesEntry)
{
    _battlePetSpeciesBySpell[spellId] = speciesEntry;
}

BattlePetSpeciesEntry const* BattlePetMgr::GetBattlePetSpeciesByCreature(uint32 creatureId)
{
    return Trinity::Containers::MapGetValuePtr(_battlePetSpeciesByCreature, creatureId);
}

BattlePetSpeciesEntry const* BattlePetMgr::GetBattlePetSpeciesBySpell(uint32 spellId)
{
    return Trinity::Containers::MapGetValuePtr(_battlePetSpeciesBySpell, spellId);
}

uint16 BattlePetMgr::RollPetBreed(uint32 species)
{
    auto itr = _availableBreedsPerSpecies.find(species);
    if (itr == _availableBreedsPerSpecies.end())
        return 3; // default B/B

    return Trinity::Containers::SelectRandomContainerElement(itr->second);
}

BattlePetBreedQuality BattlePetMgr::GetDefaultPetQuality(uint32 species)
{
    auto itr = _defaultQualityPerSpecies.find(species);
    if (itr == _defaultQualityPerSpecies.end())
        return BattlePetBreedQuality::Poor; // Default

    return BattlePetBreedQuality(itr->second);
}

uint32 BattlePetMgr::SelectPetDisplay(BattlePetSpeciesEntry const* speciesEntry)
{
    if (CreatureTemplate const* creatureTemplate = sObjectMgr->GetCreatureTemplate(speciesEntry->CreatureID))
        if (!speciesEntry->GetFlags().HasFlag(BattlePetSpeciesFlags::RandomDisplay))
            if (CreatureModel const* creatureModel = creatureTemplate->GetRandomValidModel())
                return creatureModel->CreatureDisplayID;

    return 0;
}

BattlePetMgr::BattlePetMgr(WorldSession* owner)
{
    _owner = owner;
    for (uint8 i = 0; i < AsUnderlyingType(BattlePetSlot::Count); ++i)
    {
        WorldPackets::BattlePet::BattlePetSlot slot;
        slot.Index = i;
        _slots.push_back(slot);
    }
}

void BattlePetMgr::LoadFromDB(PreparedQueryResult pets, PreparedQueryResult slots)
{
    if (pets)
    {
        do
        {
            Field* fields = pets->Fetch();
            uint32 species = fields[1].GetUInt32();
            ObjectGuid ownerGuid = !fields[11].IsNull() ? ObjectGuid::Create<HighGuid::Player>(fields[11].GetInt64()) : ObjectGuid::Empty;

            if (BattlePetSpeciesEntry const* speciesEntry = sBattlePetSpeciesStore.LookupEntry(species))
            {
                if (speciesEntry->GetFlags().HasFlag(BattlePetSpeciesFlags::NotAccountWide))
                {
                    if (ownerGuid.IsEmpty())
                    {
                        TC_LOG_ERROR("misc", "Battlenet account with id {} has battle pet of species {} with BattlePetSpeciesFlags::NotAccountWide but no owner", _owner->GetBattlenetAccountId(), species);
                        continue;
                    }
                }
                else
                {
                    if (!ownerGuid.IsEmpty())
                    {
                        TC_LOG_ERROR("misc", "Battlenet account with id {} has battle pet of species {} without BattlePetSpeciesFlags::NotAccountWide but with owner", _owner->GetBattlenetAccountId(), species);
                        continue;
                    }
                }

                if (HasMaxPetCount(speciesEntry, ownerGuid))
                {
                    if (ownerGuid.IsEmpty())
                        TC_LOG_ERROR("misc", "Battlenet account with id {} has more than maximum battle pets of species {}", _owner->GetBattlenetAccountId(), species);
                    else
                        TC_LOG_ERROR("misc", "Battlenet account with id {} has more than maximum battle pets of species {} for player {}", _owner->GetBattlenetAccountId(), species, ownerGuid.ToString());

                    continue;
                }

                BattlePet pet;
                pet.PacketInfo.Guid = ObjectGuid::Create<HighGuid::BattlePet>(fields[0].GetUInt64());
                pet.PacketInfo.Species = species;
                pet.PacketInfo.Breed = fields[2].GetUInt16();
                pet.PacketInfo.DisplayID = fields[3].GetUInt32();
                pet.PacketInfo.Level = fields[4].GetUInt16();
                pet.PacketInfo.Exp = fields[5].GetUInt16();
                pet.PacketInfo.Health = fields[6].GetUInt32();
                pet.PacketInfo.Quality = fields[7].GetUInt8();
                pet.PacketInfo.Flags = fields[8].GetUInt16();
                pet.PacketInfo.Name = fields[9].GetString();
                pet.NameTimestamp = fields[10].GetInt64();
                pet.PacketInfo.CreatureID = speciesEntry->CreatureID;

                if (!fields[13].IsNull())
                {
                    pet.DeclinedName = std::make_unique<DeclinedName>();
                    for (uint8 i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
                        pet.DeclinedName->name[i] = fields[13 + i].GetString();
                }

                if (!ownerGuid.IsEmpty())
                {
                    pet.PacketInfo.OwnerInfo.emplace();
                    pet.PacketInfo.OwnerInfo->Guid = ownerGuid;
                    if (std::shared_ptr<Realm const> ownerRealm = sRealmList->GetRealm(fields[12].GetInt32()))
                        pet.PacketInfo.OwnerInfo->PlayerVirtualRealm = pet.PacketInfo.OwnerInfo->PlayerNativeRealm = ownerRealm->Id.GetAddress();
                }

                pet.SaveInfo = BATTLE_PET_UNCHANGED;
                pet.CalculateStats();
                _pets[pet.PacketInfo.Guid.GetCounter()] = std::move(pet);
            }
        } while (pets->NextRow());
    }

    if (slots)
    {
        uint8 i = 0; // slots->GetRowCount() should equal MAX_BATTLE_PET_SLOTS

        do
        {
            Field* fields = slots->Fetch();
            _slots[i].Index = fields[0].GetUInt8();
            auto itr = _pets.find(fields[1].GetUInt64());
            if (itr != _pets.end())
                _slots[i].Pet = itr->second.PacketInfo;
            _slots[i].Locked = fields[2].GetBool();
            i++;
        } while (slots->NextRow());
    }
}

void BattlePetMgr::SaveToDB(LoginDatabaseTransaction trans)
{
    LoginDatabasePreparedStatement* stmt = nullptr;

    for (auto itr = _pets.begin(); itr != _pets.end();)
    {
        switch (itr->second.SaveInfo)
        {
            case BATTLE_PET_NEW:
                stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_BATTLE_PETS);
                stmt->setUInt64(0, itr->first);
                stmt->setUInt32(1, _owner->GetBattlenetAccountId());
                stmt->setUInt32(2, itr->second.PacketInfo.Species);
                stmt->setUInt16(3, itr->second.PacketInfo.Breed);
                stmt->setUInt32(4, itr->second.PacketInfo.DisplayID);
                stmt->setUInt16(5, itr->second.PacketInfo.Level);
                stmt->setUInt16(6, itr->second.PacketInfo.Exp);
                stmt->setUInt32(7, itr->second.PacketInfo.Health);
                stmt->setUInt8(8, itr->second.PacketInfo.Quality);
                stmt->setUInt16(9, itr->second.PacketInfo.Flags);
                stmt->setString(10, itr->second.PacketInfo.Name);
                stmt->setInt64(11, itr->second.NameTimestamp);
                if (itr->second.PacketInfo.OwnerInfo)
                {
                    stmt->setInt64(12, itr->second.PacketInfo.OwnerInfo->Guid.GetCounter());
                    stmt->setInt32(13, sRealmList->GetCurrentRealmId().Realm);
                }
                else
                {
                    stmt->setNull(12);
                    stmt->setNull(13);
                }

                trans->Append(stmt);

                if (itr->second.DeclinedName)
                {
                    stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_BATTLE_PET_DECLINED_NAME);
                    stmt->setUInt64(0, itr->first);

                    for (uint8 i = 0; i < MAX_DECLINED_NAME_CASES; i++)
                        stmt->setString(i + 1, itr->second.DeclinedName->name[i]);

                    trans->Append(stmt);
                }

                itr->second.SaveInfo = BATTLE_PET_UNCHANGED;
                ++itr;
                break;
            case BATTLE_PET_CHANGED:
                stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BATTLE_PETS);
                stmt->setUInt16(0, itr->second.PacketInfo.Level);
                stmt->setUInt16(1, itr->second.PacketInfo.Exp);
                stmt->setUInt32(2, itr->second.PacketInfo.Health);
                stmt->setUInt8(3, itr->second.PacketInfo.Quality);
                stmt->setUInt16(4, itr->second.PacketInfo.Flags);
                stmt->setString(5, itr->second.PacketInfo.Name);
                stmt->setInt64(6, itr->second.NameTimestamp);
                stmt->setUInt32(7, _owner->GetBattlenetAccountId());
                stmt->setUInt64(8, itr->first);
                trans->Append(stmt);

                stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_BATTLE_PET_DECLINED_NAME);
                stmt->setUInt64(0, itr->first);
                trans->Append(stmt);

                if (itr->second.DeclinedName)
                {
                    stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_BATTLE_PET_DECLINED_NAME);
                    stmt->setUInt64(0, itr->first);

                    for (uint8 i = 0; i < MAX_DECLINED_NAME_CASES; i++)
                        stmt->setString(i + 1, itr->second.DeclinedName->name[i]);

                    trans->Append(stmt);
                }

                itr->second.SaveInfo = BATTLE_PET_UNCHANGED;
                ++itr;
                break;
            case BATTLE_PET_REMOVED:
                stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_BATTLE_PET_DECLINED_NAME);
                stmt->setUInt64(0, itr->first);
                trans->Append(stmt);

                stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_BATTLE_PETS);
                stmt->setUInt32(0, _owner->GetBattlenetAccountId());
                stmt->setUInt64(1, itr->first);
                trans->Append(stmt);

                itr = _pets.erase(itr);
                break;
            default:
                ++itr;
                break;
        }
    }

    stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_BATTLE_PET_SLOTS);
    stmt->setUInt32(0, _owner->GetBattlenetAccountId());
    trans->Append(stmt);

    for (WorldPackets::BattlePet::BattlePetSlot const& slot : _slots)
    {
        stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_BATTLE_PET_SLOTS);
        stmt->setUInt8(0, slot.Index);
        stmt->setUInt32(1, _owner->GetBattlenetAccountId());
        stmt->setUInt64(2, slot.Pet.Guid.GetCounter());
        stmt->setBool(3, slot.Locked);
        trans->Append(stmt);
    }
}

BattlePet* BattlePetMgr::GetPet(ObjectGuid guid)
{
    return Trinity::Containers::MapGetValuePtr(_pets, guid.GetCounter());
}

void BattlePetMgr::AddPet(uint32 species, uint32 display, uint16 breed, BattlePetBreedQuality quality, uint16 level /*= 1*/)
{
    BattlePetSpeciesEntry const* battlePetSpecies = sBattlePetSpeciesStore.LookupEntry(species);
    if (!battlePetSpecies) // should never happen
        return;

    if (!battlePetSpecies->GetFlags().HasFlag(BattlePetSpeciesFlags::WellKnown)) // Not learnable
        return;

    BattlePet pet;
    pet.PacketInfo.Guid = ObjectGuid::Create<HighGuid::BattlePet>(sObjectMgr->GetGenerator<HighGuid::BattlePet>().Generate());
    pet.PacketInfo.Species = species;
    pet.PacketInfo.CreatureID = battlePetSpecies->CreatureID;
    pet.PacketInfo.DisplayID = display;
    pet.PacketInfo.Level = level;
    pet.PacketInfo.Exp = 0;
    pet.PacketInfo.Flags = 0;
    pet.PacketInfo.Breed = breed;
    pet.PacketInfo.Quality = AsUnderlyingType(quality);
    pet.PacketInfo.Name = "";
    pet.CalculateStats();
    pet.PacketInfo.Health = pet.PacketInfo.MaxHealth;

    Player* player = _owner->GetPlayer();
    if (battlePetSpecies->GetFlags().HasFlag(BattlePetSpeciesFlags::NotAccountWide))
    {
        pet.PacketInfo.OwnerInfo.emplace();
        pet.PacketInfo.OwnerInfo->Guid = player->GetGUID();
        pet.PacketInfo.OwnerInfo->PlayerVirtualRealm = pet.PacketInfo.OwnerInfo->PlayerNativeRealm = player->m_playerData->VirtualPlayerRealm;
    }

    pet.SaveInfo = BATTLE_PET_NEW;

    _pets[pet.PacketInfo.Guid.GetCounter()] = std::move(pet);

    std::vector<std::reference_wrapper<BattlePet>> updates;
    updates.push_back(std::ref(pet));
    SendUpdates(std::move(updates), true);

    player->UpdateCriteria(CriteriaType::UniquePetsOwned);
    player->UpdateCriteria(CriteriaType::LearnedNewPet, species);
}

void BattlePetMgr::RemovePet(ObjectGuid guid)
{
    if (!HasJournalLock())
        return;

    BattlePet* pet = GetPet(guid);
    if (!pet)
        return;

    pet->SaveInfo = BATTLE_PET_REMOVED;
}

void BattlePetMgr::ClearFanfare(ObjectGuid guid)
{
    BattlePet* pet = GetPet(guid);
    if (!pet)
        return;

    pet->PacketInfo.Flags &= ~AsUnderlyingType(BattlePetDbFlags::FanfareNeeded);

    if (pet->SaveInfo != BATTLE_PET_NEW)
        pet->SaveInfo = BATTLE_PET_CHANGED;
}

void BattlePetMgr::ModifyName(ObjectGuid guid, std::string const& name, std::unique_ptr<DeclinedName> declinedName)
{
    if (!HasJournalLock())
        return;

    BattlePet* pet = GetPet(guid);
    if (!pet)
        return;

    pet->PacketInfo.Name = name;
    pet->NameTimestamp = GameTime::GetGameTime();

    pet->DeclinedName = std::move(declinedName);

    if (pet->SaveInfo != BATTLE_PET_NEW)
        pet->SaveInfo = BATTLE_PET_CHANGED;

    // Update the timestamp if the battle pet is summoned
    if (Creature* summonedBattlePet = _owner->GetPlayer()->GetSummonedBattlePet())
        if (summonedBattlePet->GetBattlePetCompanionGUID() == guid)
            summonedBattlePet->SetBattlePetCompanionNameTimestamp(pet->NameTimestamp);
}

bool BattlePetMgr::IsPetInSlot(ObjectGuid guid)
{
    for (WorldPackets::BattlePet::BattlePetSlot const& slot : _slots)
        if (slot.Pet.Guid == guid)
            return true;

    return false;
}

uint8 BattlePetMgr::GetPetCount(BattlePetSpeciesEntry const* battlePetSpecies, ObjectGuid ownerGuid) const
{
    return uint8(std::count_if(_pets.begin(), _pets.end(), [battlePetSpecies, ownerGuid](std::pair<uint64 const, BattlePet> const& pet)
    {
        if (pet.second.PacketInfo.Species != battlePetSpecies->ID)
            return false;

        if (pet.second.SaveInfo == BATTLE_PET_REMOVED)
            return false;

        if (battlePetSpecies->GetFlags().HasFlag(BattlePetSpeciesFlags::NotAccountWide))
            if (!ownerGuid.IsEmpty() && pet.second.PacketInfo.OwnerInfo)
                if (pet.second.PacketInfo.OwnerInfo->Guid != ownerGuid)
                    return false;

        return true;
    }));
}

bool BattlePetMgr::HasMaxPetCount(BattlePetSpeciesEntry const* battlePetSpecies, ObjectGuid ownerGuid) const
{
    uint8 maxPetsPerSpecies = battlePetSpecies->GetFlags().HasFlag(BattlePetSpeciesFlags::LegacyAccountUnique) ? 1 : DEFAULT_MAX_BATTLE_PETS_PER_SPECIES;

    return GetPetCount(battlePetSpecies, ownerGuid) >= maxPetsPerSpecies;
}

uint32 BattlePetMgr::GetPetUniqueSpeciesCount() const
{
    std::set<uint32> speciesIds;
    std::transform(_pets.begin(), _pets.end(), std::inserter(speciesIds, speciesIds.end()), [](std::pair<uint64 const, BattlePet> const& pet)
    {
        return pet.second.PacketInfo.Species;
    });
    return speciesIds.size();
}

void BattlePetMgr::UnlockSlot(BattlePetSlot slot)
{
    if (slot >= BattlePetSlot::Count)
        return;

    uint8 slotIndex = AsUnderlyingType(slot);
    if (!_slots[slotIndex].Locked)
        return;

    _slots[slotIndex].Locked = false;

    WorldPackets::BattlePet::PetBattleSlotUpdates updates;
    updates.Slots.push_back(_slots[slotIndex]);
    updates.AutoSlotted = false; // what's this?
    updates.NewSlot = true; // causes the "new slot unlocked" bubble to appear
    _owner->SendPacket(updates.Write());
}

uint16 BattlePetMgr::GetMaxPetLevel() const
{
    uint16 level = 0;
    for (auto& pet : _pets)
        if (pet.second.SaveInfo != BATTLE_PET_REMOVED)
            level = std::max(level, pet.second.PacketInfo.Level);

    return level;
}

void BattlePetMgr::CageBattlePet(ObjectGuid guid)
{
    if (!HasJournalLock())
        return;

    BattlePet* pet = GetPet(guid);
    if (!pet)
        return;

    if (BattlePetSpeciesEntry const* battlePetSpecies = sBattlePetSpeciesStore.LookupEntry(pet->PacketInfo.Species))
        if (battlePetSpecies->GetFlags().HasFlag(BattlePetSpeciesFlags::NotTradable))
            return;

    if (IsPetInSlot(guid))
        return;

    if (pet->PacketInfo.Health < pet->PacketInfo.MaxHealth)
        return;

    ItemPosCountVec dest;

    if (_owner->GetPlayer()->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, BATTLE_PET_CAGE_ITEM_ID, 1) != EQUIP_ERR_OK)
        return;

    Item* item = _owner->GetPlayer()->StoreNewItem(dest, BATTLE_PET_CAGE_ITEM_ID, true);
    if (!item)
        return;

    item->SetModifier(ITEM_MODIFIER_BATTLE_PET_SPECIES_ID, pet->PacketInfo.Species);
    item->SetModifier(ITEM_MODIFIER_BATTLE_PET_BREED_DATA, pet->PacketInfo.Breed | (pet->PacketInfo.Quality << 24));
    item->SetModifier(ITEM_MODIFIER_BATTLE_PET_LEVEL, pet->PacketInfo.Level);
    item->SetModifier(ITEM_MODIFIER_BATTLE_PET_DISPLAY_ID, pet->PacketInfo.DisplayID);

    _owner->GetPlayer()->SendNewItem(item, 1, true, false);

    RemovePet(guid);

    WorldPackets::BattlePet::BattlePetDeleted deletePet;
    deletePet.PetGuid = guid;
    _owner->SendPacket(deletePet.Write());

    // Battle pet despawns if it's summoned
    Player* player = _owner->GetPlayer();
    if (Creature* summonedBattlePet = player->GetSummonedBattlePet())
    {
        if (summonedBattlePet->GetBattlePetCompanionGUID() == guid)
        {
            summonedBattlePet->DespawnOrUnsummon();
            player->SetBattlePetData(nullptr);
        }
    }
}

void BattlePetMgr::ChangeBattlePetQuality(ObjectGuid guid, BattlePetBreedQuality quality)
{
    if (!HasJournalLock())
        return;

    BattlePet* pet = GetPet(guid);
    if (!pet)
        return;

    if (quality > BattlePetBreedQuality::Rare)
        return;

    if (BattlePetSpeciesEntry const* battlePetSpecies = sBattlePetSpeciesStore.LookupEntry(pet->PacketInfo.Species))
        if (battlePetSpecies->GetFlags().HasFlag(BattlePetSpeciesFlags::CantBattle))
            return;

    uint8 qualityValue = AsUnderlyingType(quality);
    if (pet->PacketInfo.Quality >= qualityValue)
        return;

    pet->PacketInfo.Quality = qualityValue;
    pet->CalculateStats();
    pet->PacketInfo.Health = pet->PacketInfo.MaxHealth;

    if (pet->SaveInfo != BATTLE_PET_NEW)
        pet->SaveInfo = BATTLE_PET_CHANGED;

    std::vector<std::reference_wrapper<BattlePet>> updates;
    updates.push_back(std::ref(*pet));
    SendUpdates(std::move(updates), false);

    // UF::PlayerData::CurrentBattlePetBreedQuality isn't updated (Intended)
    // _owner->GetPlayer()->SetCurrentBattlePetBreedQuality(qualityValue);
}

void BattlePetMgr::GrantBattlePetExperience(ObjectGuid /*guid*/, uint16 /*xp*/, BattlePetXpSource /*xpSource*/)
{
    return;

    /*
    if (!HasJournalLock())
        return;

    BattlePet* pet = GetPet(guid);
    if (!pet)
        return;

    if (xp <= 0 || xpSource >= BattlePetXpSource::Count)
        return;

    if (BattlePetSpeciesEntry const* battlePetSpecies = sBattlePetSpeciesStore.LookupEntry(pet->PacketInfo.Species))
        if (battlePetSpecies->GetFlags().HasFlag(BattlePetSpeciesFlags::CantBattle))
            return;

    uint16 level = pet->PacketInfo.Level;
    if (level >= MAX_BATTLE_PET_LEVEL)
        return;

    GtBattlePetXPEntry const* xpEntry = sBattlePetXPGameTable.GetRow(level);
    if (!xpEntry)
        return;

    Player* player = _owner->GetPlayer();
    uint16 nextLevelXp = uint16(GetBattlePetXPPerLevel(xpEntry));

    if (xpSource == BattlePetXpSource::PetBattle)
        xp *= player->GetTotalAuraMultiplier(SPELL_AURA_MOD_BATTLE_PET_XP_PCT);

    xp += pet->PacketInfo.Exp;

    while (xp >= nextLevelXp && level < MAX_BATTLE_PET_LEVEL)
    {
        xp -= nextLevelXp;

        xpEntry = sBattlePetXPGameTable.GetRow(++level);
        if (!xpEntry)
            return;

        nextLevelXp = uint16(GetBattlePetXPPerLevel(xpEntry));

        player->UpdateCriteria(CriteriaType::BattlePetReachLevel, pet->PacketInfo.Species, level);
        if (xpSource == BattlePetXpSource::PetBattle)
            player->UpdateCriteria(CriteriaType::ActivelyEarnPetLevel, pet->PacketInfo.Species, level);
    }

    pet->PacketInfo.Level = level;
    pet->PacketInfo.Exp = level < MAX_BATTLE_PET_LEVEL ? xp : 0;
    pet->CalculateStats();
    pet->PacketInfo.Health = pet->PacketInfo.MaxHealth;

    if (pet->SaveInfo != BATTLE_PET_NEW)
        pet->SaveInfo = BATTLE_PET_CHANGED;

    std::vector<std::reference_wrapper<BattlePet>> updates;
    updates.push_back(std::ref(*pet));
    SendUpdates(std::move(updates), false);
    */
}

void BattlePetMgr::GrantBattlePetLevel(ObjectGuid guid, uint16 grantedLevels)
{
    if (!HasJournalLock())
        return;

    BattlePet* pet = GetPet(guid);
    if (!pet)
        return;

    if (BattlePetSpeciesEntry const* battlePetSpecies = sBattlePetSpeciesStore.LookupEntry(pet->PacketInfo.Species))
        if (battlePetSpecies->GetFlags().HasFlag(BattlePetSpeciesFlags::CantBattle))
            return;

    uint16 level = pet->PacketInfo.Level;
    if (level >= MAX_BATTLE_PET_LEVEL)
        return;

    while (grantedLevels > 0 && level < MAX_BATTLE_PET_LEVEL)
    {
        ++level;
        --grantedLevels;

        _owner->GetPlayer()->UpdateCriteria(CriteriaType::BattlePetReachLevel, pet->PacketInfo.Species, level);
    }

    pet->PacketInfo.Level = level;
    if (level >= MAX_BATTLE_PET_LEVEL)
        pet->PacketInfo.Exp = 0;
    pet->CalculateStats();
    pet->PacketInfo.Health = pet->PacketInfo.MaxHealth;

    if (pet->SaveInfo != BATTLE_PET_NEW)
        pet->SaveInfo = BATTLE_PET_CHANGED;

    std::vector<std::reference_wrapper<BattlePet>> updates;
    updates.push_back(std::ref(*pet));
    SendUpdates(std::move(updates), false);
}

void BattlePetMgr::HealBattlePetsPct(uint8 pct)
{
    // TODO: After each Pet Battle, any injured companion will automatically
    // regain 50 % of the damage that was taken during combat
    std::vector<std::reference_wrapper<BattlePet>> updates;

    for (auto& pet : _pets)
        if (pet.second.PacketInfo.Health != pet.second.PacketInfo.MaxHealth)
        {
            pet.second.PacketInfo.Health += CalculatePct(pet.second.PacketInfo.MaxHealth, pct);
            // don't allow Health to be greater than MaxHealth
            pet.second.PacketInfo.Health = std::min(pet.second.PacketInfo.Health, pet.second.PacketInfo.MaxHealth);
            if (pet.second.SaveInfo != BATTLE_PET_NEW)
                pet.second.SaveInfo = BATTLE_PET_CHANGED;
            updates.push_back(std::ref(pet.second));
        }

    SendUpdates(std::move(updates), false);
}

void BattlePetMgr::UpdateBattlePetData(ObjectGuid guid)
{
    BattlePet* pet = GetPet(guid);
    if (!pet)
        return;

    Player* player = _owner->GetPlayer();

    // Update battle pet related update fields
    if (Creature* summonedBattlePet = player->GetSummonedBattlePet())
    {
        if (summonedBattlePet->GetBattlePetCompanionGUID() == guid)
        {
            summonedBattlePet->SetWildBattlePetLevel(pet->PacketInfo.Level);
            player->SetBattlePetData(pet);
        }
    }
}

void BattlePetMgr::SummonPet(ObjectGuid guid)
{
    BattlePet* pet = GetPet(guid);
    if (!pet)
        return;

    BattlePetSpeciesEntry const* speciesEntry = sBattlePetSpeciesStore.LookupEntry(pet->PacketInfo.Species);
    if (!speciesEntry)
        return;

    Player* player = _owner->GetPlayer();
    player->SetBattlePetData(pet);

    CastSpellExtraArgs args;
    uint32 summonSpellId = speciesEntry->SummonSpellID;
    if (!summonSpellId)
    {
        summonSpellId = uint32(SPELL_SUMMON_BATTLE_PET);
        args.AddSpellBP0(speciesEntry->CreatureID);
    }
    player->CastSpell(_owner->GetPlayer(), summonSpellId, args);
}

void BattlePetMgr::DismissPet()
{
    Player* player = _owner->GetPlayer();
    if (Creature* summonedBattlePet = player->GetSummonedBattlePet())
    {
        summonedBattlePet->DespawnOrUnsummon();
        player->SetBattlePetData(nullptr);
    }
}

void BattlePetMgr::SendJournal()
{
    if (!HasJournalLock())
        SendJournalLockStatus();

    WorldPackets::BattlePet::BattlePetJournal battlePetJournal;
    battlePetJournal.Trap = _trapLevel;
    battlePetJournal.HasJournalLock = _hasJournalLock;

    for (auto& pet : _pets)
        if (pet.second.SaveInfo != BATTLE_PET_REMOVED)
            if (!pet.second.PacketInfo.OwnerInfo || pet.second.PacketInfo.OwnerInfo->Guid == _owner->GetPlayer()->GetGUID())
                battlePetJournal.Pets.push_back(std::ref(pet.second.PacketInfo));

    battlePetJournal.Slots.reserve(_slots.size());
    std::transform(_slots.begin(), _slots.end(), std::back_inserter(battlePetJournal.Slots), [](WorldPackets::BattlePet::BattlePetSlot& slot) { return std::ref(slot); });
    _owner->SendPacket(battlePetJournal.Write());
}

void BattlePetMgr::SendUpdates(std::vector<std::reference_wrapper<BattlePet>> pets, bool petAdded)
{
    WorldPackets::BattlePet::BattlePetUpdates updates;
    for (BattlePet& pet : pets)
        updates.Pets.push_back(std::ref(pet.PacketInfo));

    updates.PetAdded = petAdded;
    _owner->SendPacket(updates.Write());
}

void BattlePetMgr::SendError(BattlePetError error, uint32 creatureId)
{
    WorldPackets::BattlePet::BattlePetError battlePetError;
    battlePetError.Result = AsUnderlyingType(error);
    battlePetError.CreatureID = creatureId;
    _owner->SendPacket(battlePetError.Write());
}

void BattlePetMgr::SendJournalLockStatus()
{
    if (!IsJournalLockAcquired())
        ToggleJournalLock(true);

    if (HasJournalLock())
    {
        WorldPackets::BattlePet::BattlePetJournalLockAcquired battlePetJournalLockAcquired;
        _owner->SendPacket(battlePetJournalLockAcquired.Write());
    }
    else
    {
        WorldPackets::BattlePet::BattlePetJournalLockDenied BattlePetJournalLockDenied;
        _owner->SendPacket(BattlePetJournalLockDenied.Write());
    }
}

bool BattlePetMgr::IsJournalLockAcquired() const
{
    return sWorld->IsBattlePetJournalLockAcquired(_owner->GetBattlenetAccountGUID());
}
}