using System;
using System.Collections.Generic;
using UnityEngine;
using LitJson;
using System.Linq;


//查看其他玩家的简短信息, 该模块处理数据，其他由各自功能模块处理 通过OnRevPackage
public class OtherPlayerDetailManager : GameSystemManager<OtherPlayerDetailManager>
{

    public override void Init()
    {
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEventOnRelogin += OnBeforePlayerDataInitializeEventOnRelogin;
    }

    public override void Release()
    {
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEventOnRelogin -= OnBeforePlayerDataInitializeEventOnRelogin;
    }


    public void OnBeforePlayerDataInitializeEventOnRelogin()
    {
        viewPlayerType = -1;
        viewPlayerLineupType = -1;
    }

    public int viewPlayer { get; private set; }

    // 查询类型：根据类型做不同处理
    // 按功能自定义枚举值 EnumHelper的 ViewPlayerType
    public int viewPlayerType { get; private set; }

    public int viewPlayerLineupType { get; private set; }
    public RolePlusData.HeroData heroData;
    public List<RolePlusData.HeroData> heroDatas;
    public RolePlusData.EquipData equip;
    private Dictionary<int, ViewPlayerData> viewPlayerDataDic = new Dictionary<int, ViewPlayerData>();

    // 查看类型，玩家ID
    public event Action<int, int> OnRevPackage; //尽量不要用第一个参数viewtype做判断，容易出错

    // 获取其他玩家本地缓存数据
    public ViewPlayerData GetViewPlayerData(int player)
    {
        ViewPlayerData viewPlayerData = null;
        viewPlayerDataDic.TryGetValue(player, out viewPlayerData);
        return viewPlayerData;
    }


    // 向服务端请求其他玩家数据
    public void ViewPlayerDetail(int _playerId, int viewType = (int)ViewPlayerType.viewPlayerData, int viewPlayerLineupType = (int)BattlePreSetType.Story)
    {
        if (_playerId == PlayerDatas.Instance.baseData.PlayerID)
        {
            return;
        }
        viewPlayerType = viewType;
        this.viewPlayerLineupType = viewPlayerLineupType;
        ViewRoleParticulars(_playerId);
    }

    // 向服务端请求玩家数据
    void ViewRoleParticulars(int playerID)
    {
        if (playerID == 0)
        {
            return;
        }
        viewPlayer = playerID;
        if (viewPlayerDataDic.ContainsKey(playerID))
        {
            ViewPlayerData viewPlayerData = viewPlayerDataDic[playerID];
            if ((DateTime.Now - viewPlayerData.getTime).TotalSeconds < 30)
            {
                ShowRoleParticulars(playerID);
                return;
            }
        }

        //CC002_tagCGViewCrossPlayerInfo c002 = new CC002_tagCGViewCrossPlayerInfo();

        CA212_tagCMViewPlayerInfo pak = new CA212_tagCMViewPlayerInfo();
        pak.PlayerID = (uint)playerID;
        GameNetSystem.Instance.SendInfo(pak);
    }


    //本服竞技场假查询模拟封包，返回查看机器人数据 打开RoleParticularsWin界面，专用接口其他地方不要调用
    public void ViewFairyArenaRobot(int playerID, ViewPlayerData _viewPlayerData)
    {
        ViewPlayerData viewPlayerData = null;
        viewPlayer = playerID;
        if (!viewPlayerDataDic.TryGetValue(playerID, out viewPlayerData))
        {
            viewPlayerDataDic.Add(playerID, _viewPlayerData);
        }
        else
        {
            viewPlayerDataDic[playerID] = _viewPlayerData;
        }

        viewPlayerType = (int)ViewPlayerType.viewPlayerData;
        ShowRoleParticulars(playerID);
    }



    public void OnRevRoleEquip(HA705_tagSCQueryPlayerCacheResult package)
    {

        ViewPlayerData viewPlayerData = null;
        if (!viewPlayerDataDic.TryGetValue((int)package.PlayerID, out viewPlayerData))
        {
            viewPlayerData = new ViewPlayerData();
            viewPlayerData.getTime = DateTime.Now;
            viewPlayerDataDic.Add((int)package.PlayerID, viewPlayerData);
        }

        viewPlayerData.getTime = DateTime.Now;
        viewPlayerData.PlayerID = (int)package.PlayerID;
        viewPlayerData.PlayerName = UIHelper.ServerStringTrim(package.PlayerName);
        viewPlayerData.LV = package.LV;
        viewPlayerData.Job = package.Job;
        viewPlayerData.RealmLV = package.RealmLV;
        viewPlayerData.Face = (int)package.Face;
        viewPlayerData.FacePic = (int)package.FacePic;
        viewPlayerData.ModelMark = (int)package.ModelMark;
        viewPlayerData.EquipShowSwitch = (int)package.EquipShowSwitch;
        viewPlayerData.TitleID = (int)package.TitleID;
        viewPlayerData.ServerID = (int)package.ServerID;
        viewPlayerData.FightPower = package.FightPower + package.FightPowerEx * (long)Constants.ExpPointValue;
        viewPlayerData.FamilyID = (int)package.FamilyID;
        viewPlayerData.FamilyName = UIHelper.ServerStringTrim(package.FamilyName);
        viewPlayerData.FamilyEmblemID = (int)package.FamilyEmblemID;
        viewPlayerData.FamilyEmblemWord = UIHelper.ServerStringTrim(package.FamilyEmblemWord);


        if (viewPlayerData.rolePlusData == null)
        {
            //第一次初始化
            viewPlayerData.rolePlusData = new RolePlusData();
        }
        if (package.PlusDataSize != 0)
        {
            viewPlayerData.rolePlusData.AnalysisRolePlusData(package.PlusData);
        }


        ShowRoleParticulars((int)package.PlayerID);
    }

    //尽量不要用第一个参数viewtype做判断，容易出错，比如同时发送两个不同的viewPlayerType请求的时候
    private void ShowRoleParticulars(int playerID)
    {
        if (viewPlayerType == (int)ViewPlayerType.viewPlayerData)
        {
            if (!UIManager.Instance.IsOpened<OtherPlayerDetailWin>())
            {
                UIManager.Instance.OpenWindow<OtherPlayerDetailWin>(viewPlayerLineupType);
            }
        }

        OnRevPackage?.Invoke(viewPlayerType, playerID);
        viewPlayerType = -1;
        viewPlayerLineupType = -1;
    }
    #region 获取PlusData中的数据

    public int GetFuncPresetID(int playerID, int battleType, int funcType)
    {
        ViewPlayerData viewPlayerData = GetViewPlayerData(playerID);
        if (viewPlayerData?.rolePlusData?.BatPresetDic?.TryGetValue(battleType, out var data) != true)
        {
            return 1;
        }
        return data.ContainsKey(funcType) ? data[funcType] : 1;
    }

    public Dictionary<int, RolePlusData.HeroData> GetHeroDataDict(int playerID, int presetID)
    {
        ViewPlayerData viewPlayerData = GetViewPlayerData(playerID);
        if (viewPlayerData?.rolePlusData?.LineupDic?.TryGetValue(presetID, out var lineupData) != true)
        {
            return null;
        }
        return lineupData?.HeroDic;
    }

    public List<RolePlusData.HeroData> GetHeroDataSortList(int playerID, int presetID)
    {
        var heroDataDict = GetHeroDataDict(playerID, presetID);
        if (heroDataDict == null)
        {
            return null;
        }
        var res = new List<RolePlusData.HeroData>();
        List<int> keyList = heroDataDict.Keys.ToList();
        keyList.Sort();
        foreach (var num in keyList)
        {
            if (!heroDataDict.ContainsKey(num))
            {
                continue;
            }
            res.Add(heroDataDict[num]);
        }
        return res;
    }

    public bool TryGetFightPointByTeamType(int playerID, int presetID, out long fightPower)
    {
        fightPower = 0;
        var lineupDic = GetViewPlayerData(playerID)?.rolePlusData?.LineupDic;
        if (lineupDic != null && lineupDic.TryGetValue(presetID, out var lineupData))
        {
            fightPower = lineupData.FightPower;
            return true;
        }
        return false;
    }

    public Dictionary<int, RolePlusData.EquipData> GetEquipDataDict(int playerID)
    {
        ViewPlayerData viewPlayerData = GetViewPlayerData(playerID);
        return viewPlayerData?.rolePlusData?.EquipDic;
    }

    public int GetUseDataFirstValue(RolePlusData.EquipData equip, int key)
    {
        if (equip.UserData != null && equip.UserData.ContainsKey(key) && equip.UserData[key].Count > 0)
        {
            return equip.UserData[key][0];
        }
        return 0;
    }

    public int GetUseDataFirstValue(RolePlusData.HeroData hero, int key)
    {
        if (hero.Data != null && hero.Data.ContainsKey(key) && hero.Data[key].Count > 0)
        {
            return hero.Data[key][0];
        }
        return 0;
    }

    public int GetEquipLV(RolePlusData.EquipData equip)
    {
        if (equip == null)
        {
            return 0;
        }
        return GetUseDataFirstValue(equip, 22);
    }

    public List<int> GetUseData(RolePlusData.EquipData equip, int key)
    {
        List<int> list = null;
        if (equip.UserData != null)
        {
            equip.UserData.TryGetValue(key, out list);
        }
        return list == null ? new List<int>() : list;
    }

    public List<int> GetUseData(RolePlusData.HeroData hero, int key)
    {
        List<int> list = null;
        if (hero.Data != null)
        {
            hero.Data.TryGetValue(key, out list);
        }
        return list == null ? new List<int>() : list;
    }

    //基础属性ID列表
    public List<int> GetEquipBaseAttrs(RolePlusData.EquipData equip)
    {
        if (equip == null)
        {
            return new List<int>();
        }
        return GetUseData(equip, 21);
    }


    //基础属性值列表
    public List<int> GetEquipBaseValues(RolePlusData.EquipData equip)
    {
        if (equip == null)
        {
            return new List<int>();
        }
        return GetUseData(equip, 23);
    }

    //战斗属性ID列表
    public List<int> GetEquipFightAttrs(RolePlusData.EquipData equip)
    {
        if (equip == null)
        {
            return new List<int>();
        }
        return GetUseData(equip, 17);
    }

    //战斗属性值列表
    public List<int> GetEquipFightValues(RolePlusData.EquipData equip)
    {
        if (equip == null)
        {
            return new List<int>();
        }
        return GetUseData(equip, 19);
    }

    //  武将突破等级
    public int GetBreakLevel(RolePlusData.HeroData hero)
    {
        if (hero == null)
            return 0;
        return GetUseDataFirstValue(hero, 74);
    }

    //  武将觉醒等级
    public int GetAwakeLevel(RolePlusData.HeroData hero)
    {

        if (hero == null)
            return 0;
        return GetUseDataFirstValue(hero, 76);
    }
    // 71 # 英雄天赋ID列表
    public List<int> GetTalentIDList(RolePlusData.HeroData hero)
    {
        if (hero == null)
            return new List<int>();
        return GetUseData(hero, 71);
    }

    // 73 # 英雄天赋ID等级列表，对应71天赋ID的等级
    public List<int> GetTalentLvList(RolePlusData.HeroData hero)
    {
        if (hero == null)
            return new List<int>();
        return GetUseData(hero, 73);
    }

    // 获取红颜属性值
    public RolePlusData.BeautyData GetBeautyData(int playerID)
    {
        ViewPlayerData viewPlayerData = GetViewPlayerData(playerID);
        return viewPlayerData?.rolePlusData?.beautyData;
    }

    // 获取坐骑数据对象
    public RolePlusData.HorseData GetHorseData(int playerID)
    {
        ViewPlayerData viewPlayerData = GetViewPlayerData(playerID);
        return viewPlayerData?.rolePlusData?.horseData;
    }

    #endregion
    #region 解析PlusData
    public class ViewPlayerData
    {
        public int PlayerID;
        public string PlayerName;
        public int LV;
        public int Job;
        public int RealmLV;
        public int Face;
        public int FacePic;
        public int ModelMark;          // 变形模型mark
        public int EquipShowSwitch;    // 其他外观信息
        public int TitleID;
        public int ServerID;
        public long FightPower;
        public int FamilyID;
        public string FamilyName;
        public int FamilyEmblemID;
        public string FamilyEmblemWord;
        public RolePlusData rolePlusData;
        public DateTime getTime;
    }

    public class RolePlusData
    {
        // --- 定义存储数据的结构 ---

        // 装备字典 <位置索引, 装备数据>
        public Dictionary<int, EquipData> EquipDic = new Dictionary<int, EquipData>();

        // 阵容字典 <阵容ID, 阵容数据>
        public Dictionary<int, LineupData> LineupDic = new Dictionary<int, LineupData>();
        public Dictionary<int, Dictionary<int, int>> BatPresetDic = new Dictionary<int, Dictionary<int, int>>();

        // 红颜数据
        public BeautyData beautyData;

        // 坐骑数据
        public HorseData horseData;

        // 红颜数据类
        public class BeautyData
        {
            public int Cnt; // 已解锁数
            public Dictionary<int, long> AttrDict = new Dictionary<int, long>(); // 属性
        }

        // 坐骑数据类
        public class HorseData
        {
            public int LV;       // 等级
            public int ClassLV;  // 阶级
            public Dictionary<int, long> AttrDict = new Dictionary<int, long>(); // 属性
        }

        // 装备数据类
        public class EquipData
        {
            public int ItemID;
            public Dictionary<int, List<int>> UserData = new Dictionary<int, List<int>>();
        }

        // 阵容数据类
        public class LineupData
        {
            public int PlayerID;
            public long FightPower;
            public int ShapeType;
            // 英雄字典 <站位, 英雄数据>
            public Dictionary<int, HeroData> HeroDic = new Dictionary<int, HeroData>();

        }

        // 英雄数据类
        public class HeroData
        {
            public int HeroID;
            public int SkinID;
            public int LV;
            public int Star;
            public long FightPower;
            public List<int> SkillIDList = new List<int>();
            // 属性字典 <属性ID, 属性值>
            public Dictionary<int, long> AttrDict = new Dictionary<int, long>();
            // 英雄专属UserData (格式与物品UserData相同)
            // 使用 Dictionary<int, List<int>> 结构，key为ItemUseDataKey枚举值
            public Dictionary<int, List<int>> Data = new Dictionary<int, List<int>>();
        }

        // 通用的属性解析方法
        private Dictionary<int, long> ParseAttrDict(JsonData jd, string key)
        {
            Dictionary<int, long> result = new Dictionary<int, long>();
            if (jd.Keys.Contains(key))
            {
                JsonData attrs = jd[key];
                foreach (string attrKey in attrs.Keys)
                {
                    if (int.TryParse(attrKey, out int attrId))
                    {
                        JsonData v = attrs[attrKey];
                        long val = 0;
                        // 健壮性数值转换
                        if (v.IsLong) val = (long)v;
                        else if (v.IsInt) val = (long)(int)v;
                        else if (v.IsDouble) val = (long)(double)v;
                        else if (v.IsString) long.TryParse(v.ToString(), out val);

                        result[attrId] = val;
                    }
                }
            }
            return result;
        }

        // --- 解析逻辑 ---
        public void AnalysisRolePlusData(string jsonStr)
        {
            try
            {
                if (string.IsNullOrEmpty(jsonStr)) return;

                EquipDic.Clear();
                LineupDic.Clear();
                BatPresetDic.Clear();
                beautyData = null; // 必须置空，防止显示上一个玩家的数据
                horseData = null;  // 必须置空
                // 1. 转为 JsonData 对象
                JsonData jd = JsonMapper.ToObject(jsonStr);

                // 2. 解析装备 (Equip)
                if (jd.Keys.Contains("Equip"))
                {
                    JsonData equipJd = jd["Equip"];
                    foreach (string key in equipJd.Keys)
                    {
                        if (int.TryParse(key, out int posIndex))
                        {
                            JsonData itemJd = equipJd[key];
                            EquipData equipData = new EquipData();

                            if (itemJd.Keys.Contains("ItemID"))
                                equipData.ItemID = (int)itemJd["ItemID"];

                            if (itemJd.Keys.Contains("UserData") && !string.IsNullOrEmpty((string)itemJd["UserData"]))
                                equipData.UserData = ConfigParse.Analysis((string)itemJd["UserData"]);

                            EquipDic[posIndex] = equipData;
                        }
                    }
                }
                // 【新增】解析红颜 (Beauty)
                if (jd.Keys.Contains("Beauty"))
                {
                    JsonData beautyJd = jd["Beauty"];
                    beautyData = new BeautyData();

                    if (beautyJd.Keys.Contains("Cnt"))
                        beautyData.Cnt = (int)beautyJd["Cnt"];

                    // 解析属性
                    beautyData.AttrDict = ParseAttrDict(beautyJd, "Attr");
                }
                // 【新增】解析坐骑 (Horse)
                if (jd.Keys.Contains("Horse"))
                {
                    JsonData horseJd = jd["Horse"];
                    horseData = new HorseData();

                    if (horseJd.Keys.Contains("LV"))
                        horseData.LV = (int)horseJd["LV"];

                    if (horseJd.Keys.Contains("ClassLV"))
                        horseData.ClassLV = (int)horseJd["ClassLV"];

                    // 解析属性
                    horseData.AttrDict = ParseAttrDict(horseJd, "Attr");
                }
                // 3. 解析阵容 (Lineup)
                if (jd.Keys.Contains("Lineup"))
                {
                    JsonData lineupJd = jd["Lineup"];
                    foreach (string key in lineupJd.Keys)
                    {
                        if (int.TryParse(key, out int lineupId))
                        {
                            JsonData oneLineupJd = lineupJd[key];
                            LineupData lineupData = new LineupData();

                            if (oneLineupJd.Keys.Contains("PlayerID"))
                                lineupData.PlayerID = (int)oneLineupJd["PlayerID"];

                            if (oneLineupJd.Keys.Contains("FightPower"))
                                lineupData.FightPower = long.Parse(oneLineupJd["FightPower"].ToString());

                            if (oneLineupJd.Keys.Contains("ShapeType"))
                                lineupData.ShapeType = (int)oneLineupJd["ShapeType"];

                            // 解析阵容下的英雄 (Hero)
                            if (oneLineupJd.Keys.Contains("Hero"))
                            {
                                JsonData heroRootJd = oneLineupJd["Hero"];
                                foreach (string heroKey in heroRootJd.Keys)
                                {
                                    if (int.TryParse(heroKey, out int heroPos))
                                    {
                                        JsonData heroJd = heroRootJd[heroKey];
                                        HeroData heroData = new HeroData();

                                        if (heroJd.Keys.Contains("HeroID")) heroData.HeroID = (int)heroJd["HeroID"];
                                        if (heroJd.Keys.Contains("SkinID")) heroData.SkinID = (int)heroJd["SkinID"];
                                        if (heroJd.Keys.Contains("LV")) heroData.LV = (int)heroJd["LV"];
                                        if (heroJd.Keys.Contains("Star")) heroData.Star = (int)heroJd["Star"];
                                        if (heroJd.Keys.Contains("FightPower")) heroData.FightPower = long.Parse(heroJd["FightPower"].ToString());
                                        // 解析Data字段（武将物品UserData）
                                        if (heroJd.Keys.Contains("Data") && !string.IsNullOrEmpty((string)heroJd["Data"]))
                                        {
                                            heroData.Data = ConfigParse.Analysis((string)heroJd["Data"]);
                                        }

                                        // 解析技能列表 List<int>
                                        if (heroJd.Keys.Contains("SkillIDList"))
                                        {
                                            JsonData skills = heroJd["SkillIDList"];
                                            for (int i = 0; i < skills.Count; i++)
                                            {
                                                heroData.SkillIDList.Add((int)skills[i]);
                                            }
                                        }
                                        heroData.AttrDict = ParseAttrDict(heroJd, "AttrDict");
                                        lineupData.HeroDic[heroPos] = heroData;
                                    }
                                }
                            }
                            LineupDic[lineupId] = lineupData;
                        }
                    }
                }
                //BatPreset - {"战斗预设类型":{"预设类型":使用的方案ID, ...}, ...}      
                if (jd.Keys.Contains("BatPreset"))
                {
                    JsonData batPresetJson = jd["BatPreset"];
                    BatPresetDic = new Dictionary<int, Dictionary<int, int>>();
                    foreach (string outerKey in batPresetJson.Keys)
                    {
                        if (int.TryParse(outerKey, out int outerKeyInt))
                        {
                            JsonData innerJson = batPresetJson[outerKey];
                            var innerDict = new Dictionary<int, int>();
                            foreach (string innerKey in innerJson.Keys)
                            {
                                if (int.TryParse(innerKey, out int innerKeyInt))
                                {
                                    innerDict[innerKeyInt] = int.Parse(innerJson[innerKey].ToString());
                                }
                            }
                            BatPresetDic[outerKeyInt] = innerDict;
                        }
                    }

                }

            }
            catch (Exception e)
            {
                Debug.LogError("AnalysisRolePlusData Error: " + e.Message + "\nJSON: " + jsonStr);
            }
        }

    }
    #endregion


}