using asap.core;
using cfg;
using game;
using GameCore;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;

public class FishingChallengeData
{
    public bool FirstOpen;
    // 记录当前EventID
    public int EventId;
    // 已经通关轮数,完成之后更新,
    public int RankTierLevel;
    // 记录当前已经结算，防止改表的问题
    public int Finished;
    // 记录当前的表单号，获取争取的 EventData
    public int RedirectID;
    // 积分
    public int Score;
    // 未处理积分,进入场景后显示的积分增长
    public int ProcessedScore;
    // 当前的阶段,完成了的部分
    public int step; // 最多是7关 
    // 界面上显示 的部分
    public int uiStep;
    
    public int index;  // 根据权重判断的索引
    public DateTime StartTime;
    // 结束时间
    public DateTime EndTime;
    public List<int> eliminateNumber; //每个阶段的排除人数
    public List<int> robotAccountList; //机器人列表
}

public class FishingChallengeManager
{
    //
    private const string SaveKey = "FishingChallengeData";
    
    [Inject] public Tables _tables { get; set; }
    public string PrefabName { get; private set; }
    private int TopRankTier { get; set; }
    public int Rank { get; private set; }
    private FishingEvent CurFishingEventData { get; set; }
    public int  EventItemId => eventChallengeConfig?.Item ?? 0;
    
    public int FullStep;
    // 全部竞赛玩家数量
    public int PlayerFullNumber;
    // Btn 上显示用
    public int PreScore;
    // 开始时间
    private DateTime StartTime;
    // 结束时间
    private DateTime EndTime;
    // 
    public FishingChallengeData fishingChallengeData { get; private set; }
    public EventChallengeMain eventChallengeMain { get; private set; }
    public EventChallengeConfig eventChallengeConfig { get; private set; }
    public MapData challengeMapData { get; private set; }
    public List<ItemData> itemDataList { get; private set; }
    //
    private readonly List<int> _stageDropList = new();
    //
    // 打点数据
    private List<int> _eventTrackStageList;
    private List<int> _eventTrackNormalRewardList;
    private bool IsInit { get; set; } = false;
    
    public bool IsFirstOpen
    {
        get { return fishingChallengeData.FirstOpen; }
        set
        {
            if (fishingChallengeData.FirstOpen)
            {
                fishingChallengeData.FirstOpen = false;
                DoSave();
            }
        }
    }
    // 进入的第一步，设置数据
    public void SetupEventData(FishingEvent fishingEvent)
    {
        Log($"SetupEventData -> {fishingEvent}");
        if (CurFishingEventData == null || (CurFishingEventData.ID != fishingEvent?.ID))
        {
            CurFishingEventData = fishingEvent;
        }
        //UpdateTimeData();
    }

    public bool ShouldOpen()
    {
        Log("ShouldOpen");
        if (fishingChallengeData == null)
            return false;

        // 是否时间允许
        if (!IsTimeAllow())
        {
            return false;
        }

        // 判断是否通关
        if (IsClearAllLevel())
        {
            return false;
        }
        return true;
    }

    public bool IsTimeAllow()
    {
        var now = ZZTimeHelper.UtcNow();

        var startTime = fishingChallengeData.StartTime;
        var endTime = fishingChallengeData.EndTime;
#if UNITY_EDITOR

        var timeOpened = (now - startTime).TotalSeconds;
        var timeEnded = ( endTime -now).TotalSeconds;
        Log($"StartTime: {startTime} Now: {now} EndTime:{endTime} TimeOpened:{timeOpened} TimeToEnd:{timeEnded} Other: {1800000- timeOpened} IsTimeAllow => {now <= endTime}");
#endif
        return now >= startTime && now <= endTime;
    }
    
    public void ClearFishingChallengeData()
    {
        fishingChallengeData = null;
        _stageDropList.Clear();
        IsInit = false;
        DoSave();
    }
    
    public bool IsStepFinished(int step)
    {
        var finalStep = _eliminateListScore.Count;
        var isFinish = step == finalStep;
        Log($"IsStepFinished() -> {step} {finalStep} {isFinish}");
        return isFinish;
    }
    // 当前轮所有是否完成
    private bool IsFinishCurLevel()
    {
        return IsStepFinished(fishingChallengeData.step);
    }
    // 是否全部通关
    private bool IsClearAllLevel()
    {
        // 时间限制要不要加上，需要跟胡后续判定
        if (fishingChallengeData.RankTierLevel <= TopRankTier)
        {
            return true;
        }

        return false;
    }
    public void InitChallengeData(string str)
    {
        Log($"InitChallengeData -> {str}");
        fishingChallengeData = JsonConvert.DeserializeObject<FishingChallengeData>(str);
    }

    private void InitBaseData()
    {
        var limitedTime = (LimitedTime)CurFishingEventData.TimeDefinition;
        var startTime = GlobalUtils.TryParseDateTime(limitedTime.StartTime, ZZTimeHelper.UtcNow());
        var endTime = GlobalUtils.TryParseDateTime(limitedTime.EndTime, ZZTimeHelper.UtcNow());

        fishingChallengeData.FirstOpen = true;
        fishingChallengeData.RankTierLevel = int.MaxValue;
        fishingChallengeData.RedirectID = CurFishingEventData.RedirectID;
        fishingChallengeData.EventId = CurFishingEventData.ID;
        fishingChallengeData.StartTime = startTime;
        fishingChallengeData.EndTime = endTime;
        
        Log($"fishingChallengeData.EventId -> {fishingChallengeData.EventId}");
    }

    public void CheckInit()
    {
        
        ProcessLastChallenge();
        Init();
    }
    
    public void Init()
    {
        Log("Init");
        // 设置数据
        TopRankTier = _tables.TbEventChallengeMain.DataList[0].RankTier;
        _stageDropList.Clear();
        
        if (fishingChallengeData == null)
        {
            if (CurFishingEventData == null) // 不存在Event 
            {
                return;
            }
            fishingChallengeData = new FishingChallengeData();
            InitBaseData();
            InitChallengeData();
        }
        
        if (!IsInit)
        {
            // 设置比赛数据实体
            UpdateChallengeMainAndConfig();
            UpdateTimeData();
            UpdateLocalData();
            IsInit = true;
        }
        OnChallengeStatus();// 设置状态以及表现
    }

    public void ProcessLastChallenge()
    {
        UpdateTimeData();
        if (fishingChallengeData != null)
        {
            if(!IsTimeAllow())
            {
                // 未完成
                if (fishingChallengeData.Finished == 0)
                {
                    UpdateChallengeMainAndConfig();
                    var status = ChallengeState();
                    OnFinish(status);
                }
                ClearFishingChallengeData();
            }
        }
    }
    private void OnChallengeStatus()
    {
        var status = ChallengeState();
        Log($"OnChallengeStatus -> {status}");
        
        if (IsTimeAllow())
        {
            if (status is 0 or 2)
            {
                // GContext.container.Resolve<IFaceUIService>().AddFaceCustomUIData(UITypes.EventChallengeFacePopupPanel, true);
            }
        }
        else
        {
            OnFinish(status);
        }
    }

    // 结束的时候调用
    // 倒计时结束最好也有个调用出发到这里
    private async void OnFinish(int status)
    {
        Log($"OnFinish ->{status}");
        if (status == 0)
        {
            Log("未开始比赛 -- 不应该进入");
        }
        else if (status == 1)
        {
            Log($" RankTierLevel {fishingChallengeData.RankTierLevel} ");
            var  rewardList = GetRewardByScore(fishingChallengeData.ProcessedScore,fishingChallengeData.Score);
            GContext.Publish(new DeferredRewardStashService.EventStashItems { Items = rewardList });
            
        }
        else if (status == 2)
        {
            Log($" RankTierLevel {fishingChallengeData.RankTierLevel} ");
            // var rewardList = GetRewardByScore(fishingChallengeData.ProcessedScore,fishingChallengeData.Score);
            // GContext.Publish(new DeferredRewardStashService.EventStashItems { Items = rewardList });
        }
        ClearFishingChallengeData();
    }

     // 0- 6 阶段奖励
     // 7 最终奖励
    // 获得未处理的道具
    private List<ItemData> GetRewardByScore(int processedScore,int score)
    {
        var playerItemData = GContext.container.Resolve<PlayerItemData>();
        var listItemDatas = new List<ItemData>();
        var curIndex = GetStepByScore(processedScore,true);
        var endIndex = GetStepByScore(score,true);

        var minEndIndex = Math.Min(endIndex, GetFullStep() - 1);
        for (var i = curIndex; i < minEndIndex; ++i)
        {
            var itemDatas =
                playerItemData.GetItemDataByDropId(eventChallengeMain.StageReward[i]);
            listItemDatas.AddRange(itemDatas);
        }

        if (endIndex >= GetFullStep() - 1)
        {
            listItemDatas.AddRange(GetFinalReward());
        }
        Log($"GetRewardByScore ->{processedScore} -> {score}  {listItemDatas}");
        return listItemDatas;
    }

    // 剩余人数
    public int GetCurResidualNumber()
    {
        var newStep = fishingChallengeData.step;
        return CalcResidualNumber(newStep);
    }

    public int CalcResidualNumber(int step)
    {
        var eliminateNumber = fishingChallengeData.eliminateNumber;
        var newEliminate = 0;
        for (var i = step; i < eliminateNumber.Count; i++)
        {
            newEliminate += eliminateNumber[i];
        }
        return newEliminate;
    }
    public void SetCurRank()
    {
        if (fishingChallengeData.Score == 0)
        {
            Rank = eventChallengeMain.RobotNumber + 1;
            return;
        }
        // 
        var newStep = fishingChallengeData.step;
        //剩余人数 
        var eliminateNumber = fishingChallengeData.eliminateNumber;
        var newEliminate = CalcResidualNumber(newStep + 1);
        // newStep = Math.Min(newStep, eliminateNumber.Count - 1);
        var newRank = newEliminate + UnityEngine.Random.Range(1, eliminateNumber[newStep]);
        Rank = newRank < Rank ? newRank : Rank;
        Log($"SetCurRank -> {newStep} {Rank}");
    }

    public int GetMaxScoreByStep(int curStep)
    {
        var eliminateListScore = _eliminateListScore;
        
        if (curStep >= 0 && curStep < eliminateListScore.Count)
        {
            return eliminateListScore[curStep];
        }
        Log($"Error {curStep} : {eliminateListScore.Count}");
        return 0;
    }

    public int GetFullStep()
    {
        var eliminateScore = eventChallengeMain.EliminateScore;
        return eliminateScore.Count;
    }

    public int GetNewStep()
    {
        var eliminateListScore = _eliminateListScore;
        var newStep = eliminateListScore.Count;
        var score = fishingChallengeData.Score;
        for (int i = 0; i < eliminateListScore.Count; i++)
        {
            if (score < eliminateListScore[i])
            {
                newStep = i;
                break;
            }
        }
        Log($"GetNewStep() -> {newStep}");
        return newStep;
    }
    
    public int GetBeginScore(int score,bool asNewLine)
    {
        int step = GetStepByScore(score,asNewLine);
        return GetMaxScoreByStep(step - 1);
    }

    public float GetFillAmount(int score,bool asNewLine)
    {
        int step = GetStepByScore(score,asNewLine);
        if (step < eventChallengeMain.EliminateScore.Count)
        {
            int beginScore = GetBeginScore(score, asNewLine);
            int diffScore = score - beginScore;
            return (float)diffScore / eventChallengeMain.EliminateScore[step];
        }
        return 0f;
    }
    
    public int GetStepByScore(int score,bool asNewLine)
    {
        var newStep = _eliminateListScore.Count;
        for (int i = 0; i < _eliminateListScore.Count; i++)
        {
            if (asNewLine)
            {
                if (score < _eliminateListScore[i])
                {
                    newStep = i;
                    break;
                }
            }
            else
            {
                if (score <= _eliminateListScore[i])
                {
                    newStep = i;
                    break;
                }
            }
            
        }
        Log($"GetStepByScore() -> {newStep}");
        return newStep;
    }
    public void CheckAutoOpenPanel()
    {
        // if (!IsOpen)
        // {
        //     return;
        // }
        var status = ChallengeState();
        if (status is 0 or 3) return;
        // 异常状态,直接进入结算
        if ((status == 1 && !IsTimeAllow()) || status == 2)
        {
            InChallenge();
        }
    }

    public async void InChallenge()
    {
        Log("InChallenge()");
        
        var challengeState = ChallengeState();
        if (challengeState == 0)
        {
            FishingChallengeAct.CloudType = 1;
        }
        else
        {
            FishingChallengeAct.CloudType = 0;
        }
        
        var loadResourceService = GContext.container.Resolve<ILoadResourceService>();
        var isCanEnter = await loadResourceService.Load("FishingChallengeAct");
        if (isCanEnter)
        {
            Log($"InChallenge() 开始挑战 -> {eventChallengeMain.ID}");
            GContext.Publish(new UnloadActToNextAct("FishingChallengeAct", transitionPanel: new UIType(eventChallengeConfig.MatchPanel) ));
        }
        else
        {
            var panel = await UIManager.Instance.ShowUI(UITypes.CloudTransitionPanel);
            panel.GetComponent<CloudTransitionPanel>().SetBtn(true,
                () => GContext.Publish(new UnloadActToNextAct("FishingChallengeAct", 
                    transitionPanel: new UIType(eventChallengeConfig.MatchPanel))));
        }
    }

    /// <summary>
    /// 刷新地图
    /// </summary>
    /// <returns></returns>
    private void SetupNextLevelDataAndSave()
    {
        Log("SetupNextLevelDataAndSave()");
        InitChallengeData();
        UpdateLocalData();
        MatchComplete();
        DoSave();
    }

    private void ZeroChallengeData()
    {
        fishingChallengeData.uiStep = 0;
        fishingChallengeData.step = 0;
        fishingChallengeData.Score = 0;
        // fishingChallengeData.energy = 0;
        fishingChallengeData.ProcessedScore = 0;
    }
    // 重置 data 数据
    private void InitChallengeData()
    {
        Log("InitChallengeData() -> ");
        ZeroChallengeData();
        // fishingChallengeData.mapId = GetRandomMap();
    }

    private void UpdateLocalData()
    {
        Log("UpdateLocalData() -> ");
        if (fishingChallengeData == null || eventChallengeConfig == null || eventChallengeMain == null)
            return;
        PreScore = fishingChallengeData.Score; // 记录积分
        PlayerFullNumber = eventChallengeMain.RobotNumber + 1;
        PrefabName = eventChallengeConfig.ScenePanel;
        _stageDropList.Clear();
        Rank = eventChallengeMain.RobotNumber + 1;
    }

    // 更新等级数据,确定开始
    private void UpdateLevelData(bool isSuccess)
    {
        if (isSuccess)
        {
            fishingChallengeData.RankTierLevel = eventChallengeMain.RankTier;
            fishingChallengeData.Finished = fishingChallengeData.RankTierLevel <= TopRankTier ? 1 : 0;
        }
    }
    
    public void AddFlyEvent(float oldScore,float newScore)
    {
        GContext.Publish(new TargetAddData(eventChallengeConfig.Item,(int)oldScore,(int)newScore));
    }
    public void AddScoreByQuality(int quality, float proficiencyExtra)
    {
        if (fishingChallengeData == null)
            return;
        //
        var challengeState = ChallengeState();
        if (challengeState is 0 or 3) 
        {
            return;
        }
        
        if (!IsTimeAllow())
            return;
        var extra = GContext.container.Resolve<PlayerData>().GetMagnification();
        var qualityScore = GetQualityScoreWithExtra(quality, extra);
        var oldScore = fishingChallengeData.Score;
        if (qualityScore > 0)
        {
            fishingChallengeData.Score += qualityScore;
            // fishingChallengeData.energy += extra;
            Log($"AddScoreByQuality -> {quality} {proficiencyExtra},{qualityScore}");
            AddFlyEvent(oldScore, fishingChallengeData.Score);
            DoSave();
        }
    }

#if UNITY_EDITOR
    private int _cheatingScore;
    public void SetQualityScore(int cheatingScore)
    {
        _cheatingScore = cheatingScore;
    }
#endif
    private int GetQualityScoreWithExtra(int quality, float extra)
    {
#if UNITY_EDITOR
        if (_cheatingScore != 0)
        {
            return _cheatingScore;
        }
#endif
        return (int)(GetQualityScore(quality) * extra);
    }

    public List<ItemData> GetFinalReward()
    {
        var playerItemData = GContext.container.Resolve<PlayerItemData>();
        var itemList = playerItemData.GetItemDataByDropId(eventChallengeMain.WinnerReward);
        return itemList;
    }

    public int GetQualityScore(int quality)
    {
        var pointsGet = eventChallengeConfig?.PointsGet;
        if (pointsGet == null)
            return 0;
        if (quality > pointsGet.Count || quality < 1) // quality 在 1-5 之间有效，
            return 0;
        var qualityIndex = quality - 1;
        Log($"GetQualityScore({qualityIndex}, {pointsGet[qualityIndex]})");
        return (pointsGet[qualityIndex]);
    }

    public ItemData GetStageRewardByStep(int step)
    {
        //
        // ItemData itemData;
        var playerItemData = GContext.container.Resolve<PlayerItemData>();
        if (step >= 0 && step < GetFullStep() - 1)
        {
            var itemDatas =
                playerItemData.GetItemDataByDropId(eventChallengeMain.StageReward[step]);
            return itemDatas.FirstOrDefault();
        }

        return null;
    }

    public void AddStageReward(int stageIndex)
    {
        // stageIndex =  newStep -1 == oldStep
        Log($"AddStageReward({stageIndex})");
        if (stageIndex >= 0 && stageIndex < GetFullStep() - 1)
        {
            _stageDropList.Add(eventChallengeMain.StageReward[stageIndex]);
            _eventTrackStageList.Add(stageIndex + 1);
        }
    }

    public bool PlayGetStageReward()
    {
        Log("PlayGetStageReward -> ");
        var playerItemData = GContext.container.Resolve<PlayerItemData>();
        if (_stageDropList.Count > 0)
        {
            playerItemData.AddItemByDropList(_stageDropList,scope:1);
            GContext.Publish(new ShowData());
            _stageDropList.Clear();
            return true;
        }
        return false;
    }


    public void SetStep(int step)
    {
        fishingChallengeData.step = step;
        DoSave();
    }

    public void SetUIStep(int step)
    {
        fishingChallengeData.uiStep = step;
        DoSave();
    }

    public void SetProcessedScore(int score)
    {
        fishingChallengeData.ProcessedScore = score;
        DoSave();
    }
    /// <summary>
    /// 当匹配完成的时候，开始倒计时
    /// </summary>
    public void MatchComplete()
    {
        Log("MatchComplete()");
        UpdateFishIndex();
        // 最后剩余人数
        var M = eventChallengeMain.FinalPlayer[fishingChallengeData.index];
        int Count = eventChallengeMain.EliminateScore.Count;
        int first_number = UnityEngine.Random.Range(eventChallengeConfig.RandomSequenceConfig1[0],
            eventChallengeConfig.RandomSequenceConfig1[1]);

        int residualNumber = eventChallengeMain.RobotNumber + 1 - first_number - M;

        int RandomSequence = eventChallengeConfig.RandomSequenceConfig2;
        int a = 0;
        for (int i = 0; i < RandomSequence; i++)
        {
            a += i + 1;
        }

        residualNumber -= a;
        //中间淘汰人数
        int eliminate;
        List<int> eliminateNumber = new List<int>
        {
            first_number
        };
        List<float> weight = new List<float>();
        for (int i = 0; i < RandomSequence; i++)
        {
            weight.Add(UnityEngine.Random.Range(residualNumber / Count, residualNumber));
        }

        float allWeight2 = weight.Sum();
        for (int i = 0; i < RandomSequence; i++)
        {
            eliminate = Mathf.FloorToInt((weight[i] / allWeight2) * residualNumber);
            residualNumber -= eliminate;
            eliminateNumber.Add(eliminate);
        }

        // eliminateNumber.Add(residualNumber);
        eliminateNumber.Sort((a, b) => b.CompareTo(a));
        for (var i = 0; i < RandomSequence; i++)
        {
            eliminateNumber[i + 1] += (RandomSequence - i);
        }

        var leftNum = Count - 2 - RandomSequence;
        while (leftNum-- > 0)
        {
            var num = UnityEngine.Random.Range(1, residualNumber);
            eliminateNumber.Add(num);
            residualNumber -= num;
        }

        eliminateNumber.Add(residualNumber);
        //最后剩余人数 放到淘汰列表 所有淘汰之后 最后一个
        eliminateNumber.Add(M);
        fishingChallengeData.eliminateNumber = eliminateNumber;
        fishingChallengeData.robotAccountList = new List<int>();
        //随机机器人
        //随机位置 
        var robotAccountList = new List<int>(eventChallengeMain.RobotAccountList);
        for (int i = 0; i < 30; i++)
        {
            if (robotAccountList.Count <= 0)
            {
                break;
            }

            var index = UnityEngine.Random.Range(0, robotAccountList.Count);
            fishingChallengeData.robotAccountList.Add(robotAccountList[index]);
            robotAccountList.RemoveAt(index);
        }

        ZeroChallengeData();
        PreScore = fishingChallengeData.Score;
        Rank = eventChallengeMain.RobotNumber + 1;
    }

    private void UpdateFishIndex()
    {
        var finalWeight = eventChallengeMain.FinalWeight;
        var allWeight = finalWeight.Sum();
        var rand = UnityEngine.Random.Range(0, allWeight);
        for (int i = 0; i < finalWeight.Count; i++)
        {
            rand -= finalWeight[i];
            if (rand < 0)
            {
                fishingChallengeData.index = i;
                break;
            }
        }
    }

    /// <summary>
    /// 结算
    /// </summary>
    public void OnSettle()
    {
        Log("OnSettle()");
        itemDataList = null;
        if (fishingChallengeData != null)
        {
            Log($"OnSettle() -> 结算 -> {fishingChallengeData.RankTierLevel}");
            SetCurRank();
            var playerItemData = GContext.container.Resolve<PlayerItemData>();
            if (IsFinishCurLevel())
            {
                //成功，瓜分奖励
                itemDataList = playerItemData.GetItemDataByDropId(eventChallengeMain.FinalReward[fishingChallengeData.index]);
                playerItemData.AddItem(itemDataList);
                UpdateLevelData(true);
            }
            else
            {
                Log("失败了");
                UpdateLevelData(false);
            }
            GContext.Publish(new ConditionTypeEvent { type = ConditionType.CompleteChallengeCount, count = 1 });
        }
    }

    /// <summary>
    ///  全部结算处理逻辑的时候，
    /// </summary>
    public void OnSettleFinished(bool isSuccess)
    {
        Log($"OnSettleFinished() -> {isSuccess}");
        if (!isSuccess)
        {
            fishingChallengeData = null;
            DoSave();
        }
        else
        {
            UpdateChallengeMainAndConfig();
            SetupNextLevelDataAndSave();
        }

    }
    private static void Log(object t)
    {
        Debug.Log($"<color=yellow>FishingChallengeManager -> {t} </color>");
    }
    
    public void EventTracking()
    {
        // _eventTrackNormalRewardList = _stageDropList.ToList();
        
        var tier = eventChallengeMain?.RankTier ?? -1;
        var stageList = _eventTrackStageList;
        var maxStage = fishingChallengeData.step;
        var normalRewardList = _stageDropList.ToList();;
        var combineId = (6 - tier) * 100 + maxStage;
#if AGG
        using (var e = GEvent.TackEvent("offer_challenge"))
        {
            e.AddContent("tier", tier);
            e.AddContent("stage_list",string.Join(",",stageList));
            e.AddContent("max_stage", maxStage);
            e.AddContent("normal_reward_list", string.Join(',',normalRewardList));
            if (IsFinishCurLevel())
            {
                var finalRewardList = eventChallengeMain?.FinalReward?
                    .ElementAtOrDefault(fishingChallengeData?.index ?? -1) ?? -1;
                var finalPlayer = eventChallengeMain?.FinalPlayer?
                    .ElementAtOrDefault(fishingChallengeData?.index ?? -1) ?? -1;
                e.AddContent("final_reward_list", string.Join(',', finalRewardList));
                e.AddContent("final_player", finalPlayer);
            }
            e.AddContent("combine_id", combineId);
        }
#endif 
        var sb = new StringBuilder();
        sb.Append($"tier: {tier},")
            .Append($"max_stage: {maxStage}")
            .Append($"stage_list: {string.Join(',', stageList)}")
            .Append($"normal_reward_list:{string.Join(',', normalRewardList)}")
            .Append($"combine_id: {combineId}");
        
        if (IsFinishCurLevel())
        {
            var finalRewardList = eventChallengeMain?.FinalReward?
                .ElementAtOrDefault(fishingChallengeData?.index ?? -1) ?? -1;
            var finalPlayer = eventChallengeMain?.FinalPlayer?
                .ElementAtOrDefault(fishingChallengeData?.index ?? -1) ?? -1;
            sb.Append($"final_reward_list:{string.Join(',',finalRewardList)}");
            sb.Append($"finalPlayer:{finalPlayer}");
        }
        
        Log($"EventTracking: -> {sb}");
        _eventTrackStageList.Clear();
        // _eventTrackNormalRewardList.Clear();
        
    }
    private void UpdateTimeData()
    {
        if (CurFishingEventData == null)
        {
            if (fishingChallengeData != null)
            {
                fishingChallengeData.StartTime = ZZTimeHelper.UtcNow();
                fishingChallengeData.EndTime = ZZTimeHelper.UtcNow().AddDays(-1);
            }
        }
        else
        {
            var limitedTime = (LimitedTime)CurFishingEventData.TimeDefinition;
            var startTime = GlobalUtils.TryParseDateTime(limitedTime.StartTime, ZZTimeHelper.UtcNow());
            var endTime = GlobalUtils.TryParseDateTime(limitedTime.EndTime, ZZTimeHelper.UtcNow().AddDays(-1));
            StartTime = startTime;
            EndTime = endTime;
            if (fishingChallengeData != null )
            {
                fishingChallengeData.StartTime = startTime;
                fishingChallengeData.EndTime = endTime;
            }
        }
    }
    // 获取当前可用的数值，以及初始化
    private void UpdateChallengeMainAndConfig()
    {
        Log("UpdateChallengeMainAndConfig()");

        var redirectId = fishingChallengeData.RedirectID;
        // 未满足的情况
        // 选择当前 Config
        var configList = _tables.TbEventChallengeConfig.DataList;
        foreach (var eventChallenge in configList.Where(eventChallenge => eventChallenge.ID == redirectId))
        {
            eventChallengeConfig = eventChallenge;
            break;
        }
        // 选择当前的 Main
        var challengeMatchMains = _tables.TbEventChallengeMain.DataList;
        var rankTierLevel = fishingChallengeData.RankTierLevel;
        eventChallengeMain = challengeMatchMains.LastOrDefault();
        for (var i = challengeMatchMains.Count - 1; i >= 0; i--)
        {
            if (rankTierLevel > challengeMatchMains[i].RankTier)
            {
                eventChallengeMain = challengeMatchMains[i];
                break;
            }
        }
        UpdateEliminateListScore();
    }

    //
    private readonly List<int> _eliminateListScore = new();
    public void UpdateEliminateListScore()
    {
        _eliminateListScore.Clear();
        var orElmScore  = eventChallengeMain.EliminateScore;
        var elem = 0;
        foreach (var i in orElmScore)
        {
            elem += i;
            _eliminateListScore.Add(elem);
        }
        Log(_eliminateListScore);
    }
    
    public List<int> GetEliminateListScore()
    {
        return _eliminateListScore;
    }

    public List<int> GetOriEliminateListScore()
    {
        return eventChallengeMain.EliminateScore;
    }
    /// <summary>
    /// 当前钓鱼争霸赛的状态,进入此函数认为已经确认过时间
    /// </summary>
    /// <returns>0,未开始匹配 1，开始中 2，当前轮已经结算 3.关卡清空 </returns>
    public int ChallengeState()
    {
        // Log("ChallengeState");
        
        int state;
        // 未开始|未到开始时间
        if (fishingChallengeData == null)
        {
            state = 0;
        }
        else
        {
            if (IsClearAllLevel())
            {
                state = 3;
            }
            else if (fishingChallengeData.eliminateNumber == null || fishingChallengeData.robotAccountList == null)
            {
                state = 0;
            }
            // 未完成当前轮
            else if (!IsFinishCurLevel())
            {
                state = 1;
            }
            else
            {
                state = 2;
            }
        }
        Log($"ChallengeState() -> {state}");
        return state;
    }

    public bool IsSettleState()
    {
        var status = ChallengeState();
        // 超时或者结束，都进入结算
        return (status == 1 && !IsTimeAllow()) || status == 2;
    }
    /// <summary>
    /// 获取倒计时,距离截至时间
    /// </summary>
    /// <returns></returns>
    public TimeSpan GetTimeSpan()
    {
        if (fishingChallengeData != null)
        {
            return fishingChallengeData.EndTime - ZZTimeHelper.UtcNow();
        }
        // 活动未开始
        return EndTime - ZZTimeHelper.UtcNow();
    }
    
    private void DoSave()
    {
        PlayFabMgr.Instance.UpdateUserDataValue(SaveKey, JsonConvert.SerializeObject(fishingChallengeData));
    }

    public string GetOpenEventKey()
    {
        if (fishingChallengeData != null)
        {
            return fishingChallengeData?.EventId + "_LL_FIRST_OPEN";
        }
        return "";
    }

    public bool IfHasReward()
    {
        var step = fishingChallengeData.step;
        var newStep = GetStepByScore(fishingChallengeData.Score, true);
        return step != newStep;
    }
    
    public void OnChallengeSceneEnter()
    {
        _stageDropList.Clear();
        _eventTrackStageList = new();
    }

    //TODO:LF 调试用，暂时这么写
    public async void InitHexMap()
    {
        var loadResourceService = GContext.container.Resolve<ILoadResourceService>();
        var isCanEnter = await loadResourceService.Load("HexMapAct");
        if (isCanEnter)
        {
            GContext.Publish(new UnloadActToNextAct("HexMapAct"));
        }
        else
        {
            var panel = await UIManager.Instance.ShowUI(UITypes.CloudTransitionPanel);
            panel.GetComponent<CloudTransitionPanel>().SetBtn(true,
                () => GContext.Publish(new UnloadActToNextAct("HexMapAct")));
        }
    }
}