/*
 * 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 "ConversationDataStore.h"
#include "DB2Stores.h"
#include "DatabaseEnv.h"
#include "Log.h"
#include "MapUtils.h"
#include "ObjectMgr.h"
#include "Timer.h"

namespace
{
    std::unordered_map<uint32, ConversationTemplate>       _conversationTemplateStore;
    std::unordered_map<uint32, ConversationLineTemplate>   _conversationLineTemplateStore;
}

void ConversationDataStore::LoadConversationTemplates()
{
    _conversationLineTemplateStore.clear();
    _conversationTemplateStore.clear();

    std::unordered_map<uint32, std::vector<ConversationActorTemplate>> actorsByConversation;

    if (QueryResult lineTemplates = WorldDatabase.Query("SELECT Id, UiCameraID, ActorIdx, Flags, ChatType FROM conversation_line_template"))
    {
        uint32 oldMSTime = getMSTime();

        do
        {
            Field* fields = lineTemplates->Fetch();

            uint32 id = fields[0].GetUInt32();

            if (!sConversationLineStore.LookupEntry(id))
            {
                TC_LOG_ERROR("sql.sql", "Table `conversation_line_template` has template for non existing ConversationLine (ID: {}), skipped", id);
                continue;
            }

            ConversationLineTemplate& conversationLine = _conversationLineTemplateStore[id];
            conversationLine.Id         = id;
            conversationLine.UiCameraID = fields[1].GetUInt32();
            conversationLine.ActorIdx   = fields[2].GetUInt8();
            conversationLine.Flags      = fields[3].GetUInt8();
            conversationLine.ChatType   = fields[4].GetUInt8();
        }
        while (lineTemplates->NextRow());

        TC_LOG_INFO("server.loading", ">> Loaded {} Conversation line templates in {} ms", _conversationLineTemplateStore.size(), GetMSTimeDiffToNow(oldMSTime));
    }
    else
    {
        TC_LOG_INFO("server.loading", ">> Loaded 0 Conversation line templates. DB table `conversation_line_template` is empty.");
    }

    if (QueryResult actors = WorldDatabase.Query("SELECT ConversationId, ConversationActorId, ConversationActorGuid, Idx, CreatureId, CreatureDisplayInfoId, NoActorObject, ActivePlayerObject FROM conversation_actors"))
    {
        uint32 oldMSTime = getMSTime();
        uint32 count = 0;

        struct ConversationActorDbRow
        {
            uint32 ConversationId = 0;
            uint32 ActorIndex = 0;

            ObjectGuid::LowType SpawnId = 0;
            uint32 CreatureId = 0;
            uint32 CreatureDisplayInfoId = 0;

            bool operator()(ConversationActorWorldObjectTemplate& worldObject) const
            {
                if (!sObjectMgr->GetCreatureData(SpawnId))
                {
                    TC_LOG_ERROR("sql.sql", "Table `conversation_actors` references an invalid creature guid (GUID: {}) for Conversation {} and Idx {}, skipped.", SpawnId, ConversationId, ActorIndex);
                    return false;
                }

                if (CreatureId)
                    TC_LOG_ERROR("sql.sql", "Table `conversation_actors` with ConversationActorGuid cannot have CreatureId ({}). Conversation {} and Idx {}.", CreatureId, ConversationId, ActorIndex);

                if (CreatureDisplayInfoId)
                    TC_LOG_ERROR("sql.sql", "Table `conversation_actors` with ConversationActorGuid cannot have CreatureDisplayInfoId ({}). Conversation {} and Idx {}.", CreatureDisplayInfoId, ConversationId, ActorIndex);

                worldObject.SpawnId = SpawnId;
                return true;
            }

            bool operator()(ConversationActorNoObjectTemplate& noObject) const
            {
                if (!sObjectMgr->GetCreatureTemplate(CreatureId))
                {
                    TC_LOG_ERROR("sql.sql", "Table `conversation_actors` references an invalid creature id ({}) for Conversation {} and Idx {}, skipped.", CreatureId, ConversationId, ActorIndex);
                    return false;
                }

                if (CreatureDisplayInfoId && !sCreatureDisplayInfoStore.LookupEntry(CreatureDisplayInfoId))
                {
                    TC_LOG_ERROR("sql.sql", "Table `conversation_actors` references an invalid creature display id ({}) for Conversation {} and Idx {}, skipped.", CreatureDisplayInfoId, ConversationId, ActorIndex);
                    return false;
                }

                if (SpawnId)
                    TC_LOG_ERROR("sql.sql", "Table `conversation_actors` with NoActorObject cannot have ConversationActorGuid ({}). Conversation {} and Idx {}.", SpawnId, ConversationId, ActorIndex);

                noObject.CreatureId = CreatureId;
                noObject.CreatureDisplayInfoId = CreatureDisplayInfoId;
                return true;
            }

            bool operator()([[maybe_unused]] ConversationActorActivePlayerTemplate& activePlayer) const
            {
                if (SpawnId)
                    TC_LOG_ERROR("sql.sql", "Table `conversation_actors` with ActivePlayerObject cannot have ConversationActorGuid ({}). Conversation {} and Idx {}.", SpawnId, ConversationId, ActorIndex);

                if (CreatureId)
                    TC_LOG_ERROR("sql.sql", "Table `conversation_actors` with ActivePlayerObject cannot have CreatureId ({}). Conversation {} and Idx {}.", CreatureId, ConversationId, ActorIndex);

                if (CreatureDisplayInfoId)
                    TC_LOG_ERROR("sql.sql", "Table `conversation_actors` with ActivePlayerObject cannot have CreatureDisplayInfoId ({}). Conversation {} and Idx {}.", CreatureDisplayInfoId, ConversationId, ActorIndex);

                return true;
            }

            bool operator()(ConversationActorTalkingHeadTemplate& talkingHead) const
            {
                if (!sObjectMgr->GetCreatureTemplate(CreatureId))
                {
                    TC_LOG_ERROR("sql.sql", "Table `conversation_actors` references an invalid creature id ({}) for Conversation {} and Idx {}, skipped.", CreatureId, ConversationId, ActorIndex);
                    return false;
                }

                if (CreatureDisplayInfoId && !sCreatureDisplayInfoStore.LookupEntry(CreatureDisplayInfoId))
                {
                    TC_LOG_ERROR("sql.sql", "Table `conversation_actors` references an invalid creature display id ({}) for Conversation {} and Idx {}, skipped.", CreatureDisplayInfoId, ConversationId, ActorIndex);
                    return false;
                }

                if (SpawnId)
                    TC_LOG_ERROR("sql.sql", "Table `conversation_actors` with TalkingHead cannot have ConversationActorGuid ({}). Conversation {} and Idx {}.", SpawnId, ConversationId, ActorIndex);

                talkingHead.CreatureId = CreatureId;
                talkingHead.CreatureDisplayInfoId = CreatureDisplayInfoId;
                return true;
            }
        };

        do
        {
            Field* fields = actors->Fetch();

            ConversationActorDbRow data;
            ConversationActorTemplate actor;
            data.ConversationId           = fields[0].GetUInt32();
            actor.Id                      = fields[1].GetUInt32();
            data.SpawnId                  = fields[2].GetUInt64();
            data.ActorIndex = actor.Index = fields[3].GetUInt16();
            data.CreatureId               = fields[4].GetUInt32();
            data.CreatureDisplayInfoId    = fields[5].GetUInt32();
            bool noActorObject            = fields[6].GetUInt8() == 1;
            bool activePlayerObject       = fields[7].GetUInt8() == 1;

            if (activePlayerObject)
                actor.Data.emplace<ConversationActorActivePlayerTemplate>();
            else if (noActorObject)
                actor.Data.emplace<ConversationActorNoObjectTemplate>();
            else if (data.SpawnId || !data.CreatureId) // @TODO: remove CreatureId check when actor flags are implemented
                actor.Data.emplace<ConversationActorWorldObjectTemplate>();
            else
                actor.Data.emplace<ConversationActorTalkingHeadTemplate>();

            bool valid = std::visit(data, actor.Data);
            if (!valid)
                continue;

            actorsByConversation[data.ConversationId].push_back(actor);
            ++count;
        } while (actors->NextRow());

        TC_LOG_INFO("server.loading", ">> Loaded {} Conversation actors in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    }
    else
    {
        TC_LOG_INFO("server.loading", ">> Loaded 0 Conversation actors. DB table `conversation_actors` is empty.");
    }

    // TODO: Remove this hack when NextConversationLineID is changed to uint32
    auto getNextConversationLineId = [&](ConversationLineEntry const* conversationLine)
    {
        if (conversationLine && conversationLine->NextConversationLineID)
        {
            static constexpr uint32 FirstLineId = 60000; // Arbitrary id to cover the affected rows

            if (conversationLine->ID > FirstLineId && conversationLine->NextConversationLineID < (sConversationLineStore.GetNumRows() - USHRT_MAX - 1))
                return (uint32)(USHRT_MAX + conversationLine->NextConversationLineID + 1);

            return (uint32)conversationLine->NextConversationLineID;
        }

        return 0u;
    };

    // Validate FirstLineId
    std::unordered_map<uint32, uint32> prevConversationLineIds;
    for (ConversationLineEntry const* conversationLine : sConversationLineStore)
        if (uint32 nextConversationLineId = getNextConversationLineId(conversationLine))
            prevConversationLineIds[nextConversationLineId] = conversationLine->ID;

    auto getFirstLineIdFromAnyLineId = [&](uint32 lineId)
    {
        while (uint32 const* prevLineId = Trinity::Containers::MapGetValuePtr(prevConversationLineIds, lineId))
            lineId = *prevLineId;

        return lineId;
    };

    if (QueryResult templates = WorldDatabase.Query("SELECT Id, FirstLineId, TextureKitId, Flags, ScriptName FROM conversation_template"))
    {
        uint32 oldMSTime = getMSTime();

        do
        {
            Field* fields = templates->Fetch();

            ConversationTemplate conversationTemplate;
            conversationTemplate.Id                 = fields[0].GetUInt32();
            conversationTemplate.FirstLineId        = fields[1].GetUInt32();
            conversationTemplate.TextureKitId       = fields[2].GetUInt32();
            conversationTemplate.Flags              = (ConversationFlags)fields[3].GetUInt8();
            conversationTemplate.ScriptId           = sObjectMgr->GetScriptId(fields[4].GetStringView());

            conversationTemplate.Actors = std::move(actorsByConversation[conversationTemplate.Id]);

            uint32 correctedFirstLineId = getFirstLineIdFromAnyLineId(conversationTemplate.FirstLineId);
            if (conversationTemplate.FirstLineId != correctedFirstLineId)
            {
                TC_LOG_ERROR("sql.sql", "Table `conversation_template` has incorrect FirstLineId {}, it should be {} for Conversation {}, corrected",
                    conversationTemplate.FirstLineId, correctedFirstLineId, conversationTemplate.Id);
                conversationTemplate.FirstLineId = correctedFirstLineId;
            }

            ConversationLineEntry const* currentConversationLine = sConversationLineStore.LookupEntry(conversationTemplate.FirstLineId);
            if (!currentConversationLine)
                TC_LOG_ERROR("sql.sql", "Table `conversation_template` references an invalid line (ID: {}) for Conversation {}, skipped", conversationTemplate.FirstLineId, conversationTemplate.Id);

            while (currentConversationLine != nullptr)
            {
                if (ConversationLineTemplate const* conversationLineTemplate = Trinity::Containers::MapGetValuePtr(_conversationLineTemplateStore, currentConversationLine->ID))
                    conversationTemplate.Lines.push_back(conversationLineTemplate);
                else
                    TC_LOG_ERROR("sql.sql", "Table `conversation_line_template` has missing template for line (ID: {}) in Conversation {}, skipped", currentConversationLine->ID, conversationTemplate.Id);

                uint32 nextConversationLineId = getNextConversationLineId(currentConversationLine);
                if (!nextConversationLineId)
                    break;

                currentConversationLine = sConversationLineStore.AssertEntry(nextConversationLineId);
            }

            _conversationTemplateStore[conversationTemplate.Id] = std::move(conversationTemplate);
        }
        while (templates->NextRow());

        TC_LOG_INFO("server.loading", ">> Loaded {} Conversation templates in {} ms", _conversationTemplateStore.size(), GetMSTimeDiffToNow(oldMSTime));
    }
    else
    {
        TC_LOG_INFO("server.loading", ">> Loaded 0 Conversation templates. DB table `conversation_template` is empty.");
    }
}

ConversationTemplate const* ConversationDataStore::GetConversationTemplate(uint32 conversationId) const
{
    return Trinity::Containers::MapGetValuePtr(_conversationTemplateStore, conversationId);
}

ConversationLineTemplate const* ConversationDataStore::GetConversationLineTemplate(uint32 conversationLineId) const
{
    return Trinity::Containers::MapGetValuePtr(_conversationLineTemplateStore, conversationLineId);
}

ConversationDataStore* ConversationDataStore::Instance()
{
    static ConversationDataStore instance;
    return &instance;
}