using Newtonsoft.Json;
using System.Collections.Concurrent;


using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;


namespace GameServer;

public class QuestAction : EntityActionBase
{
    private ConcurrentDictionary<(EQuestType, UInt32), ServerCommon.Quest> m_quests = new();

    public QuestAction(EntityBase owner)
        : base(owner)
    { }

    public override async Task<Result> onInit()
    {
        await Task.CompletedTask;

        var result = new Result();

        return result;
    }

    public override void onClear()
    {
        m_quests.Clear();
        return;
    }


    public void removeQuest(ServerCommon.Quest quest)
    {
        if (quest is null)
        {
            Log.getLogger().error("quest is null !!!");
            return;
        }
        var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
        NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");

        var quest_id = quest_attribute.QuestId;
        var quest_type = quest_attribute.QuestType;

        if (false == m_quests.TryRemove((quest_type, quest_id), out _))
        {
            Log.getLogger().error($"quest TryRemove fail  !!! quest : {JsonConvert.SerializeObject(quest)}");
        }
    }


    public Result hasQuest(EQuestType questType, UInt32 questId, UInt32 questRevision = 0)
    {
        var result = new Result();

        if (false == m_quests.ContainsKey((questType, questId)))
        {
            result.setFail(ServerErrorCode.QuestAbadonNotExistQuest, $"Quest Not Exist QuestID : {questId}, questRevision : {questRevision}");
            return result;
        }
        return result;
    }
    public Result hasQuest(string questType, UInt32 questId, UInt32 questRevision = 0)
    {
        var result = new Result();
        if (false == checkHasQuest(questType, questId))
        {
            result.setFail(ServerErrorCode.QuestAbadonNotExistQuest, $"Quest Not Exist QuestID : {questId}, questRevision : {questRevision}");
            return result;
        }
        return result;
    }


    public bool checkHasQuest(EQuestType questType, UInt32 questId)
    {
        return m_quests.ContainsKey((questType, questId));
    }

    public bool checkHasQuest(string questType, UInt32 questId)
    {
        var quest_type = EnumHelper.convertEnumTypeAndValueStringToEnum(questType, EQuestType.NORMAL);
        return m_quests.ContainsKey((quest_type, questId));
    }


    public Result deleteQuest(EQuestType questType, UInt32 questId)
    {
        var result = new Result();
        var owner = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");

        if (false == m_quests.TryRemove((questType, questId), out var quest))
        {
            var err_msg = $"Quest Not Exist QuestID : {questId}, owner : {owner.toBasicString()}";
            result.setFail(ServerErrorCode.QuestAbadonNotExistQuest, err_msg);
            Log.getLogger().error(result.toBasicString());
            return result;
        }

        return result;
    }

    //public void deleteQuestFromdDictionary(Int32 questId, Int32 questRevision = 0)
    //{
    //    var quest_key = QuestMetaHelper.makeQuestsDictionaryKey(questId, questRevision);
    //    m_quests.TryRemove(quest_key, out var _);
    //}

    public async Task<Result> setQuestsFromDoc(QuestDoc doc)
    {
        var result = new Result();
        var owner = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");

        ServerCommon.Quest quest = new ServerCommon.Quest(owner, owner.getUserGuid());

        var attribute = quest.getEntityAttribute<QuestAttribute>();

        if (attribute is null)
        {
            var err_msg = $"Fail to get QuestAttribute";
            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
            return result;
        }

        if (false == doc.getAttribWrappers().TryGetValue(typeof(QuestAttrib), out var to_copy_doc_attrib))
        {
            var err_msg = $"Fail to get QuestAttrib";
            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
            return result;
        }

        var attrib_base = to_copy_doc_attrib.getAttribBase();
        var doc_attrib = attrib_base as QuestAttrib;
        if (doc_attrib is null)
        {
            var err_msg = $"Fail to get QuestAttrib";
            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
            return result;
        }

        attribute.QuestId = doc_attrib.m_quest_id;
        attribute.QuestType = doc_attrib.m_quest_type;
        attribute.UgqInfo.QuestRevision = doc_attrib.m_ugq_quest_info.QuestRevision;
        attribute.UgqInfo.QuestCost = doc_attrib.m_ugq_quest_info.QuestCost;
        attribute.UgqInfo.UqgState = doc_attrib.m_ugq_quest_info.UqgState;
        attribute.QuestAssignTime = doc_attrib.m_quest_assign_time;
        attribute.CurrentTaskNum = doc_attrib.m_current_task_num;
        attribute.TaskStartTime = doc_attrib.m_task_start_time;
        attribute.QuestCompleteTime = doc_attrib.m_quest_complete_time;
        attribute.ActiveEvents = doc_attrib.m_active_events;
        attribute.HasCounter = doc_attrib.m_has_counter;
        attribute.MinCounter = doc_attrib.m_min_counter;
        attribute.MaxCounter = doc_attrib.m_max_counter;
        attribute.CurrentCounter = doc_attrib.m_current_counter;
        attribute.IsComplete = doc_attrib.m_is_complete;
        attribute.ReplacedRewardGroupId = doc_attrib.m_replaced_reward_group_id;
        attribute.HasTimer = doc_attrib.m_has_timer;
        attribute.TimerCompleteTime = doc_attrib.m_timer_complete_time;
        attribute.CurrentTaskComplete = doc_attrib.m_is_current_task_complete;
        attribute.CompletedIdxStrings = doc_attrib.m_completed_idx_strings;
        attribute.m_quest_doc_nullable = doc;

        (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(owner, doc_attrib.m_quest_id, doc_attrib.m_ugq_quest_info.QuestRevision, attribute.UgqInfo.UqgState);
        if(result.isFail())
        {
            if (attribute.UgqInfo.UqgState == UgqStateType.Test)
            {
                var ugq_test_action = owner.getEntityAction<UgqTestAction>();
                var copy_doc = await attribute.toDocBase();
                
                _ = await ugq_test_action.ugqTestDelete(attribute);
            }
            else
            {
                var err_msg = $"getQuestMeta result fail, owner : {owner.toBasicString()}, quest_id : {doc_attrib.m_quest_id}, questRevision : {doc_attrib.m_ugq_quest_info.QuestRevision}, " +
                $"state : {attribute.UgqInfo.UqgState}, result : {result.toBasicString()}";
                Log.getLogger().error(err_msg);
            }
            return result;
        }
        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;
        NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!! - {owner.toBasicString()}");
        if (false == EnumHelper.tryParse(quest_base_info.QuestType, out MetaAssets.EQuestType quest_type))
        {
            attribute.QuestType = MetaAssets.EQuestType.NONE;
        }
        else attribute.QuestType = quest_type;


        if (false == m_quests.TryAdd((attribute.QuestType, attribute.QuestId), quest))
        {
            var err_msg = $"m_quest try Add Fail type : {attribute.QuestType}, quest Id : {attribute.QuestId}, questRevision : {attribute.UgqInfo.QuestRevision}, state : {attribute.UgqInfo.UqgState}";
            result.setFail(ServerErrorCode.ServerLogicError, err_msg);
            return result;
        }


        return result;
    }



    public Result assignableQuestCheckByQuestType(EQuestType questType)
    {
        var result = new Result();

        bool is_max = false;

        Int32 epic_quest_count = 0;
        Int32 tutorial_quest_count = 0;
        Int32 normal_quest_count = 0;
        Int32 ugq_quest_count = 0;
        foreach (var quest in m_quests)
        {
            var quest_type = quest.Key.Item1;
            if (quest_type.Equals(EQuestType.EPIC)) epic_quest_count++;
            else if (quest_type.Equals(EQuestType.TUTORIAL)) tutorial_quest_count++;
            else if (quest_type.Equals(EQuestType.NORMAL)) normal_quest_count++;
            else if (quest_type.Equals(EQuestType.UGQ)) ugq_quest_count++;
        }

        switch (questType)
        {
            case MetaAssets.EQuestType.NORMAL:
                if (normal_quest_count >= MetaHelper.GameConfigMeta.MaxNormalQuest) is_max = true;
                break;
            case MetaAssets.EQuestType.EPIC:
                if (epic_quest_count >= MetaHelper.GameConfigMeta.MaxEpicQuest) is_max = true;
                break;
            case MetaAssets.EQuestType.TUTORIAL:
                if (tutorial_quest_count >= MetaHelper.GameConfigMeta.MaxTutorialQuest) is_max = true;
                break;
            case MetaAssets.EQuestType.UGQ:
                if (tutorial_quest_count >= MetaHelper.GameConfigMeta.MaxUGQuest) is_max = true;
                break;
            default:
                break;
        }

        if (is_max)
        {
            result.setFail(ServerErrorCode.QuestTypeAssignCountMax, $"Quest is Max questType : {questType.ToString()}");
            return result;
        }


        return result;



    }



    //         private List<QuestMetaInfo> makeQuestMetaInfoData(List<UserQuestInfo> infos)
    //         {
    //             List<QuestMetaInfo> metaInfos = new List<QuestMetaInfo>();
    //             foreach (UserQuestInfo info in infos)
    //             {
    //                 if (!MetaData.Instance._QuestScriptMetaTable.TryGetValue(info.m_quest_id, out var questScripts))
    //                 {
    //                     Log.getLogger().error($"QuestMetaInfoData Not Exist questId : {info.m_quest_id}");
    //                     continue;
    //                 }
    // 
    //                 foreach (var script in questScripts.Values)
    //                 {
    //                     var meta = QuestNotifyHelper.fillQuestMetaInfo(script);
    //                     metaInfos.Add(meta);
    //                 }
    //             }
    // 
    //             return metaInfos;
    //         }



    

    public Result getQuest(string questType, UInt32 questId, out ServerCommon.Quest? quest)
    {
        var result = new Result();

        var quest_type = EnumHelper.convertEnumTypeAndValueStringToEnum(questType, EQuestType.NORMAL);
        if (false == m_quests.TryGetValue((quest_type, questId), out quest))
        {
            result.setFail(ServerErrorCode.QuestAssingDataNotExist, $"Quest Not Exist QuestID : {questId}");
            return result;
        }
        
        return result;
    }

    public Result getQuest(EQuestType questType, UInt32 questId, out ServerCommon.Quest? quest)
    {
        var result = new Result();

        if (false == m_quests.TryGetValue((questType, questId), out quest))
        {
            result.setFail(ServerErrorCode.QuestAssingDataNotExist, $"Quest Not Exist QuestID : {questId}");
            return result;
        }

        return result;
    }

    public async Task<(Result, ServerCommon.Quest?)> getQuest(UInt32 questId, UInt32 questRevision)
    {
        var result = new Result();
        ////(result, var quest_base_info) = QuestMetaHelper.getQuestMetaInfo(questId, questRevision);
        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
        (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(player, questId, questRevision);
        if (result.isFail()) return (result, null!);
        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;

        NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");
        var quest_type = EnumHelper.convertEnumTypeAndValueStringToEnum(quest_base_info.QuestType, EQuestType.NORMAL);
        if (false == m_quests.TryGetValue((quest_type, questId), out var quest))
        {
            result.setFail(ServerErrorCode.QuestAssingDataNotExist, $"Quest Not Exist QuestID : {questId}");
            return (result, null);
        }
        return (result, quest);
    }


    public ConcurrentDictionary<(EQuestType, UInt32), ServerCommon.Quest> getQuests()
    {
        return m_quests;
    }


    public List<ServerCommon.Quest> getUgqQuests()
    {
        List<ServerCommon.Quest> ugq_quests = new List<ServerCommon.Quest>();
        foreach (var quest in m_quests)
        {
            var quest_type = quest.Key.Item1;
            var quest_id = quest.Key.Item2;
            var quest_attribute = quest.Value.getEntityAttribute<QuestAttribute>();
            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");

            if (quest_attribute.UgqInfo.QuestRevision > 0)
            {
                ugq_quests.Add(quest.Value);
            }
        }

        return ugq_quests;
    }

    public List<ServerCommon.Quest> getSystemQuests()
    {
        List < ServerCommon.Quest > system_quests = new List<ServerCommon.Quest>();
        foreach (var quest in m_quests.Values)
        {
            var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
            if (quest_attribute.UgqInfo.QuestRevision == 0)
            {
                system_quests.Add(quest);
            }
        }

        return system_quests;
    }

    public List<UInt32> getSystemQuestIds()
    {
        List<UInt32> quest_ids = new ();
        foreach (var quest in m_quests)
        {
            var quest_attribute = quest.Value.getEntityAttribute<QuestAttribute>();
            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
            if (quest_attribute.UgqInfo.QuestRevision == 0)
            {
                quest_ids.Add(quest.Key.Item2);
            }
        }

        return quest_ids;
    }


    public async Task<Result> questForceAcceptWithTransaction(UInt32 questId)
    {
        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
        var server_logic = GameServerApp.getServerLogic();

        AcceptQuestVariable? accept_quest_var = null;
        var quest_accept_action = player.getEntityAction<QuestAcceptAction>();
        var fn_quest_force_accept = async delegate ()
        {
            var fn_result = new Result();

            (fn_result, accept_quest_var) = await quest_accept_action.questAccept(questId);
            if (fn_result.isFail()) return fn_result;

            NullReferenceCheckHelper.throwIfNull(accept_quest_var, () => $"accept_quest_var is null !!!");

            var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.QuestMainAssignForce, server_logic.getDynamoDbClient());
            {
                batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
            }

            batch.appendBusinessLog(new QuestAcceptBusinessLog(questId, 0, accept_quest_var.m_quest_type));

            fn_result = await QueryHelper.sendQueryAndBusinessLog(batch);

            return fn_result;
        };

        var result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "QuestForceAccept", fn_quest_force_accept);
        if (result.isFail())
        {
            string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {player.toBasicString()}";
            Log.getLogger().error(err_msg);
            return result;
        }

        if (null != accept_quest_var)
        {
            var quest = accept_quest_var.m_new_quest_nullable;

            NullReferenceCheckHelper.throwIfNull(quest, () => $"quest is null !!!");
            NullReferenceCheckHelper.throwIfNull(accept_quest_var.m_quest_base_info_nullable, () => $"accept_quest_var.m_quest_base_info_nullable is null !!!");

            var quest_id = accept_quest_var.m_quest_base_info_nullable.QuestId;
            var quest_action = player.getEntityAction<QuestAction>();
            quest_action.addNewQuest(quest_id, quest);
            await player.send_GS2C_NTF_QUEST_UPDATE(quest_id, 0, new(), true);

            foreach (var assignable_quest_id in accept_quest_var.assignable_quests)
            {
                await quest_accept_action.questAcceptWithTransaction(assignable_quest_id, 0, 0);
            }
        }

        return result;
    }


    public async Task<List<ServerCommon.Quest>> makeNewQuestByCreateUser(List<UInt32> forceAcceptQuestIds)
    {
        var owner = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(owner);
        var quest_accept_action = owner.getEntityAction<QuestAcceptAction>();

        List<ServerCommon.Quest> new_quests = new List<ServerCommon.Quest>();

        foreach (var questId in forceAcceptQuestIds)
        {
            (var result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(questId);
            if (result.isFail()) continue;
            var quest_base_info = quest_meta_all_base_info.m_quest_base_info;

            AcceptQuestVariable accept_quest_var = new();
            accept_quest_var.m_is_mail_quest = false;
            accept_quest_var.m_quest_base_info_nullable = quest_base_info;

            result = quest_accept_action.makeNewQuestAssignInfo(ref accept_quest_var);
            if (result.isFail()) continue;

            var new_quest = accept_quest_var.m_new_quest_nullable;
            NullReferenceCheckHelper.throwIfNull(new_quest, () => $"new_quest is null !!! - {owner.toBasicString()}");
            new_quests.Add(new_quest);
        }

        return new_quests;

    }

    public async Task cheatResetAllQuests()
    {
        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
        var result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "ResetAllQuests", delegateDeleteAllQuests);
        if (result.isFail())
        {
            string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {player.toBasicString()}";
            Log.getLogger().error(err_msg);
            return;
        }
        async Task<Result> delegateDeleteAllQuests() => await deleteAllQuests();

        onClear();
        var end_quest_action = player.getEntityAction<EndQuestAction>();
        end_quest_action.onClear();

        player.send_GS2C_NTF_QUEST_UPDATE_EMPTY();

        var quest_mail_action = player.getEntityAction<QuestMailAction>();
        (var mail_quest_ids, var force_accept_quest_ids) = await quest_mail_action.makeQuestMailDocByType(EAssignRequireType.PlayerInitial);


        result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "CheatAccecptQuests", delegateCheatAcceptQuests);
        if (result.isFail())
        {
            string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {player.toBasicString()}";
            Log.getLogger().error(err_msg);
            return;
        }
        async Task<Result> delegateCheatAcceptQuests() => await cheatAcceptQuests(force_accept_quest_ids);

        foreach (var quest_id in force_accept_quest_ids)
        {
            await player.send_GS2C_NTF_QUEST_UPDATE(quest_id, 0, new(), true);
        }

        player.send_GS2C_NTF_END_QUESTS();



    }

    private async Task<Result> cheatAcceptQuests(List<UInt32> force_accept_quest_ids)
    {
        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
        var quest_accept_action = player.getEntityAction<QuestAcceptAction>();

        List<AcceptQuestVariable> accept_quest_vars = new List<AcceptQuestVariable>();
        List<ILogInvoker> invokers = new();
        foreach (var quest_id in force_accept_quest_ids)
        {
            (var accept_result, var quest_accept_var) = await quest_accept_action.questAccept(quest_id);
            if (accept_result.isFail()) continue;

            NullReferenceCheckHelper.throwIfNull(quest_accept_var, () => $"quest_accept_var is null !!!");

            accept_quest_vars.Add(quest_accept_var);
            
            var business_log = new QuestAcceptBusinessLog(quest_id, 0, quest_accept_var.m_quest_type);
            invokers.Add(business_log);
        }

        var server_logic = GameServerApp.getServerLogic();
        var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandQuestAccept, server_logic.getDynamoDbClient());
        {
            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
        }

        batch.appendBusinessLogs(invokers);

        var result = await QueryHelper.sendQueryAndBusinessLog(batch);
        if (result.isFail()) return result;

        var quest_action = player.getEntityAction<QuestAction>();

        foreach (var quest_var in accept_quest_vars)
        {
            NullReferenceCheckHelper.throwIfNull(quest_var.m_quest_base_info_nullable, () => $"quest_var.m_quest_base_info_nullable is null !!!");
            NullReferenceCheckHelper.throwIfNull(quest_var.m_new_quest_nullable, () => $"quest_var.m_new_quest_nullable is null !!!");

            quest_action.addNewQuest(quest_var.m_quest_base_info_nullable.QuestId, quest_var.m_new_quest_nullable);
            await player.send_GS2C_NTF_QUEST_UPDATE(quest_var.m_quest_base_info_nullable.QuestId, 0, new(), true);
        }

        return result;

    }

    private async Task<Result> deleteAllQuests()
    {
        var result = new Result();
        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

        foreach (var quest in m_quests.Values)
        {
            var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
            quest_attribute.deleteEntityAttribute();
        }

        var end_quest_action = player.getEntityAction<EndQuestAction>();
        var end_quests = end_quest_action.getEndQuests();

        var log_invokers = new List<ILogInvoker>();

        foreach (var end_quest in end_quests.Values)
        {
            var end_quest_attribute = end_quest.getEntityAttribute<EndQuestAttribute>();
            NullReferenceCheckHelper.throwIfNull(end_quest_attribute, () => $"end_quest_attribute is null !!!");
            end_quest_attribute.deleteEntityAttribute();

            log_invokers.Add(new EndQuestDeleteBusinessLog(end_quest_attribute.QuestId, end_quest_attribute.QuestRevision));
        }

        var server_logic = GameServerApp.getServerLogic();
        var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandResetAllQuest, server_logic.getDynamoDbClient());
        {
            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
        }
        batch.appendBusinessLogs(log_invokers);

        result = await QueryHelper.sendQueryAndBusinessLog(batch);
        if (result.isFail()) return result;

        return result;
    }

    public async Task questComplete(UInt32 questId)
    {
        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

        var result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "cheatQuestComplete", delegateCheatQuestComplete);
        if (result.isFail())
        {
            string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {player.toBasicString()}";
            Log.getLogger().error(err_msg);
            return;
        }
        async Task<Result> delegateCheatQuestComplete() => await cheatQuestComplete(questId);

        await player.send_GS2C_NTF_QUEST_UPDATE(questId, 0, new(), false);

        await QuestManager.It.QuestCheck(player, new QuestActiveQuest(EQuestEventTargetType.QUEST, EQuestEventNameType.COMPLETED, questId));
    }

    private async Task<Result> cheatQuestComplete(UInt32 questId)
    {
        var result = new Result();
        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

        (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(questId);
        if (result.isFail()) return result;
        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;

        NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");

        result = getQuest(quest_base_info.QuestType, questId, out var quest);
        if(result.isFail()) return result;

        NullReferenceCheckHelper.throwIfNull(quest, () => $"quest is null !!!");

        var quest_attribute = quest.getEntityAttribute<QuestAttribute>();

        NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");

        quest_attribute.IsComplete = 1;
        quest_attribute.ActiveEvents.Clear();
        quest_attribute.modifiedEntityAttribute();

        var server_logic = GameServerApp.getServerLogic();
        var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandQuestComplete, server_logic.getDynamoDbClient());
        {
            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
        }
        batch.appendBusinessLog(new QuestCompleteBusinessLog(questId, 0));

        result = await QueryHelper.sendQueryAndBusinessLog(batch);

        return result;
    }

    public async Task cheatAcceptQuest(UInt32 questId)
    {
        (var result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(questId);
        if (result.isFail()) return;
        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;

        NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");

        var quest_type = EnumHelper.convertEnumTypeAndValueStringToEnum(quest_base_info.QuestType, EQuestType.NORMAL);

        result = hasQuest(quest_base_info.QuestType, questId);
        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

        if (result.isSuccess())
        {
            result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "cheatDeleteQuest", delegatecheatDeleteQuest);
            if (result.isFail())
            {
                string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {player.toBasicString()}";
                Log.getLogger().error(err_msg);
                return;
            }
            async Task<Result> delegatecheatDeleteQuest() => await cheatDeleteQuest(quest_type, questId);
            m_quests.TryRemove((quest_type, questId), out var _);
        }
        
        var quest_accept_action = player.getEntityAction<QuestAcceptAction>();
        await quest_accept_action.questAcceptWithTransaction(questId, 0, 0);
    }

    private async Task<Result> cheatDeleteQuest(EQuestType questType, UInt32 questId, UInt32 questRevision = 0)
    {
        var result = new Result();

        m_quests.TryGetValue((questType, questId), out var quest);

        NullReferenceCheckHelper.throwIfNull(quest, () => $"quest is null !!!");

        var quest_attribute = quest.getEntityAttribute<QuestAttribute>();

        NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");
        quest_attribute.deleteEntityAttribute();
                    
        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

        var server_logic = GameServerApp.getServerLogic();
        var batch = new QueryBatchEx<QueryRunnerWithDocument>(player, LogActionType.CheatCommandDeleteQuest, server_logic.getDynamoDbClient());
        {
            batch.addQuery(new DBQWriteToAttributeAllWithTransactionRunner());
        }
        batch.appendBusinessLog(new QuestDeleteBusinessLog(questId, questRevision));

        result = await QueryHelper.sendQueryAndBusinessLog(batch);


        return result;
    }


    public async Task<Result> questAssignableItemConditionCheck(ItemMetaData itemMeta)
    {
        var result = new Result();

        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
        var quest_mail_action = player.getEntityAction<QuestMailAction>();
        
        var normal_mails = await quest_mail_action.getNormalMailSet();
        var normal_mail_count = normal_mails.Count;
        var quest_id = (UInt32)itemMeta.Register_id;

        (result, var quest_meta_all_base_info) = await QuestMetaManager.It.getQuestMeta(quest_id);
        if (result.isFail()) return result;
        var quest_base_info = quest_meta_all_base_info.m_quest_base_info;

        NullReferenceCheckHelper.throwIfNull(quest_base_info, () => $"quest_base_info is null !!!");

        //진행중인 퀘스트가 있어서 아이템 사용 불가
        if (true == checkHasQuest(quest_base_info.QuestType, quest_id))
        {
            var err_msg = $"Item Use : Already Has Quest quest_id : {quest_id}, player : {player.toBasicString()}";
            result.setFail(ServerErrorCode.ItemUseAlreadyHasQuest, err_msg);
            Log.getLogger().warn(err_msg);
            return result;
        }
        return result;
    }

    public async Task<(Result, HashSet<UInt32>)> resetQuestCoolTimeConditionCheck()
    {
        var result = new Result();

        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
        var quest_mail_action = player.getEntityAction<QuestMailAction>();            

        var my_normal_quest_mails = await quest_mail_action.getNormalMailSet();
        var my_normal_quest_mail_count = my_normal_quest_mails.Count;
                    
        HashSet<UInt32> assignable_mail_set = await quest_mail_action.getAssignableMailSet();

        //퀘스트메일이 가득차서 아이템 사용 불가
        if (MetaHelper.GameConfigMeta.MaxQuestSendMail <= my_normal_quest_mail_count)
        {
            var err_msg = $"Item Use : Assignable QuestMail is Max, my_normal_quest_mail_count : {my_normal_quest_mail_count} normal_mails : {JsonConvert.SerializeObject(my_normal_quest_mails)}, player : {player.toBasicString()}";
            result.setFail(ServerErrorCode.ItemUseQuestMailCountMax, err_msg);
            Log.getLogger().warn(err_msg);
            return (result, assignable_mail_set);
        }
        //할당가능한 퀘스트 메일이 없다. 
        if (assignable_mail_set.Count < 1) 
        {
            var err_msg = $"Item Use : Assignable QuestMail is none, normal_mails : {JsonConvert.SerializeObject(my_normal_quest_mails)}, player : {player.toBasicString()}";
            result.setFail(ServerErrorCode.ItemUseNotExistAssignableQuest, err_msg);
            Log.getLogger().warn(err_msg);
            return (result, assignable_mail_set);
        }
        
        return (result, assignable_mail_set);

    }

    public async Task<(Result, AcceptQuestVariable?)> questAssignByItem(ItemMetaData itemMeta)
    {
        var result = new Result();
        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

        var quest_id = (UInt32)itemMeta.Register_id;

        var quest_accept_action = player.getEntityAction<QuestAcceptAction>();
        
        (result , var accept_quest_var) = await quest_accept_action.questAccept(quest_id);

        return (result, accept_quest_var);
    }

    public void addNewQuest(UInt32 questId, ServerCommon.Quest quest)
    {
        var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
        NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");

        var key = (quest_attribute.QuestType, questId);
        m_quests.TryAdd(key, quest);
    }


    public async Task cheatDeleteQuestAction(EQuestType questType, UInt32 questId, UInt32 questRevision)
    {
        var player = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");

        var result = await player.runTransactionRunnerSafely(TransactionIdType.PrivateContents, "cheatDeleteQuest", delegatecheatDeleteQuest);
        if (result.isFail())
        {
            string err_msg = $"Failed to runTransactionRunnerSafely()!!! : {result.toBasicString()} - {player.toBasicString()}";
            Log.getLogger().error(err_msg);
            return;
        }
        async Task<Result> delegatecheatDeleteQuest() => await cheatDeleteQuest(questType, questId, questRevision);

        m_quests.TryRemove((questType, questId), out var _);
    }

    public Dictionary<UInt32, ServerCommon.Quest> getTestUgqs()
    {
        Dictionary<UInt32, ServerCommon.Quest> test_ugq_ids = new();
        foreach (var quest in m_quests.Values)
        {
            var quest_attribute = quest.getEntityAttribute<QuestAttribute>();
            NullReferenceCheckHelper.throwIfNull(quest_attribute, () => $"quest_attribute is null !!!");

            if (quest_attribute.QuestType == EQuestType.UGQ && quest_attribute.UgqInfo.UqgState == UgqStateType.Test)
            {
                test_ugq_ids.Add(quest_attribute.QuestId, quest);
            }
        }

        return test_ugq_ids;
    }

    
    public Result setQuestCheckFromDoc(DailyQuestCheckDoc doc)
    {
        var result = new Result();
        
        var owner = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");

        var daily_quest_check_attribute = owner.getEntityAttribute<DailyQuestCheckAttribute>();
        
        if (daily_quest_check_attribute is null)
        {
            var err_msg = $"Fail to get daily_quest_check_attribute";
            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
            return result;
        }
        
        if (false == doc.getAttribWrappers().TryGetValue(typeof(DailyQuestCheckAttrib), out var to_copy_doc_attrib))
        {
            var err_msg = $"Fail to get DailyQuestCheckAttrib";
            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
            return result;
        }
        
        var attrib_base = to_copy_doc_attrib.getAttribBase();
        var doc_attrib = attrib_base as DailyQuestCheckAttrib;
        if (doc_attrib is null)
        {
            var err_msg = $"Fail to get RentalInstanceVisitAttrib";
            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
            return result;
        }

        foreach (var id in doc_attrib.m_daily_sended_quest)
        {
            daily_quest_check_attribute.m_daily_sended_quest.Add(id);
        }
        

        daily_quest_check_attribute.m_next_refresh_time = doc_attrib.m_next_refresh_time;
        daily_quest_check_attribute.m_daily_quest_check_doc_nullable = doc;

        return result;
    }

    public Result setPeriodRepeatQuestFromDoc(QuestPeriodRepeatCheckDoc doc)
    {
        var result = new Result();
        
        var owner = getOwner() as Player;
        NullReferenceCheckHelper.throwIfNull(owner, () => $"owner is null !!!");

        var period_repeat_quest_attribute = owner.getEntityAttribute<QuestPeriodRepeatCheckAttribute>();
        
        if (period_repeat_quest_attribute is null)
        {
            var err_msg = $"Fail to get period_repeat_quest_attribute";
            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
            return result;
        }
        
        if (false == doc.getAttribWrappers().TryGetValue(typeof(QuestPeriodRepeatAttrib), out var to_copy_doc_attrib))
        {
            var err_msg = $"Fail to get QuestPeriodRepeatAttrib";
            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
            return result;
        }
        
        var attrib_base = to_copy_doc_attrib.getAttribBase();
        var doc_attrib = attrib_base as QuestPeriodRepeatAttrib;
        if (doc_attrib is null)
        {
            var err_msg = $"Fail to get QuestPeriodRepeatAttrib";
            result.setFail(ServerErrorCode.EntityAttributeNotFound, err_msg);
            return result;
        }

        foreach (var info in doc_attrib.m_period_repeat_quests)
        {
            QuestPeriodRepeatInfo repeat_info = new();
            
            //repeat_info.m_next_refresh_time = info.m_sen;

            foreach (var send_quest in info.Value.m_sended_quest)
            {
                repeat_info.m_sended_quest.TryAdd(send_quest.Key, send_quest.Value);
            }

            if (false == period_repeat_quest_attribute.m_period_repeat_quests.TryAdd(info.Key, repeat_info))
            {
                Log.getLogger().warn($"m_period_repeat_quests add Fail info.key : {info.Key}, value : {JsonConvert.SerializeObject(info.Value)}");
            }
        }

        return result;
    }
}