using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using asap.core;
using cfg;
using game;
using LitJson;
using Newtonsoft.Json;
using UnityEngine;
using static EventPartnerData;

namespace GameCore
{
    public class ChangeSmallGameTargetEvent
    {
        public OpponentItemData opponentItemData;
        public System.Threading.Tasks.TaskCompletionSource<bool> ts;
        public bool random;
    }
    public class SmallGameData
    {
        private cfg.Tables _tables;
        IUserService userService;
        ICustomServerMgr customServerMgr;
        public SmallGameData(cfg.Tables tables, IUserService userService, ICustomServerMgr customServerMgr)
        {
            this._tables = tables;
            this.userService = userService;
            this.customServerMgr = customServerMgr;
            BottleCashParamBase = _tables.TbGlobalConfig.BottleCashParamBase;
            BottleCashParamDiv = _tables.TbGlobalConfig.BottleCashParamDiv;
            BottleCashParamLevel = _tables.TbGlobalConfig.BottleCashParamLevel;
        }
        public void Init()
        {
            campData = GContext.container.Resolve<CampDataMM>();

            LoginRandomOpponent();
        }
        CampDataMM campData;
    
        int _heistGameCount = 0;
        int _bombGameCount = 0;
        int _fishHuntGameCount = 0;
        public int HeistGameCount => _heistGameCount;
        public int FishHuntGameCount => _fishHuntGameCount;
        public int BombGameCount => _bombGameCount;

        public int AlbumEventID;
        //public UnityEngine.Vector3 image_extra_pos { set; get; }
               
        public void SetHeistGameCount(int value)
        {
            _heistGameCount = value;
        }
        public void SaveHeistGameCount()
        {
            _heistGameCount++;
            PlayFabMgr.Instance.UpdateUserDataValue("HeistGameCount", _heistGameCount.ToString());
        }
        public void SetBombGameCount(int value)
        {
            _bombGameCount = value;
        }
        public void SaveBombGameCount()
        {
            _bombGameCount++;
            PlayFabMgr.Instance.UpdateUserDataValue("BombGameCount", _bombGameCount.ToString());
        }
        public void SetFishHuntGameCount(int value)
        {
            _fishHuntGameCount = value;
        }
        public void SaveFishHuntGameCount()
        {
            _fishHuntGameCount++;
            PlayFabMgr.Instance.UpdateUserDataValue("FishHuntGameCount", _fishHuntGameCount.ToString());
        }
        #region 小游戏仇人
        public List<OpponentItemData> opponentItemDatas = new List<OpponentItemData>();
        public List<OpponentItemData> opponentFriendItemDatas = new List<OpponentItemData>();
        public List<OpponentItemData> opponentNotFriendItemDatas = new List<OpponentItemData>();
        public List<OpponentItemData> opponentFriend = new List<OpponentItemData>();
        Dictionary<string, OpponentItemData> opponentFriendDic = new Dictionary<string, OpponentItemData>();
        public Dictionary<EnemyType, List<OpponentItemData>> opponentEnemy = new Dictionary<EnemyType, List<OpponentItemData>>();
        List<OpponentItemData> opponentItemDatasPre = new List<OpponentItemData>();
        List<OpponentItemData> opponentFriendItemDatasPre = new List<OpponentItemData>();
        List<OpponentItemData> opponentNotFriendItemDatasPre = new List<OpponentItemData>();
        EnemyType curEnemyType = EnemyType.Aquarium;
        public Dictionary<string, float> powerData;
        public OpponentItemData opponentData;
        OpponentItemData nextOpponent;
        int GMbobmName = 0;
        int BottleCashParamBase;
        int BottleCashParamDiv;
        int BottleCashParamLevel;
        public int RobotMapId;
        public int nextRobotMapId;
        public void GMSetBomb(string bobmName)
        {
            GMbobmName = int.Parse(bobmName);
        }

        public async void LoginRandomOpponent()
        {
            GetRobotData();
            RandomOpponent();
            await LoadData();
            RandomOpponent();
        }

        void RandomOpponent()
        {
            Synchrodata();
            nextOpponent = NextOpponent();
            LoadNextOpponentResource();
        }

        public List<OpponentItemData> GetOpponentEnemy()
        {
            return opponentEnemy.GetValueOrDefault(curEnemyType);
        }

        public OpponentItemData GetBankHeistOpponent(EnemyType enemyType)
        {
            this.curEnemyType = enemyType;
            if (opponentItemDatasPre == null || opponentItemDatasPre.Count == 0)
            {
                ClearOpponent();
                GetFriendData();
                GetRobotData();
            }
            opponentData = RandomItem();
            LoadData();
            GetEnemyData(curEnemyType);
            if (GMbobmName > 0)
            {
                opponentData.BombID = GMbobmName;
            }
            return opponentData;
        }

        void Synchrodata()
        {
            if (opponentItemDatasPre != null && opponentItemDatasPre.Count > 0)
            {
                opponentItemDatas = opponentItemDatasPre;
            }
            if (opponentFriendItemDatasPre != null && opponentFriendItemDatasPre.Count > 0)
            {
                opponentFriendItemDatas = opponentFriendItemDatasPre;
            }
            if (opponentNotFriendItemDatasPre != null && opponentNotFriendItemDatasPre.Count > 0)
            {
                opponentNotFriendItemDatas = opponentNotFriendItemDatasPre;
            }
        }
        public OpponentItemData RandomItem()
        {
            OpponentItemData target = nextOpponent;
            Synchrodata();
            nextOpponent = NextOpponent();
            RobotMapId = nextRobotMapId;
            LoadNextOpponentResource();
            return target;
        }

        async void LoadNextOpponentResource()
        {
            if (nextOpponent != null)
            {
                ILoadResourceService loadResourceService = GContext.container.Resolve<ILoadResourceService>();
                RobotSetMap();
                int mapId;
                if (nextOpponent.isRobot)
                {
                    mapId = nextRobotMapId;
                }
                else
                {
                    mapId = await LoadAquariumResource(nextOpponent.playFabID);
                    if (mapId > 0)
                    {
                        nextRobotMapId = mapId;
                    }
                    else
                    {
                        mapId = nextRobotMapId;
                    }
                }
                Debug.Log($"nextOpponent Next MapID {mapId}");

                if (mapId > 0)
                {
                    MapDownloadRes mapData = _tables.TbMapDownloadRes.GetOrDefault(mapId);
                    if (mapData != null)
                    {
                        loadResourceService.Load(mapData.FishRes);
                    }
                }

                string bombPrefab = _tables.TbConstruction.GetOrDefault(nextOpponent.BombID)?.BombPrefab;
                if (!string.IsNullOrEmpty(bombPrefab))
                {
                    loadResourceService.Load(new List<string>() { bombPrefab });
                }
            }

        }

        void RobotSetMap()
        {
            int curMapId = nextRobotMapId;

            var mapDatas = _tables.TbMapData.DataList;
            var maxMapID = GContext.container.Resolve<PlayerData>().lastMapId;

            //非当前地图
            var mapIDs = new List<int>();
            for (int i = 0; i < mapDatas.Count; i++)
            {
                if (mapDatas[i].ID <= maxMapID)
                {
                    if (mapDatas[i].ID != curMapId)
                    {
                        mapIDs.Add(mapDatas[i].ID);
                    }
                }
                else
                {
                    break;
                }
            }
            if (mapIDs.Count == 0)
            {
                nextRobotMapId = maxMapID;
            }
            else
            {
                nextRobotMapId = mapIDs[UnityEngine.Random.Range(0, mapIDs.Count)];
            }
        }

        async Task<int> LoadAquariumResource(string playFabId)
        {
            GetAquariumDataRequest request = new GetAquariumDataRequest();
            request.playFabId = playFabId;
            string result = await customServerMgr.CustomServerPost("aquarium/GetAquariumData", Newtonsoft.Json.JsonConvert.SerializeObject(request));
            if (result != null)
            {
                var resp = JsonConvert.DeserializeObject<GetAquariumDataResp>(result);
                if (resp.code == 0)
                {
                    var data = resp.data;
                    List<AquariumSlotData> slotDatas = data.slotDatas;
                    if (slotDatas == null)
                    {
                        return 0;
                    }

                    var time = ZZTimeHelper.UtcNow();
                    List<AquariumResultData> aquariumResultDatas = data.aquariumResultDatas;
                    for (int i = 0; i < slotDatas.Count; i++)
                    {
                        AquariumSlotData slotData = slotDatas[i];
                        slotData.index = i;
                        var HatchTime = slotData.FishHatchTime();

                        if (HatchTime < time)
                        {
                            if (!slotData.IsResult() && aquariumResultDatas.Count > i && !aquariumResultDatas[i].IsResult())
                            {
                                return resp.data.mapId;
                            }
                        }
                    }
                }
            }
            return 0;
        }
        public OpponentItemData NextOpponent()
        {
            int friendW = Math.Min(100, opponentFriendItemDatas.Count * 20);
            if (opponentFriendItemDatas.Count == 0)
            {
                friendW = 0;
            }
            int noFriendW = 70;
            if (opponentNotFriendItemDatas.Count == 0)
            {
                noFriendW = 0;
            }
            int robotW = 30;
            int allW = friendW + noFriendW + robotW;
            int w = UnityEngine.Random.Range(0, allW);
            OpponentItemData target;
            if (friendW > 0 && opponentFriendItemDatas.Count > 0 && w < friendW)
            {
                target = opponentFriendItemDatas[UnityEngine.Random.Range(0, opponentFriendItemDatas.Count)];
                target.target_group = 1;
            }
            else if (noFriendW > 0 && opponentNotFriendItemDatas.Count > 0 && w < friendW + noFriendW)
            {
                target = opponentNotFriendItemDatas[UnityEngine.Random.Range(0, opponentNotFriendItemDatas.Count)];
                target.target_group = 2;
            }
            else
            {
                if (opponentItemDatas == null || opponentItemDatas.Count == 0)
                {
                    GetRobotData();
                    opponentItemDatas = opponentItemDatasPre;
                    Debug.LogError("opponentItemDatas Count == 0");
                }
                target = opponentItemDatas[UnityEngine.Random.Range(0, opponentItemDatas.Count)];
                target.target_group = 3;
            }
            return target;
        }

        void ClearOpponent()
        {
            Synchrodata();
            opponentFriendItemDatasPre = new List<OpponentItemData>();
            opponentNotFriendItemDatasPre = new List<OpponentItemData>();
            opponentItemDatasPre = new List<OpponentItemData>();
            powerData = new Dictionary<string, float>();
            opponentFriend = new List<OpponentItemData>();
            opponentFriendDic = new Dictionary<string, OpponentItemData>();
        }
        public async Task LoadData()
        {
            ClearOpponent();
            GetFriendData();
            try
            {
                await GetActiveNotFriendData();
                await GetLeaderboardData(curEnemyType);
            }
            catch (Exception ex)
            {
                Debug.LogError(ex.Message);
            }
            GetRobotData();
        }

        async Task GetActiveNotFriendData()
        {
            var request = new EventBuildRecommendPlayerRequest();
            int lv = GContext.container.Resolve<PlayerData>().lv;
            int minLevel = (int)(lv * 0.5f);
            if (minLevel < 0)
            {
                minLevel = 0;
            }
            request.MinLevel = minLevel;
            request.MaxLevel = lv * 2;
            request.Exclude = new List<string>();

            string json = await customServerMgr.CustomServerPost($"eventpartner/recommend",
            Newtonsoft.Json.JsonConvert.SerializeObject(request));
            if (!string.IsNullOrEmpty(json) && json != "[]")
            {
                EventBuildRecommendPlayerResp resp = Newtonsoft.Json.JsonConvert.DeserializeObject<EventBuildRecommendPlayerResp>(json);
                if (resp.State == EEventBuildState.Success && resp.Players != null)
                {
                    List<Construction> _dataList = _tables.TbConstruction.DataList;
                    for (int i = 0; i < resp.Players.Count; i++)
                    {
                        if (resp.Players[i].PlayFabId == userService.UserId)
                        {
                            continue;
                        }
                        OpponentItemData opponentItemData = new OpponentItemData();
                        opponentItemData.playFabID = resp.Players[i].PlayFabId;
                        opponentItemData.target_source = 2;

                        userService.SetPlayInfo(resp.Players[i].PlayFabId, resp.Players[i].DisplayName, resp.Players[i].AvatarUrl);
                        userService.SetPlayerLv(resp.Players[i].PlayFabId, resp.Players[i].Level);
                        int level = resp.Players[i].Level;
                        int id = _dataList[0].ID;
                        for (int j = _dataList.Count - 1; j >= 0; j--)
                        {
                            if (_dataList[j].InitialLevel <= level)
                            {
                                id = _dataList[j].ID;
                                break;
                            }
                        }
                        opponentItemData.BombID = id;
                        opponentItemData.power = (float)Math.Log10(BottleCashParamBase + level / BottleCashParamLevel) / BottleCashParamDiv;
                        powerData[opponentItemData.playFabID] = opponentItemData.power;
                        //opponentItemDatasPre.Add(opponentItemData);
                        opponentNotFriendItemDatasPre.Add(opponentItemData);
                    }
                }
            }
        }
        void GetFriendData()
        {
            var FriendList = GContext.container.Resolve<FriendService>().FriendList;
            opponentFriendItemDatasPre.Clear();
            DateTime dateTime = ZZTimeHelper.UtcNow().Date.AddDays(-1);
            if (FriendList != null && FriendList.Count > 0)
            {
                List<Construction> _dataList = _tables.TbConstruction.DataList;
                for (int i = 0; i < FriendList.Count; i++)
                {
                    if (FriendList[i].playFabId == userService.UserId)
                    {
                        continue;
                    }
                    OpponentItemData opponentItemData = new OpponentItemData();
                    opponentItemData.playFabID = FriendList[i].playFabId;
                    opponentItemData.target_source = 1;

                    //if (FriendList[i].LastLogin != null && FriendList[i].LastLogin > dateTime)
                    //{
                    opponentFriendItemDatasPre.Add(opponentItemData);
                    //}
                    int level = FriendList[i].value / LeadboardData.LV_MODELING;
                    int id = _dataList[0].ID;
                    for (int j = _dataList.Count - 1; j >= 0; j--)
                    {
                        if (_dataList[j].InitialLevel <= level)
                        {
                            id = _dataList[j].ID;
                            break;
                        }
                    }
                    opponentItemData.BombID = id;
                    opponentItemData.power = (float)Math.Log10(BottleCashParamBase + level / BottleCashParamLevel) / BottleCashParamDiv;
                    powerData[opponentItemData.playFabID] = opponentItemData.power;
                    //opponentItemDatasPre.Add(opponentItemData);
                    opponentFriend.Add(opponentItemData);
                    opponentFriendDic[opponentItemData.playFabID] = opponentItemData;
                }
            }
        }

        public async void SetEnemy(EnemyType enemyType, long glod)
        {
            if (!opponentData.isRobot)
            {
                SetEnemyIDRequest setEnemyCampIDRequest = new SetEnemyIDRequest()
                {
                    enemyType = enemyType,
                    playerID = userService.UserId,
                    albumEventID = AlbumEventID,
                    enemyID = opponentData.playFabID,
                    content = glod.ToString()
                };
                var customServerMgr = GContext.container.Resolve<ICustomServerMgr>();
                string json = await customServerMgr.BombRequest("SetEnemyID", setEnemyCampIDRequest);
                if (!string.IsNullOrEmpty(json) && json != "[]")
                {
                    SetEnemyIDResponse setCampIDResponse = Newtonsoft.Json.JsonConvert.DeserializeObject<SetEnemyIDResponse>(json);
                }
            }
        }
        //向服务器请求仇人列表
        async Task GetEnemyData(EnemyType enemyType)
        {
            GetEnemyIDRequest getEnemyCampIDRequest = new GetEnemyIDRequest()
            {
                playerID = userService.UserId,
                enemyType = enemyType,
                albumEventID = AlbumEventID,
            };
            var customServerMgr = GContext.container.Resolve<ICustomServerMgr>();
            string json = await customServerMgr.BombRequest("GetEnemyID", getEnemyCampIDRequest);
            if (!string.IsNullOrEmpty(json) && json != "[]")
            {
                GetEnemyIDResponse getCampIDResponse = Newtonsoft.Json.JsonConvert.DeserializeObject<GetEnemyIDResponse>(json);
                if (getCampIDResponse.enemyIDs == null)
                {
                    return;
                }
                List<EventPopupData> eventPopupDatas = GContext.container.Resolve<ClubService>().eventPopupDatas;
                //DateTime dateTime = ZZTimeHelper.UtcNow().UtcNowOffset();
                //EventPopupData eventPopupData;
                int count;
                ReportDataType reportDataType = ReportDataType.Bomb;
                switch (enemyType)
                {
                    case EnemyType.Bomb:
                        reportDataType = ReportDataType.Bomb;
                        break;
                    case EnemyType.Heist:
                        reportDataType = ReportDataType.Heist;
                        break;
                    case EnemyType.Aquarium:
                        reportDataType = ReportDataType.Aquarium;
                        break;
                }
                List<OpponentItemData> opponentItemDatas = new List<OpponentItemData>();
                opponentEnemy[enemyType] = opponentItemDatas;
                eventPopupDatas = eventPopupDatas.Where(x => (int)(x.type) == (int)reportDataType).ToList();
                for (int i = 0; i < getCampIDResponse.enemyIDs.Count; i++)
                {
                    if (getCampIDResponse.enemyIDs[i] == userService.UserId)
                    {
                        continue;
                    }

                    OpponentItemData opponentItemData = new OpponentItemData();
                    opponentItemData.playFabID = getCampIDResponse.enemyIDs[i];


                    //if (string.IsNullOrEmpty(getCampIDResponse.avatar[i]) && string.IsNullOrEmpty(getCampIDResponse.displayName[i]))
                    //{
                    //    userService.GetPlayInfo(opponentItemData.playFabID);
                    //}
                    //else
                    //{
                    //    userService.SetPlayInfo(opponentItemData.playFabID, getCampIDResponse.displayName[i], getCampIDResponse.avatar[i]);
                    //}

                    if (getCampIDResponse.enemyType == EnemyType.Bomb)
                    {
                        opponentItemData.BombID = getCampIDResponse.campID[i];
                    }

                    if (powerData.ContainsKey(opponentItemData.playFabID))
                    {
                        opponentItemData.power = powerData[opponentItemData.playFabID];
                    }
                    else
                    {
                        opponentItemData.power = 1;
                    }
                    count = eventPopupDatas.Where(x => x.playerID == opponentItemData.playFabID).Count();
                    if (reportDataType == ReportDataType.Aquarium)
                    {
                        if (count > 1)
                        {
                            opponentItemData.info = LocalizationMgr.GetFormatTextValue("UI_EventBankHeistOpponentPopupPanel_3", count);
                        }
                        else
                        {
                            opponentItemData.info = LocalizationMgr.GetFormatTextValue("UI_EventBankHeistOpponentPopupPanel_5", 1);
                        }
                    }
                    else
                    {
                        if (count > 1)
                        {
                            opponentItemData.info = LocalizationMgr.GetFormatTextValue("UI_EventBankHeistOpponentPopupPanel_6", count);
                        }
                        else
                        {
                            opponentItemData.info = LocalizationMgr.GetFormatTextValue("UI_EventBankHeistOpponentPopupPanel_7", 1);
                        }
                    }
                    if (opponentFriendDic.TryGetValue(opponentItemData.playFabID, out OpponentItemData friendData))
                    {
                        friendData.info = opponentItemData.info;
                    }
                    opponentItemData.target_source = 4;

                    opponentItemDatas.Add(opponentItemData);
                    //opponentNotFriendItemDatasPre.Add(opponentItemData);
                }
            }
        }
        void GetRobotData()
        {
            int count = opponentItemDatasPre.Count;
            int allCount = 20;
            if (count >= 20)
            {
                allCount = count + 1;
            }
            var robots = new List<cfg.Robot>(_tables.TbRobot.DataList);
            cfg.Robot robot;
            int myID = campData.Id;
            cfg.TbConstruction tbConstruction = _tables.TbConstruction;
            int constructionFirstId = tbConstruction.DataList[0].ID % 1000;
            int constructionLastId = tbConstruction.DataList[^1].ID;
            int campId;
            for (int i = count; i < allCount; i++)
            {
                robot = robots[UnityEngine.Random.Range(0, robots.Count)];
                robots.Remove(robot);
                OpponentItemData opponentItemData = new OpponentItemData();
                opponentItemData.playFabID = robot.ID.ToString("X");
                opponentItemData.target_source = -1;
                userService.SetPlayInfo(opponentItemData.playFabID, LocalizationMgr.GetText(robot.Name_l10n_key), robot.Avatar);
                //opponentItemData.playName = robot.Name;
                //opponentItemData.url = robot.Avatar;
                opponentItemData.isRobot = true;

                campId = robot.ConstructionOffset + myID;
                if (campId < constructionFirstId)
                {
                    campId = constructionFirstId;
                }
                if (campId > constructionLastId)
                {
                    campId = constructionLastId;
                }
                opponentItemData.BombID = campId;
                opponentItemData.power = (float)Math.Log10(BottleCashParamBase - i) / BottleCashParamDiv;
                opponentItemDatasPre.Add(opponentItemData);
            }
        }
        async Task GetLeaderboardData(EnemyType enemyType)
        {
            FishingEventData _fishingEventData = GContext.container.Resolve<FishingEventData>();
            if (!_fishingEventData.IsOpenRank())
            {
                return;
            }
            LeadboardData leadboardData = GContext.container.Resolve<LeadboardData>();
            if (leadboardData.curEventRank == null)
            {
                return;
            }
            Dictionary<int, cfg.Robot> robots = GContext.container.Resolve<cfg.Tables>().TbRobot.DataMap;
            GetLeaderboardsResp curEventRank = leadboardData.curEventRank;
            int myID = campData.Id;
            cfg.TbConstruction tbConstruction = _tables.TbConstruction;
            int constructionFirstId = tbConstruction.DataList[0].ID % 1000;
            int constructionLastId = tbConstruction.DataList[^1].ID;
            int campId = myID;
            Dictionary<string, OpponentItemData> playerList = new Dictionary<string, OpponentItemData>();
            for (int i = 0; i < curEventRank.data.Length; i++)
            {
                if (curEventRank.data[i].isMe || curEventRank.data[i].id == userService.UserId)
                {
                    continue;
                }

                if (curEventRank.data[i].id == null || powerData.ContainsKey(curEventRank.data[i].id))
                {
                    continue;
                }

                OpponentItemData opponentItemData = new OpponentItemData();
                opponentItemData.playFabID = curEventRank.data[i].id;
                if (curEventRank.data[i].isBot)
                {
                    int b = Convert.ToInt32(opponentItemData.playFabID, 16);
                    if (robots.TryGetValue(b, out cfg.Robot robot))
                    {
                        campId = robot.ConstructionOffset + myID;
                    }
                    if (campId < constructionFirstId)
                    {
                        campId = constructionFirstId;
                    }
                    if (campId > constructionLastId)
                    {
                        campId = constructionLastId;
                    }
                    opponentItemData.isRobot = true;
                    opponentItemData.target_source = -1;
                    opponentItemDatasPre.Add(opponentItemData);
                }
                else
                {
                    playerList[opponentItemData.playFabID] = opponentItemData;
                    opponentItemData.target_source = 3;
                    userService.GetPlayInfo(opponentItemData.playFabID);
                    opponentNotFriendItemDatasPre.Add(opponentItemData);
                }
                opponentItemData.BombID = campId;
                opponentItemData.power = (float)Math.Log10(BottleCashParamBase - curEventRank.data[i].rank) / BottleCashParamDiv;
                powerData[opponentItemData.playFabID] = opponentItemData.power;
            }
            if (playerList.Count > 0 && enemyType == EnemyType.Bomb)
            {
                await GetCampID(playerList);
            }
        }
        async Task GetCampID(Dictionary<string, OpponentItemData> playerList)
        {
            List<string> playFabIds = playerList.Values.Select(x => x.playFabID).ToList();

            GetCampIDRequest getCampIDRequest = new GetCampIDRequest()
            {
                playerIDs = playFabIds
            };
            var customServerMgr = GContext.container.Resolve<ICustomServerMgr>();
            string json = await customServerMgr.BombRequest("GetCampID", getCampIDRequest);
            if (!string.IsNullOrEmpty(json) && json != "[]")
            {
                GetCampIDResponse getCampIDResponse = Newtonsoft.Json.JsonConvert.DeserializeObject<GetCampIDResponse>(json);
                if (getCampIDResponse != null && getCampIDResponse.campIDs != null && getCampIDResponse.campIDs.Count > 0)
                {
                    foreach (var item in getCampIDResponse.campIDs)
                    {
                        playerList[item.Key].BombID = item.Value;
                    }
                }
            }
        }
        #endregion       
    }
}