using System.Collections.Concurrent;


using RabbitMQ.Client;
using MongoDB.Bson.IO;


using ServerCore; using ServerBase;
using ServerCommon;


using MetaAssets;


using UGQDatabase.Models;


namespace GameServer;

public static class UgqMetaHelper
{
    public static UgqNpcInfo copyToUgcNpc(UgcNpcAttrib npcAttrib)
    {
        var ugq_npc = new UgqNpcInfo();
        ugq_npc.NpcMetaGuid = npcAttrib.UgcNpcMetaGuid; 
        ugq_npc.OwnerGuid = npcAttrib.OwnerGuid;
        ugq_npc.OwnerEntityType = (int)npcAttrib.OwnerEntityType;
        ugq_npc.Nickname = npcAttrib.Nickname;
        ugq_npc.Title = npcAttrib.Title;
        ugq_npc.Greeting = npcAttrib.Greeting;
        ugq_npc.Introduction = npcAttrib.Introduction;
        ugq_npc.Description = npcAttrib.Description;
        ugq_npc.WorldScenario = npcAttrib.WorldScenario;
        ugq_npc.DefaultSocialActionMetaId = npcAttrib.DefaultSocialActionMetaId;
        ugq_npc.HabitSocialActionMetaIds.AddRange(npcAttrib.HabitSocialActionMetaIds);
        ugq_npc.DialogueSocialActionMetaIds.AddRange(npcAttrib.DialogueSocialActionMetaIds);
        ugq_npc.BodyItemMetaId = npcAttrib.BodyItemMetaId;
        ugq_npc.HashTagMetaIds.AddRange(npcAttrib.HashTagMetaIds);
        ugq_npc.State = npcAttrib.State;
        ugq_npc.IsRegisteredAiChatServer = npcAttrib.IsRegisteredAiChatServer == true ? BoolType.True : BoolType.False;

        return ugq_npc;

    }

    public static UGQAbortReason convertUGQAbortReason(this UgqStateType ugqStateType)
    {
        switch (ugqStateType)
        {
            case UgqStateType.Shutdown:
                return UGQAbortReason.Shutdown;

            case UgqStateType.RevisionChanged:
                return UGQAbortReason.RevisionUpdated;

            case UgqStateType.None:
            default:
                return UGQAbortReason.None;
        }
    
    }


    public static (Result, QuestBaseInfo?) generateUgqQuestBaseInfo(GameQuestDataEntity gameQuestData)
    {
        var quest_base_info = new QuestBaseInfo();
        SortedSet<int> setTaskNum = new();
        SortedSet<int> setTaskIdx = new();

        UgqGradeType grade_type = gameQuestData.GradeType;
        int beacon_id = gameQuestData.BeaconId;
            
        var result = new Result();
        if (gameQuestData.QuestScriptMetas.Count == 0)
        {
            var err_msg = $"gameQuestData QuestsScript Metas count zero QuestId : {gameQuestData.QuestId}, revision : {gameQuestData.Revision}";
            result.setFail(ServerErrorCode.UgqQuestMetaNotExist, err_msg);
            Log.getLogger().error(result.toBasicString());
            return (result, null);
        }

        var quest_script_metas = convertQuestMeta2ScrioptMeta(gameQuestData.QuestScriptMetas);

        var ugq_quest_type = QuestHelper.convertQuestContentStateToUgqStateType(gameQuestData.State);
        MetaData.Instance.makeQuestBaseInfo(quest_script_metas, ref quest_base_info, ref setTaskIdx,
            (UInt32)gameQuestData.QuestId,
            EQuestType.UGQ.ToString(),
            true,
            EAssignType.NONE.ToString(),
            ERequirementQuestType.None.ToString(),
            0,
            OncePeriodRangeType.Nolimit,
            false,
            true,
            getUgqRewardGroupIdByGrade(grade_type, beacon_id),
            string.Empty,
            string.Empty,
            ugq_quest_type,
            (UInt32)gameQuestData.Revision
            );


        //Log.getLogger().info($"base_info : {JsonConvert.SerializeObject(quest_base_info)}");
        return (new(), quest_base_info);

    }
    
    private static bool isWorldBeacon(int beaconId)
    {
        if (beaconId > 0)
        {
            return true;
        }
        else return false;

    }


    /*
     * ugq api 서버 테스트 및 디버깅이 어려워 우선 meta 정보 받아오고 나서 groupId셋팅 처리
     * 추후 다시 리팩토링 필요
     */
    
    private static int getUgqRewardGroupIdByGrade(UgqGradeType gradeType, int beaconId) 
    {

        bool is_world_beacon = isWorldBeacon(beaconId);

        if (is_world_beacon)
        {
            switch (gradeType)
            {
                case UgqGradeType.Amature:
                    return MetaHelper.GameConfigMeta.WorldBeaconAmateurUGQReward;
                case UgqGradeType.RisingStar:
                    return MetaHelper.GameConfigMeta.WorldBeaconRisingstarUGQReward;
                case UgqGradeType.Master1:
                    return MetaHelper.GameConfigMeta.WorldBeaconMasterOneUGQReward;
                case UgqGradeType.Master2:
                    return MetaHelper.GameConfigMeta.WorldBeaconMasterTwoUGQReward;
                case UgqGradeType.Master3:
                    return MetaHelper.GameConfigMeta.WorldBeaconMasterThreeUGQReward;
                default:
                    Log.getLogger().error($"{gradeType} type not exist in getUgqRewardGroupIdByGrade");
                    return 0;
            }
        }
        else
        {
            switch (gradeType)
            {
                case UgqGradeType.Amature:
                    return MetaHelper.GameConfigMeta.NormalBeaconAmateurUGQReward;
                case UgqGradeType.RisingStar:
                    return MetaHelper.GameConfigMeta.NormalBeaconRisingstarUGQReward;
                case UgqGradeType.Master1:
                    return MetaHelper.GameConfigMeta.NormalBeaconMasterOneUGQReward;
                case UgqGradeType.Master2:
                    return MetaHelper.GameConfigMeta.NormalBeaconMasterTwoUGQReward;
                case UgqGradeType.Master3:
                    return MetaHelper.GameConfigMeta.NormalBeaconMasterThreeUGQReward;
                default:
                    Log.getLogger().error($"{gradeType} type not exist in getUgqRewardGroupIdByGrade");
                    return 0;
            }
        }



    }

    public static List<QuestScriptMetaData> convertQuestMeta2ScrioptMeta(List<QuestMetaInfo> questMetaInfos)
    {
        List<QuestScriptMetaData> metas = new();

        (var quest_id, var quest_revision) = QuestHelper.convertUgqQuestIdToQuestIdAndRevision(questMetaInfos[0].ComposedQuestId);

        foreach (var quest_meta in questMetaInfos)
        {
            QuestScriptMetaDataMutable script_mutable = new();

            script_mutable.QuestId = quest_id;
            script_mutable.Index = quest_meta.Index;
            script_mutable.EventTarget = quest_meta.EventTarget;
            script_mutable.Event = quest_meta.EventName;
            script_mutable.EventCondition1 = quest_meta.EventCondition1;
            script_mutable.EventCondition2 = quest_meta.EventCondition2;
            script_mutable.EventCondition3 = quest_meta.EventCondition3;
            script_mutable.FunctionTarget = quest_meta.FunctionTarget;
            script_mutable.Function = quest_meta.FunctionName;
            script_mutable.FunctionCondition1 = quest_meta.FunctionCondition1;
            script_mutable.FunctionCondition2 = quest_meta.FunctionCondition2;
            script_mutable.FunctionCondition3 = quest_meta.FunctionCondition3;


            QuestScriptMetaData script_meta = new(script_mutable);
            metas.Add(script_meta);
        }
        return metas;
    }


    public static async Task<(Result, GameQuestDataEntity?)> loadLiveGameQuestGameDataEntity(Player player, UInt32 questId, UInt32 questRevision)
    {
        var server_logic = GameServerApp.getServerLogic();
        var ugq_api_manager = server_logic.GetUqgApiManager();
        NullReferenceCheckHelper.throwIfNull(ugq_api_manager, () => $"ugq_api_manager is null - {player.toBasicString()}");

        var lang_type = player.getLanguageType();

        var func = new Func<string, UInt32, UInt32, LanguageType, Task<(Result, GameQuestDataEntity?)>>(ugq_api_manager.getUgqQuestData);
        
        return await loadGameQuestDataEntity(player, questId, questRevision, func);
    }

    public static async Task<(Result, GameQuestDataEntity?)> loadTestGameQuestGameDataEntity(Player player, UInt32 questId, UInt32 questRevision)
    {
        var server_logic = GameServerApp.getServerLogic();
        var ugq_api_manager = server_logic.GetUqgApiManager();
        NullReferenceCheckHelper.throwIfNull(ugq_api_manager, () => $"ugq_api_manager is null - {player.toBasicString()}");

        var lang_type = player.getLanguageType();

        var func = new Func<string, UInt32, UInt32, LanguageType, Task<(Result, GameQuestDataEntity?)>>(ugq_api_manager.getUgqTestQuestData);

        return await loadGameQuestDataEntity(player, questId, questRevision, func);
    }

    public static async Task<(Result, GameQuestDataEntity?)> loadGameQuestDataEntity(Player player, UInt32 questId, UInt32 questRevision, Func<string, UInt32, UInt32, LanguageType, Task<(Result, GameQuestDataEntity?)>> func)
    {
        // 1. ugq api 서버에서 데이터 호출
        (var result, var game_quest_data) = await func(player.getUserGuid(), questId, questRevision, player.getLanguageType());
        if (result.isFail())
        {
            return (result, null);
        }
        if (game_quest_data == null || game_quest_data.QuestScriptMetas.Count == 0 || game_quest_data.UgqGameQuestDataForClientString == string.Empty)
        {
            var err_msg = $"GameQuestDataEntity NotExist questId : {questId} - questRevision L {questRevision}";
            result.setFail(ServerErrorCode.UgqQuestMetaNotExist, err_msg);
            Log.getLogger().error(err_msg);
            return (result, null);
        }
        
        // 2. string -> UgqGameQuestDataForClient 로 전환및 gradeType, stateType 적용
        var ugq_game_quest_data_for_client = Newtonsoft.Json.JsonConvert.DeserializeObject<UgqGameQuestDataForClient>(game_quest_data.UgqGameQuestDataForClientString);
        if (ugq_game_quest_data_for_client is null)
        {
            var err_msg = $"GameQuestDataEntity NotExist questId : {questId} - questRevision L {questRevision}";
            result.setFail(ServerErrorCode.UgqQuestMetaNotExist, err_msg);
            Log.getLogger().error(err_msg);
            return (result, null);
        }
        game_quest_data.UgqGameQuestDataForClient = ugq_game_quest_data_for_client;
        game_quest_data.UgqGameQuestDataForClient.UgqGradeType = game_quest_data.GradeType;
        game_quest_data.UgqGameQuestDataForClient.UgqStateType = QuestHelper.convertQuestContentStateToUgqStateType(game_quest_data.State);
        
        // 3. IsShowNpcLocation 값 신규 추가 됐으나, 추가되기전 데이터에는 반영이 안되어 있어서 임시로 반영 처리  
        if (false == game_quest_data.UgqGameQuestDataForClientString.Contains("IsShowNpcLocation"))
        {
            foreach (var task in game_quest_data.UgqGameQuestDataForClient.Task)
            {
                task.IsShowNpcLocation = BoolType.True;
            }
        }
        
        // 4. shutdown  체크
        if (game_quest_data.Shutdown == true) game_quest_data.UgqGameQuestDataForClient.UgqStateType = UgqStateType.Shutdown;

        game_quest_data.UgqGameQuestDataForClientString = string.Empty;
        return (result, game_quest_data);
        
    }

    public static (Int32, Int32) getUgqDailyRewardMaxCountByGrade(UgqGradeType grade)
    {
        switch (grade)
        {
            case UgqGradeType.Amature:
                return (MetaHelper.GameConfigMeta.UgqAmateurBonusCount, MetaHelper.GameConfigMeta.UgqBonusGoldAmateur);
            case UgqGradeType.RisingStar:
                return (MetaHelper.GameConfigMeta.UgqRisingStarBonusCount, MetaHelper.GameConfigMeta.UgqBonusGoldRisingStar);
            case UgqGradeType.Master1:
                return (MetaHelper.GameConfigMeta.UgqMaster1BonusCount, MetaHelper.GameConfigMeta.UgqBonusGoldMaster1);
            case UgqGradeType.Master2:
                return (MetaHelper.GameConfigMeta.UgqMaster2BonusCount, MetaHelper.GameConfigMeta.UgqBonusGoldMaster2);
            case UgqGradeType.Master3:
                return (MetaHelper.GameConfigMeta.UgqMaster3BonusCount, MetaHelper.GameConfigMeta.UgqBonusGoldMaster3);
            default:
                return (MetaHelper.GameConfigMeta.UgqAmateurBonusCount, MetaHelper.GameConfigMeta.UgqBonusGoldAmateur);
        }
    }

    public static CurrencyType getUgqUsageFeeType(UgqGradeType grade)
    {
        switch (grade)
        {
            case UgqGradeType.Amature:
                return EnumHelper.convertEnumValueStringToEnum<CurrencyType>(MetaHelper.GameConfigMeta.UgqUsageFeeTypeAmateur, CurrencyType.Sapphire);
            case UgqGradeType.RisingStar:
                return EnumHelper.convertEnumValueStringToEnum<CurrencyType>(MetaHelper.GameConfigMeta.UgqUsageFeeTypeRisingStar, CurrencyType.Ruby);
            case UgqGradeType.Master1:
                return EnumHelper.convertEnumValueStringToEnum<CurrencyType>(MetaHelper.GameConfigMeta.UgqUsageFeeTypeMaster1, CurrencyType.Sapphire);
            case UgqGradeType.Master2:
                return EnumHelper.convertEnumValueStringToEnum<CurrencyType>(MetaHelper.GameConfigMeta.UgqUsageFeeTypeMaster2, CurrencyType.Sapphire);
            case UgqGradeType.Master3:
                return EnumHelper.convertEnumValueStringToEnum<CurrencyType>(MetaHelper.GameConfigMeta.UgqUsageFeeTypeMaster3, CurrencyType.Sapphire);
            default:
                return CurrencyType.Sapphire;
        }
    }
    
    public static int getUgqCost(UgqGradeType gradeType)
    {
        switch (gradeType)
        {
            case UgqGradeType.Amature:
                return MetaHelper.GameConfigMeta.UgqUsageFeeAmateur;
            case UgqGradeType.RisingStar:
                return MetaHelper.GameConfigMeta.UgqUsageFeeRisingStar;
            case UgqGradeType.Master1:
                return MetaHelper.GameConfigMeta.UgqUsageFeeMaster1;
            case UgqGradeType.Master2:
                return MetaHelper.GameConfigMeta.UgqUsageFeeMaster2;
            case UgqGradeType.Master3:
                return MetaHelper.GameConfigMeta.UgqUsageFeeMaster3;
            default:
                return 0;
        }
    }
}