using asap.core;
using asap.playfab.async;
using game;
using PlayFab.ClientModels;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using tysdk;

namespace GameCore
{
    public enum ELeaderboardState : byte
    {
        Success = 0,
        Failed = 1,
        Delay = 2
    }

    public class GetLeaderboardsRequest
    {
        public string playerId { get; set; }
        public bool includeOther { get; set; }
        public int? Score { get; set; }
    }

    /// <summary>
    /// Leaderboard Model
    /// </summary>
    public class GetLeaderboardsResp
    {
        public ELeaderboardState state { get; set; }
        /// <summary>
        /// Event Id from table
        /// </summary>
        public int eventId { get; set; }

        /// <summary>
        /// Level of Leaderboard eg. T0 T1 T2
        /// </summary>
        public int rankLevel { get; set; }
        ///
        /// <summary>
        /// Max players of this leaderboard
        /// </summary>
        public int capacity { get; set; }
        /// <summary>
        /// Num of current member in this leaderboard (Players + Bots)
        /// </summary>
        //public int Count => data?.Length ?? 0;

        /// <summary>
        /// Avaliable Rank Datas
        /// </summary>
        public RankData[] data { get; set; }
    }

    public class UpdateScoreRequest
    {
        public string playerId { get; set; }
        public float Score { get; set; }
    }

    public class UpdateScoreResp
    {
        public ELeaderboardState state { get; set; }
        public int rank { get; set; }
        public int preRank { get; set; }
        public double score { get; set; }
        public double preScore { get; set; }
    }

    public class GetRewardsRequest
    {
        public string playerId { get; set; }
    }

    public class GetRewardsResp
    {
        public bool success { get; set; }
        public List<RewardData> rewardDatas { get; set; }
    }

    //public class ManualUpdateRequest
    //{
    //    public int eventId { get; set; }
    //}

    public class RewardData
    {
        public int rankLevel { get; set; }
        public int dropId { get; set; }
        public int eventId { get; set; }
        public RankData[] ranks { get; set; }
    }

    public class RankData
    {
        /// <summary>
        /// Player PlayFab ID
        /// </summary>
        public string id { get; set; }

        /// <summary>
        /// Leaderboard ranking
        /// </summary>
        public int rank { get; set; }

        /// <summary>
        /// leaderboard score
        /// </summary>
        public float score { get; set; }

        /// <summary>
        /// Is this player myself
        /// </summary>
        public bool isMe { get; set; }

        public bool isBot { get; set; }

        public string displayName { get; set; }
        public string avatarUrl { get; set; }
    }
    public class EventRankData
    {

    }
    public class PFRankDataEvent
    {
        public bool isLocal;
    }
    public class LeadboardData
    {
        [Inject]
        public IUserService userService { get; set; }
        [Inject]
        public ICustomServerMgr customServerMgr { get; set; }

        public static int LV_MODELING = 100000;
        //public const string leadboardLevelName = "Level";
        public const string leadboardLevelName = "LevelB";
        const int RefreshSeconds = 300;
        bool isRefreshing = false;
        public List<LeadboardItemData> LeadboardDataList = new List<LeadboardItemData>();
        public List<LeadboardItemData> LeadboardContinentDataList = new List<LeadboardItemData>();
        public GetLeaderboardsResp curEventRank;

        public RewardData eventRankReward;
        public cfg.RankInit lastEventRank;
        public cfg.FishingEvent fishingEvent;
        public cfg.RankTargets rankTarget;
        public int lastScore;
        public int lastAllScore;
        int MeRank = 0;
        public bool IsOpenleaderboard;
        public async Task SetLeadboardData(List<string> names, List<int> value)
        {
            List<StatisticUpdate> Statistics = new List<StatisticUpdate>();
            for (int i = 0; i < names.Count; i++)
            {
                Statistics.Add(new StatisticUpdate() { StatisticName = names[i], Value = value[i] });
            }
            UpdatePlayerStatisticsRequest request = new UpdatePlayerStatisticsRequest()
            {
                Statistics = Statistics,
            };
            await PlayFabClientAsyncAPI.UpdatePlayerStatisticsAsync(request);
        }
        public async Task<GetLeaderboardResult> GetLeadboardData(string leaderboardNaem, int maxCount = 50)
        {
            GetLeaderboardRequest reques = new GetLeaderboardRequest()
            {
                StartPosition = 0,
                MaxResultsCount = maxCount,
                StatisticName = leaderboardNaem,
                ProfileConstraints = new PlayerProfileViewConstraints()
                {
                    ShowAvatarUrl = true,
                    ShowLocations = true,
                    ShowDisplayName = true,
                }

            };
            return await PlayFabClientAsyncAPI.GetLeaderboardAsync(reques);
        }
        public async void SetLvData()
        {
            isRefreshing = true;
            string localName = GContext.container.Resolve<IUserService>().ContinentCode + leadboardLevelName;
            string InfiniteBuildingLevel = GContext.container.Resolve<PlayerData>().InfiniteBuildingLevel;
            int.TryParse(InfiniteBuildingLevel, out int InfiniteBuildingLevelInt);
            int level = GContext.container.Resolve<PlayerData>().lv * LV_MODELING + InfiniteBuildingLevelInt;
            await SetLeadboardData(new List<string> { leadboardLevelName, localName }, new List<int> { level, level });
            isRefreshing = false;
        }

        public async void AwaitSetLvData()
        {
            if (isRefreshing)
            {
                return;
            }
            isRefreshing = true;
            await Awaiters.Seconds(RefreshSeconds);
            SetLvData();
        }

        public async void GetLevelLeadboardData(bool islocal = false,/* bool save = false,*/ string name = leadboardLevelName)
        {
            if (islocal)
            {
                name = GContext.container.Resolve<IUserService>().ContinentCode + leadboardLevelName;
            }

            var result = await GetLeadboardData(name);
            if (result != null)
            {
                List<LeadboardItemData> curList = new List<LeadboardItemData>();
                var Leaderboard = result.Leaderboard;
                if (Leaderboard.Count > 0)
                {
                    for (int i = 0; i < Leaderboard.Count; i++)
                    {
                        LeadboardItemData item = new LeadboardItemData();
                        if (string.IsNullOrEmpty(Leaderboard[i].Profile.DisplayName))
                        {
                            Leaderboard[i].Profile.DisplayName = userService.GetDefaultName(Leaderboard[i].PlayFabId);
                        }
                        item.SetData(Leaderboard[i]);
                        userService.SetPlayInfo(Leaderboard[i].PlayFabId, Leaderboard[i].Profile.DisplayName, Leaderboard[i].Profile.AvatarUrl);
                        curList.Add(item);
                    }
                    if (islocal)
                    {
                        LeadboardContinentDataList = curList;
                    }
                    else
                    {
                        LeadboardDataList = curList;
                    }
                    GContext.Publish(new PFRankDataEvent() { isLocal = islocal });
                }
            }
        }
        #region EventLeaderboard

        public async Task<bool> GetLeaderboard(int Score = 0)
        {
            GetLeaderboardsResp getLeaderboardsResp = null;
            GetLeaderboardsRequest getLeaderboardRequest = new GetLeaderboardsRequest()
            {
                playerId = userService.UserId,
                includeOther = true,
                Score = Score
            };
            string json = await customServerMgr.EventRequest("GetLeaderboards", getLeaderboardRequest);
            if (!string.IsNullOrEmpty(json) && json != "[]")
            {
                getLeaderboardsResp = Newtonsoft.Json.JsonConvert.DeserializeObject<GetLeaderboardsResp>(json);
            }
            if (getLeaderboardsResp != null && getLeaderboardsResp.state == ELeaderboardState.Success)
            {
                curEventRank = getLeaderboardsResp;
                GetRankPlayInfo(curEventRank.data);
            }
            else if (curEventRank == null || curEventRank.data == null)
            {
                curEventRank = new GetLeaderboardsResp();
            }

            if (curEventRank.data == null)
            {
                curEventRank.data = new RankData[] { new RankData { id = userService.UserId, isMe = true, rank = 1 } };
                MeRank = 0;
            }
            else
            {
                if (curEventRank.data.Length > 1)
                {
                    for (int i = 0; i < curEventRank.data.Length; i++)
                    {
                        if (curEventRank.data[i].isMe)
                        {
                            MeRank = curEventRank.data[i].rank;
                        }
                    }
                }
                else
                {
                    MeRank = 0;
                }
            }
            GContext.Publish(new EventRankData());
            return curEventRank != null;
        }
        public int GetMeRank()
        {
            return MeRank;
        }
        public List<ItemData> rankItemDatas { set; get; }
        public static string NextQueueKey = "EventRankNextQueueKey";
        public async Task GetRewards()
        {
            if (lastEventRank != null && rankItemDatas == null)
            {
                int dropId = 0;
                GetRewardsRequest request = new GetRewardsRequest { playerId = userService.UserId };
                string json = await customServerMgr.EventRequest("GetRewards", request);

                GetRewardsResp response = null;
                if (!string.IsNullOrEmpty(json) && json != "[]")
                {
                    response = Newtonsoft.Json.JsonConvert.DeserializeObject<GetRewardsResp>(json);
                }
                if (response != null && response.success && response.rewardDatas != null && response.rewardDatas.Count > 0)
                {
                    dropId = response.rewardDatas[0].dropId;
                    eventRankReward = response.rewardDatas[0];
                    RankData[] ranks = response.rewardDatas[0].ranks;
                    GetRankPlayInfo(ranks);
                    RankData rankData = ranks.Where(x => x.isMe).FirstOrDefault();
                    float score = rankData.score;
                    var _tables = GContext.container.Resolve<cfg.Tables>();
                    var fishingEvent1 = _tables.TbFishingEvent.GetOrDefault(response.rewardDatas[0].eventId);
                    if (fishingEvent1 != null)
                    {
                        fishingEvent = fishingEvent1;
                    }
                    var lastEventRank1 = _tables.TbRankInit.GetOrDefault(fishingEvent.RedirectID);
                    if (lastEventRank1 != null)
                    {
                        lastEventRank = lastEventRank1;
                    }
                    if (lastEventRank.UnlockPoint > score)
                    {
                        return;
                    }
                    rankTarget = _tables.TbRankTargets.GetOrDefault(lastEventRank.TargetList[0]);
                    if (rankTarget != null)
                    {
                        lastAllScore = (int)score;
                        lastScore = lastAllScore;
                        while (rankTarget != null && rankTarget.NextTarget > 0 && rankTarget.TokenRequired <= lastScore)
                        {
                            lastScore -= rankTarget.TokenRequired;
                            rankTarget = _tables.TbRankTargets.GetOrDefault(rankTarget.NextTarget);
                        }
                    }

                    if (dropId > 0)
                    {
                        var fishingStage = GContext.container.ResolveStage("FishingStage") as FishingStage;
                        if (fishingStage != null)
                        {
                            fishingStage.IsNextQueue = true;
                            fishingStage.NextQueueKey = NextQueueKey;
                        }
                        rankItemDatas = GContext.container.Resolve<PlayerItemData>().AddItemByDrop(dropId, true);
                        if (fishingStage != null)
                        {
                            fishingStage.IsNextQueue = false;
                            fishingStage.NextQueueKey = string.Empty;
                        }
#if AGG
                        using (var e = GEvent.GameEvent("last_ranking"))
                        {
                            int playerCount = ranks.Where(x => !x.isBot).Count();
                            int isBotCount = ranks.Length - playerCount;
                            e.AddContent("ranking_tier", response.rewardDatas[0].rankLevel)
                             .AddContent("ranking_points", lastAllScore)
                             .AddContent("get_reward_user", playerCount)
                             .AddContent("get_reward_robot", isBotCount)
                             .AddContent("rank", rankData.rank)
                            .AddContent("dropId", dropId);
                            if (rankItemDatas != null)
                            {
                                for (int i = 0; i < rankItemDatas.Count; i++)
                                {
                                    if (rankItemDatas[i].id == 1001)
                                    {
                                        e.AddContent("reward_hook", rankItemDatas[i].count);
                                    }
                                    else if (rankItemDatas[i].id == 1002)
                                    {
                                        e.AddContent("reward_cash", rankItemDatas[i].count);
                                    }
                                }
                            }
                        }
#endif
                        GContext.container.Resolve<IFaceUIService>().AddFaceUIData(fishingEvent.FaceID, fishingEvent.RedirectID, 2);
                    }
                }
            }
        }
        public async void UpdateScore(int score)
        {
            UpdateScoreResp data = null;
            UpdateScoreRequest request = new UpdateScoreRequest { playerId = userService.UserId, Score = score };
            string json = await customServerMgr.EventRequest("UpdateScore", request);
            if (!string.IsNullOrEmpty(json) && json != "[]")
            {
                data = Newtonsoft.Json.JsonConvert.DeserializeObject<UpdateScoreResp>(json);
            }
            if (data != null && data.state == ELeaderboardState.Success)
            {
                MeRank = data.rank;
                //更新主界面排名显示
            }
            else /*if (data.state == ELeaderboardState.Delay)*/
            {
                MeRank = 0;
                curEventRank = new GetLeaderboardsResp();
                curEventRank.data = new RankData[] { new RankData { isMe = true, rank = 1 } };
            }

            GContext.Publish(new EventRankData());
        }
        void GetRankPlayInfo(RankData[] RankDatas)
        {
            Dictionary<int, cfg.Robot> robots = GContext.container.Resolve<cfg.Tables>().TbRobot.DataMap;
            foreach (var item in RankDatas)
            {
                if (!item.isMe && !item.isBot)
                {
                    if (!string.IsNullOrEmpty(item.avatarUrl) || !string.IsNullOrEmpty(item.displayName))
                    {
                        userService.SetPlayInfo(item.id, item.displayName, item.avatarUrl);
                    }
                    else
                    {
                        userService.GetPlayInfo(item.id);
                    }
                }
                else if (item.isBot)
                {
                    int b = Convert.ToInt32(item.id, 16);
                    if (robots.TryGetValue(b, out cfg.Robot robot))
                    {
                        userService.SetPlayInfo(item.id, LocalizationMgr.GetText(robot.Name_l10n_key), robot.Avatar);
                    }
                }
            }

        }
        #endregion
    }
}