using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using asap.core;
using Castle.Core.Internal;
using cfg;
using DataCenter;
using DG.Tweening;
using EventPartnerGather;
using game;
using GameCore;
using TMPro;
using UniRx;
using UnityEngine;
using UnityEngine.UI;

using BuildPartner = EventPartnerGather.BuildPartner;

namespace UI.PartnerGather.Mining
{
    public class EventPartnerMiningPanel : MonoBehaviour
    {
        private const bool EnableTraceLogs = true;

        [SerializeField]
        [Header("小火车开始默认位置")]
        private float originX = -1000;

        [SerializeField]
        [Header("小火车显示位置")]
        private float finalX = 0;

        [SerializeField]
        [Header("动画曲线")]
        public AnimationCurve moveCurve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);

        [Header("移动参数")]
        [Min(0.01f)]
        public float duration = 1f;       // 总时长（秒）

        private Button _btnConfirm;
        private EventPartnerGatherManager _manager;
        private PartnerInfoManager _partnerInfoManager;

        private EventPartnerService _eventPartnerService;
        private IUIService _uiService;
        private Tables _tables;
        private readonly IUserService _userService = GContext.container.Resolve<IUserService>();
        // 玩家列表
        private List<Transform> _listPartnerTransforms;

        private Transform _target;
        private Transform _reward1;
        private Transform _reward2;
        private Transform _reward3;
        

        private Transform _finished;
        private Transform _iconTicket;
        private Button btn_questionmark;
        // private Transform _textTime;

        private TMP_Text _textTime;

        private PlayerItemData _playerItemData;
        private Button _btnAdd;
        //
        private List<Transform> _listIconTrans;

        private Timer timer;

        // 
        private IDisposable _robotAddScoreSubscription;
        private CompositeDisposable _disposables;
        
        //-自动匹配的控制
        private AutoMatchController _autoMatchController;
        private void Awake()
        {
            _eventPartnerService = GContext.container.Resolve<EventPartnerService>();
            _uiService = GContext.container.Resolve<IUIService>();
            _manager = GContext.container.Resolve<EventPartnerGatherManager>();
            _partnerInfoManager = _manager.PartnerInfoManager;

            _tables = GContext.container.Resolve<Tables>();
            _playerItemData = GContext.container.Resolve<PlayerItemData>();
            // 创建自动匹配控制器
            _autoMatchController = new AutoMatchController(_manager);
            
            
            _target = transform.Find("root/target");
            _reward1 = transform.Find("root/target/target1/reward1");
            _reward2 = transform.Find("root/target/target1/reward2");
            _reward3 = transform.Find("root/target/target1/reward3");
            _btnConfirm = transform.Find("root/finished/Btn_confirm/btn_green").GetComponent<Button>();
            _finished = transform.Find("root/finished");
            _iconTicket = transform.Find("root/icon_ticket");
            _textTime = _target.Find("text_time").GetComponent<TMP_Text>();
            _btnAdd = transform.Find("root/icon_ticket/btn_add").GetComponent<Button>();

            btn_questionmark = transform.Find("root/title/btn_questionmark").GetComponent<Button>();

            _listPartnerTransforms = new List<Transform>
            {
                transform.Find("root/btn_partner1"),
                transform.Find("root/btn_partner2"),
                // transform.Find("root/btn_partner3"),
            };

            _listIconTrans = new List<Transform>
            {
                transform.Find("root/target/target1/icon/icon1"),
                transform.Find("root/target/target1/icon/icon2"),
                // transform.Find("root/target/target1/icon/icon3"),
            };

            _finished.gameObject.SetActive(false);

        }

        private void InitTarget()
        {
            //TBF
            // _textTime 倒计时
            // 
            var target1 = _target.Find("target1");
            var text_time = _target.Find("text_time");
            var buildPartners = _partnerInfoManager.BuildPartners;
            //

            var dropId = _manager.EventPartnerMineMainData.Reward;
            var listItems = _playerItemData.GetItemDataByDropIdLureInflation(_manager.GatherData.InflationRate, dropId);
            
            // var rewardItemNew = target1.Find("reward1").GetComponent<RewardItemNew>();
            // rewardItemNew.SetData(listItems.FirstOrDefault());
            
            // var rewardItemNew2 = target1.Find("reward2").GetComponent<RewardItemNew>();
            // rewardItemNew2.SetData(listItems[1]);

            // var rewardItemNew3 = target1.Find("reward3").GetComponent<RewardItemNew>();
            // rewardItemNew3.SetData(listItems[2]);
            // var data = listItems.ElementAtOrDefault(0);
            // var i = PartnerInfoManager.BuilderCapacity;
            
            
            var rewardItemList = new List<Transform>();
            for (var i = 1; i < 3 ; ++i)
            {
                rewardItemList.Add(target1.Find($"reward{i}"));
            }
            
            for (var i = 0; i < listItems.Count; ++i)
            {
                var trans = rewardItemList.ElementAtOrDefault(i);
                if (!trans) continue;
                var rewardItemNew = trans.GetComponent<RewardItemNew>();
                rewardItemNew?.SetData(listItems[i]);
            }
            
            


            // 设置显示
            for (var i = 0; i < buildPartners.Length; ++i)
            {
                var buildPartner = buildPartners[i];
                var fx = _listIconTrans[i].Find("fx_ui_partnermining_trophy_finish");
                if (fx)
                {
                    fx.gameObject.SetActive(false);
                }
                _listIconTrans[i].gameObject.SetActive(buildPartner != null 
                                                       && buildPartner.IsValid() && buildPartner.IsFinished() 
                                                       && _manager.IsCompleteStageAll(buildPartner.SlotId));
            }

            InitTitle();
        }

        private void InitTitle()
        {
            var timeSpan = _manager.GetRemainingTime();
            _textTime.text = ConvertTools.ConvertTime2(timeSpan.Days, timeSpan.Hours, timeSpan.Minutes, timeSpan.Seconds);
            var seconds = timeSpan.TotalSeconds;
            timer = this.AttachTimer((float)seconds, null,
                async (elapsed) =>
                {
                    // var now = endTime - ZZTimeHelper.UtcNow().UtcNowOffset();
                    var now = _manager.GetRemainingTime();
                    _textTime.text = ConvertTools.ConvertTime2(now.Days, now.Hours, now.Minutes, now.Seconds);
                    if (now.TotalMilliseconds < 0)
                    {
                        Settle();
                    }
                }, useRealTime: true);
        }

        private void InitInfo()
        {
            var textNum = _iconTicket.Find("text_num").GetComponent<TMP_Text>();
            textNum.text = _manager.GatherData.TicketCount.ToString();
        }

        private void Settle()
        {
            timer?.Cancel();
            timer = null;
            _textTime.text = LocalizationMgr.GetText("UI_EventRankPopupPanel_13");
            //结算
            _manager.OnSettle();
        }

        private void Start()
        {
            _btnConfirm.onClick.AddListener(OnBtnConfirm);
            btn_questionmark.onClick.AddListener(() =>
            {
                _ = UIManager.Instance.ShowUI(UITypes.EventPartnerMiningInfoPopupPanel);
            });

            _btnAdd.onClick.AddListener(OnBtnAdd);
            // 检查是否需要更新 UI

            // InitDebug();
            Init();
            InitRobot();

            // StartAuto 
            GContext.container.Resolve<GuideDataCenter>().InspectTriggerGuide("EventPartnerMiningPanel", curPanelName: gameObject.name);
        }
        
        private void OnEnable()
        {
            ELog($"OnEnable eventId={_manager?.EventId}");
            _disposables = new CompositeDisposable();
            GContext.OnEvent<EventPartnerGatherAddPartner>().Subscribe(OnAddPartner).AddTo(_disposables);
            GContext.OnEvent<EventPartnerGatherPartnerAddScore>().Subscribe(OnScoreAdd).AddTo(_disposables);
            GContext.OnEvent<EventPartnerRefreshPartnerUI>().Subscribe(OnRefreshPartner).AddTo(_disposables);
            GContext.OnEvent<EventPartnerGatherUpdateTicketCount>().Subscribe(OnUpdateTicketCount).AddTo(_disposables);
            GContext.OnEvent<EventTryCloseAutoMatch>().Subscribe(OnTryCloseAutoMatch).AddTo(_disposables);
            GContext.OnEvent<EventForAutoMatchChangeStage>().Subscribe(OnAutoMatchStateChange).AddTo(_disposables);
            
            
            // 更新Partner
            CheckForUpdate();
            // 恢复自动匹配（若上次开启且服务器仍在匹配中）
            _ = _autoMatchController.TryResumeAutoMatch();
        }
        // 
        private void OnDisable()
        {
            ELog($"OnDisable eventId={_manager?.EventId}");
            _disposables?.Dispose();
            _disposables = null;

            CheckStopPollMatchResult();
        }

        // 
        private void Init()
        {
            InitTarget();
            InitPartners();
            InitInfo();
        }

        private void CheckStopPollMatchResult()
        {
            Trace($"CheckStopPollMatchResult eventId={_manager?.EventId}");
            _autoMatchController.CancelPollMatchResult();
        }
        
        
        // 检测是否又奖杯的变化，以及数值的变化
        private async void CheckForUpdate()
        {
            ELog($"CheckForUpdate eventId={_manager?.EventId}");
            
            
            var buildPartners = _partnerInfoManager.BuildPartners;
            var listActBuilders = new List<BuildPartner>();
            
            RefreshAllBubbles();
            RefreshTicketCount();
            
            foreach (var buildPartner in buildPartners)
            {
                if (buildPartner == null) continue;
                UpdatePartner(buildPartner);
                // 生成更新奖杯列表
                if (buildPartner.IsFinished() && (_manager.IsCompleteStageAll(buildPartner.SlotId)))
                {
                    var slotId = buildPartner.SlotId;
                    if(!_manager.GatherData.UIFinishedPartners[slotId])
                    {
                        listActBuilders.Add(buildPartner);
                    }
                    else
                    {
                        _listIconTrans[slotId].gameObject.SetActive(true);
                    }
                }
            }
            // 
            if (listActBuilders.Count > 0)
            {
                await Awaiters.Seconds(1f);
                await RunChampionAction(listActBuilders);
            }
            // 是否已经领了大奖
            if(_manager.GatherData.IsRecvFinalReward)
                return;
            
            // 全部完成了，更新大奖
            var finished = buildPartners?.All(buildPartner =>
                buildPartner != null && buildPartner.IsValid() && buildPartner.IsFinished()
                && _manager.IsCompleteStageAll(buildPartner.SlotId)
                ) ?? true ;

            if (finished)
            {
                await RunFinalRewardAction();
            }
        }

        private void RefreshTicketCount()
        {
            var textNum = _iconTicket.Find("text_num").GetComponent<TMP_Text>();
            textNum.text = _manager.GatherData.TicketCount.ToString();  
        }
        

        private void UpdatePartner(BuildPartner buildPartner)
        {
            var index = buildPartner.SlotId;
            var rootUI = _listPartnerTransforms[index];
            SetupInfo(rootUI, buildPartner);
            var player = rootUI.Find("player");
            if (player)
            {
                player.DOKill();
                player.position = new Vector3(0, player.position.y, player.position.z);
            }
        }

        private void UpdatePartnerScore(BuildPartner buildPartner)
        {
            if (buildPartner == null)
                return;

            var index = buildPartner.SlotId;
            var rootUI = _listPartnerTransforms[index];
            if (!string.IsNullOrEmpty(buildPartner.PartnerId) )
            {
                rootUI.Find("empty").gameObject.SetActive(false);
                var player = rootUI.Find("player");
                player.gameObject.SetActive(true);
                var head = player.Find("head");
                var bar = head.Find("bg_bar/bar").GetComponent<Image>();
                var currentDisplayScore = buildPartner.DisplayScore;
                var maxScore = buildPartner.MaxScore;
                var pt = currentDisplayScore;
                var progress = _manager.CalcMiningProgressOld(currentDisplayScore);
                var leftPoint = _manager.GetLeftPoint(currentDisplayScore, progress);
                if (_manager.IsStepFinished(buildPartner.SlotId,progress) && leftPoint == 0)
                {
                    progress = _manager.CalcMiningProgressNew(currentDisplayScore);
                } 
                
                if (progress > _manager.NodeSteps.Count - 1)
                {
                    progress = _manager.NodeSteps.Count -1 ;
                }

                if (progress > 0)
                {
                    pt = currentDisplayScore - _manager.NodeCumulativeSteps[progress - 1];
                }
                bar.fillAmount = (pt  * 1F / _manager.NodeSteps[progress]);
                
                var finished = head.Find("finished");
                var add = head.Find("add");
                var bgBar = head.Find("bg_bar");
                var stageRewardItemNew = bgBar.Find("reward").GetComponent<RewardItemNew>();
                add.gameObject.SetActive(false);
                if (currentDisplayScore >= maxScore)
                {
                    finished.gameObject.SetActive(true);
                    bgBar.gameObject.SetActive(false);
                }
                else
                {
                    finished.gameObject.SetActive(false);
                    bgBar.gameObject.SetActive(true);
                    if (buildPartner.GetExtraScore() > 0)
                    {
                        add.gameObject.SetActive(true);
                        add.Find("text_add").GetComponent<TMP_Text>().text = buildPartner.GetExtraScore().ToString();
                    }
                    //
                    // var progress = _manager.CalcMiningProgress(buildPartner.DisplayScore);
                    var dropId = _manager.GetStageReward(progress);
                    var listItems = _playerItemData.GetItemDataByDropIdLureInflation(_manager.GatherData.InflationRate, dropId);
                    stageRewardItemNew.SetData(listItems.FirstOrDefault());
                }
            }
        }

        private async Task RunFinalRewardAction()
        {
            ELog($"RunFinalRewardAction eventId={_manager?.EventId}");
            await Awaiters.Seconds(0.5f);
            _reward1.Find("effect_reward_shop").gameObject.SetActive(true);
            _reward2.Find("effect_reward_shop").gameObject.SetActive(true);
            _reward3.Find("effect_reward_shop").gameObject.SetActive(true);
            //
            _manager.PlayGetFinalReward();
        }
        private async Task RunChampionAction(List<BuildPartner> listActBuilders)
        {
            ELog($"RunChampionActionStart eventId={_manager?.EventId}");
            if (listActBuilders == null) return;
            ELog($"RunChampionActionCount eventId={_manager?.EventId} count={listActBuilders.Count}");
            foreach (var slotId in listActBuilders.Select(buildPartner => buildPartner.SlotId))
            {
                _manager.GatherData.UIFinishedPartners[slotId] = true;
                await ShowIcon(slotId);
            }
            _manager.SaveData();

        }
        private async void OnBtnAdd()
        {
            var packData = new EventNeoNormalPackData
            {
                EventId = _manager.EventId,
                PackId = _manager.EventPartnerMineMainData.PackId,
                Panel = _manager.EventPartnerMineMainData.PackPanel
            };
            await EventNeoNormalPackPanel.TryShowAsync(packData);
        }
        
        private async Task ShowIcon(int index)
        {
            ELog($"ShowIcon index={index}");
            await Awaiters.Seconds(0.5f);
            if (index < _listIconTrans.Count)
            {
                var fx = _listIconTrans[index].Find("fx_ui_partnermining_trophy_finish");
                if (fx)
                {
                    fx.gameObject.SetActive(true);
                }
                _listIconTrans[index].gameObject.SetActive(true);
            }
        }
        
        private void InitRobot()
        {
            // 机器人加分逻辑
            var buildPartners = _partnerInfoManager.BuildPartners;
            var now = ZZTimeHelper.UtcNow();
            for (var i = 0; i < buildPartners.Length; i++)
            {
                var buildPartner = buildPartners[i];
                if (!buildPartner.IsPartnerRobot || buildPartner.IsFinished())
                    continue;
                
                var botActionQueue = buildPartner.BotActionQueue;

                if (botActionQueue.IsNullOrEmpty() || now < botActionQueue.Peek().Time)
                    continue;

                if (buildPartner.Score >= buildPartner.MaxScore)
                {
                    botActionQueue.Clear();
                    continue;
                }
                while (!buildPartner.BotActionQueue.IsNullOrEmpty() && now >= buildPartner.BotActionQueue.Peek().Time)
                {
                    var bRet = buildPartner.AddRobotScore();
                    if (bRet)
                    {
                        UpdatePartnerScore(buildPartner);
                    }

                }
                buildPartner.SyncRobotScore();

            }

            _manager.RobotInvitationSystem.CheckAndFire();
            
            _robotAddScoreSubscription ??= Observable.Interval(System.TimeSpan.FromSeconds(2.0f))
                .Subscribe(x =>
                {
                    if (!gameObject.activeSelf)
                        return;
                    
                    _manager.RobotInvitationSystem.CheckAndFire();
                    foreach (var buildPartner in buildPartners.Where(c => !c.IsFinished() && c.IsPartnerRobot))
                    {
                        if (!buildPartner.BotActionQueue.TryPeek(out var action) || ZZTimeHelper.UtcNow() < action.Time)
                            continue;
                        if (buildPartner.Score >= buildPartner.MaxScore)
                        {
                            buildPartner.BotActionQueue.Clear();
                            continue;
                        }

                        if (buildPartner.AddRobotScore())
                        {
                            UpdatePartnerScore(buildPartner);
                            buildPartner.SyncRobotScore();
                        }
                    }
                });

            // InitPartnerAddScore();
        }

        private void OnDestroy()
        {
            ELog($"OnDestroy eventId={_manager?.EventId}");
            //- 
            _autoMatchController?.Dispose();
            _autoMatchController = null;
            
            _disposables?.Dispose();
            _disposables = null;

            // 机器人
            _robotAddScoreSubscription?.Dispose();
            _robotAddScoreSubscription = null;
        }
        
        /// <summary>
        /// 开始自动匹配流程
        /// </summary>
        private async Task StartAutoMatchProcess()
        {
            try
            {
                var success = await _autoMatchController.StartAutoMatch();
                if (!success)
                {
                    _manager.NotifyAutoMatchFailed("StartFailed");
                }
            }
            catch (Exception e)
            {
                LogError($"StartAutoMatchProcessError eventId={_manager?.EventId} error={e.Message}");
            }
        }
        
        /// <summary>
        /// 停止自动匹配
        /// </summary>
        private void StopAutoMatchAsync()
        {
            _ = _autoMatchController.StopAutoMatch();
        }
        
        private void OnTryCloseAutoMatch(EventTryCloseAutoMatch e)
        {
            Trace($"OnTryCloseAutoMatch eventId={_manager?.EventId}");
            if (!_manager.CanStopAutoMatch(out var leftTimes))
            {
                if (leftTimes > 0)
                {
                    var text = LocalizationMgr.GetFormatTextValue("UI_EventPartnerMiningPanel_13", leftTimes);
                    // ToastPanel.Show($"不可关闭，CD中  {leftTimes} seconds");
                    ToastPanel.Show(text);
                }
                GContext.Publish(new EventTryCloseAutoMatchResult
                {
                    IsCanClose = false,
                });
            }
            else
            {
                GContext.Publish(new EventTryCloseAutoMatchResult
                {
                    IsCanClose = true
                });
            }
        }
        
        /// <summary>
        /// 自动匹配状态变化事件处理
        /// </summary>
        private async void OnAutoMatchStateChange(EventForAutoMatchChangeStage e)
        {
            try
            {
                if (e.State == AutoMatchState.AutoMatchOn)
                {
                    // 开启自动匹配
                    _manager.SetAutoMatchEnabled(true);
                    _manager.GatherData.LastAutoMatchTime = DateTime.UtcNow;
                    await StartAutoMatchProcess();
                }
                else if (e.State == AutoMatchState.AutoMatchOff)
                {
                    // 关闭自动匹配
                    _manager.SetAutoMatchEnabled(false);
                    StopAutoMatchAsync();
                }
            }
            catch (Exception ex)
            {
                LogError($"OnAutoMatchStateChangeError eventId={_manager?.EventId} error={ex.Message}");
            }
        }
        // 添加用户
        public async void OnAddPartner(EventPartnerGatherAddPartner evt)
        {
            ELog($"OnAddPartner slotId={evt.SlotId}");
            var index = evt.SlotId;
            var buildPartner = _partnerInfoManager.BuildPartners[index];
            // 执行动画
            UIManager.Instance.DestroyUI(UITypes.EventPartnerGatherInvitePanel);
            if (evt.DelaySeconds > 0)
            {
                await Awaiters.Seconds(evt.DelaySeconds);
            }
            await RunAddPartnerAction(index, buildPartner);
            RefreshAllBubbles();
        }
        
        public async void OnRefreshPartner(EventPartnerRefreshPartnerUI evt)
        {
            //
            // UpdateAllPartners();
            
            //
            RefreshAllBubbles();
        }

        private void RefreshAllBubbles()
        {
            var requestPartners = _partnerInfoManager.EventBuildInfo.RequestPartners;
            var hasReqPartners = requestPartners is { Count: > 0 }; 
            
            for (var i = 0; i < _listPartnerTransforms.Count; ++i)
            {
                var buildPartner = _partnerInfoManager.BuildPartners[i];
                if (buildPartner == null || string.IsNullOrEmpty(buildPartner.PartnerId))
                {
                    var partnerTransform = _listPartnerTransforms[i];
                    partnerTransform.Find("empty").gameObject.SetActive(true);
                    partnerTransform.Find("empty/redpoints").gameObject.SetActive(hasReqPartners);
                }
            }
        }
        
        private async Task RunAddPartnerAction(int index, BuildPartner buildPartner)
        {
            var rootUI = _listPartnerTransforms[index];
            // var empty = rootUI.Find("empty");
            var player = rootUI.Find("player");
            // _listPartnerTransforms[index]
            var pos = player.transform.position;
            player.transform.position = new Vector3(pos.x + originX, pos.y, pos.z);
            SetupInfo(rootUI, buildPartner);
            
            await StartMoveTo(player, pos);
        }
        
        public async Task StartMoveTo(Transform trans, Vector3 worldTarget)
        {
            if (!trans) return;
            try
            {
                // _isMoving = true;
                trans.DOKill();
                await trans.DOMove(worldTarget, Mathf.Max(0.0001f, duration))
                    .SetEase(moveCurve)
                    .SetUpdate(UpdateType.Normal)
                    // .OnComplete(() => _isMoving = false)
                    // .OnKill(() => _isMoving = false) // 如果补间被杀死
                    .AsyncWaitForCompletion();

            }
            catch (Exception ex)
            {
                LogError($"MoveAnimationFailed error={ex.Message}");
            }
            // finally
            // {
            //     // _isMoving = false;
            // }
        }
        
        public void OnUpdateTicketCount(EventPartnerGatherUpdateTicketCount evt)
        {
            var textNum = _iconTicket.Find("text_num").GetComponent<TMP_Text>();
            textNum.text = _manager.GatherData.TicketCount.ToString();
        }
        
        //
        public void OnScoreAdd(EventPartnerGatherPartnerAddScore evt)
        {
            ELog($"OnScoreAdd partnerId={evt.partnerId} score={evt.score}");
            
            for (int i = 0; i < _partnerInfoManager.BuildPartners.Length; i++)
            {
                var buildPartner = _partnerInfoManager.BuildPartners[i];
                SetupInfo(_listPartnerTransforms[i], buildPartner);
            }
        }
        
        //UIEvent
        private void InitPartners()
        {
            var requestPartners = _partnerInfoManager.EventBuildInfo.RequestPartners;
            bool hasReqPartners = requestPartners is { Count: > 0 }; 
            
            for (var i = 0; i < _listPartnerTransforms.Count; ++i)
            {
                var partnerTransform = _listPartnerTransforms[i];
                partnerTransform.Find("empty").gameObject.SetActive(true);
                partnerTransform.Find("player").gameObject.SetActive(false);
                partnerTransform.Find("empty/redpoints").gameObject.SetActive(hasReqPartners);
                var i1 = i;
                partnerTransform.GetComponent<Button>().onClick.AddListener(() => OnPartner(i1));
            }
            var partners = _partnerInfoManager.BuildPartners;
            for (var index = 0; index < partners.Length; ++index)
            {
                if (index < _listPartnerTransforms.Count)
                {
                    SetupInfo(_listPartnerTransforms[index], partners[index]);
                }
            }
        }
        // 首先实现邀请
        private void OnPartner(int i)
        {
            ELog($"OnPartner index={i}");


            var buildPartner = _manager.PartnerInfoManager.BuildPartners[i];
            if (buildPartner == null || string.IsNullOrEmpty(buildPartner.PartnerId))
            {
                OnEnterInvite();
            }
            else
            {
                var currentScore = buildPartner.ScorePartnerActual + buildPartner.ScoreSelfActual;
                var maxScore = _manager.NodeCumulativeSteps[^1];
                if (currentScore >= maxScore && _manager.IsCompleteStageAll(buildPartner.SlotId))
                {
                    // ToastPane
                    ELog($"PartnerMaxLevel slotId={buildPartner?.SlotId} currentScore={currentScore} maxScore={maxScore}");
                    return;
                }

                // _manager.StartBuildProgress(buildPartner);

                // var ui = await UIManager.Instance.ShowUI(UITypes.CloudTransitionPanel);
                // await Awaiters.Seconds(1f);
                _manager.StartBuildProgress(buildPartner);
                // ui.GetComponent<CloudTransitionPanel>().EndTransition(new EndTransition());
                // await Awaiters.Seconds();
                // GContext.Publish(new EventPartnerGatherSceneStart());
            }
        }
        // 
        private async void OnEnterInvite()
        {
            ELog($"OnEnterInvite eventId={_manager?.EventId}");
            await UIManager.Instance.ShowUI(UITypes.EventPartnerGatherInvitePanel);
        }
        // 填充角色
        private void SetupInfo(Transform rootUI, BuildPartner buildPartner)
        {
            if (buildPartner != null && !string.IsNullOrEmpty(buildPartner.PartnerId))
            {
                rootUI.Find("empty").gameObject.SetActive(false);
                var player = rootUI.Find("player");
                player.gameObject.SetActive(true);
                var head = player.Find("head");
                
                var train = player.Find("train");
                var stone = player.Find("mask_stone/stone");
                var iconHead = head.Find("mask/icon_head");
                _uiService.SetHeadImage(iconHead.GetComponent<Image>(), buildPartner.AvatarUrl);
                var displayName = buildPartner.DisplayName;
                head.Find("text_player_name").GetComponent<TMP_Text>().text = displayName;
                var bar = head.Find("bg_bar/bar").GetComponent<Image>();
                var currentDisplayScore = buildPartner.DisplayScore;
                var maxScore = buildPartner.MaxScore;
                var progress = _manager.CalcMiningProgressOld(buildPartner.DisplayScore);
                var leftPoint = _manager.GetLeftPoint(currentDisplayScore, progress);
                if (_manager.IsStepFinished(buildPartner.SlotId, progress) && leftPoint == 0)
                {
                    progress = _manager.CalcMiningProgressNew(currentDisplayScore);
                } 
                var pt = currentDisplayScore;
                if (progress > _manager.NodeSteps.Count - 1)
                {
                    progress = _manager.NodeSteps.Count -1;
                }
                if (progress > 0)
                {
                    pt = currentDisplayScore - _manager.NodeCumulativeSteps[progress - 1];
                }
                bar.fillAmount = (pt  * 1F / _manager.NodeSteps[progress]);
                var finished = head.Find("finished");
                var add = head.Find("add");
                var bgBar = head.Find("bg_bar");
                var stageRewardItemNew = bgBar.Find("reward").GetComponent<RewardItemNew>();
                add.gameObject.SetActive(false);
                if (currentDisplayScore >= maxScore && _manager.IsCompleteStageAll(buildPartner.SlotId))
                {
                    finished.gameObject.SetActive(true);
                    bgBar.gameObject.SetActive(false);
                }
                else
                {
                    finished.gameObject.SetActive(false);
                    bgBar.gameObject.SetActive(true);
                    if (buildPartner.GetExtraScore() > 0)
                    {
                        add.gameObject.SetActive(true);
                        add.Find("text_add").GetComponent<TMP_Text>().text = buildPartner.GetExtraScore().ToString();
                    }

                    //
                    
                    var dropId = _manager.GetStageReward(progress);
                    var listItems = _playerItemData.GetItemDataByDropIdLureInflation(_manager.GatherData.InflationRate, dropId);
                    stageRewardItemNew.SetData(listItems.FirstOrDefault());
                }
            }
        }
        
        private async void OnBtnConfirm()
        {
            ELog($"BtnConfirm eventId={_manager?.EventId}");
            await UIManager.Instance.ShowUI(UITypes.EventPartnerGatherRequestPanel);
        }
        private void LogError(object t)
        {
            Debug.LogError($"<color=red>EventPartnerMiningPanel -> {t} </color>");
        }

        private void ELog(string message)
        {
#if UNITY_EDITOR
            Debug.Log($"<Color=cyan> EventPartnerMiningPanel=>  {message} </color>");
#endif
        }
        
        [System.Diagnostics.Conditional("UNITY_EDITOR")]
        private void Trace(string message)
        {
            if (!EnableTraceLogs) return;
            ELog(message);
        }
    }
}