ft/Client/Assets/Scripts/UI/HookWheel/HookWheelPanel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using asap.core;
using game;
using GameCore;
using Newtonsoft.Json.Linq;
using TMPro;
using UI.Wheel;
using UniRx;
using UnityEngine;
using UnityEngine.UI;

namespace UI.HookWheel
{
    public class HookWheelPanel : BasePanel
    {
        private List<IWheelReward> _eventAdWheelRewards;

        private bool _isNeedRefreshUI;
        private HookWheelManager _manager;

        private bool isRotating;
        private HookWheelManager Manager => _manager ??= GContext.container.Resolve<HookWheelManager>();
        private HookWheelData Data => Manager?.Data;

        private void Awake()
        {
            progressObjs = gameObject.FindChildGameObject("target_nml")
                .FindGameObjects(new[] { "icon1", "icon2", "icon3", "icon4" });
            bubble_final = gameObject.FindChildGameObject("p_reward").GetComponentInChildren<RewardItemNew>();
            text_time = gameObject.FindChildGameObject(nameof(text_time)).GetComponent<TextMeshProUGUI>();
            p_wheel = transform.GetComponentInChildren<HookWheelRewardComponent>();
            btn_spin = gameObject.FindChildGameObject(nameof(btn_spin)).GetComponentInChildren<Button>();
            btn_spin.onClick.AddListener(OnChlickBuy);
            btn_close = gameObject.FindChildGameObject(nameof(btn_close)).GetComponent<Button>();
            p_text = btn_spin.gameObject.FindChildGameObject(nameof(p_text)).GetComponentInChildren<TextMeshProUGUI>();
            RewardFlyBatchCtrl = gameObject.FindChildGameObject(nameof(RewardFlyBatchCtrl))
                .GetComponent<RewardFlyBatchController>();
            _targetAni = gameObject.FindChildGameObject("target").GetComponent<Animation>();
            _panelAni = GetComponent<Animation>();

            Observable.Interval(TimeSpan.FromSeconds(1f)).Subscribe(UpdateTimer).AddTo(disposables);
        }

        protected override void Start()
        {
            base.Start();
            GContext.OnEvent<RewardPanelClose>().Subscribe(OnRewardPanelClose).AddTo(disposables);
            InitUI();
            InitData();
            ShowUI();
        }

        protected override void OnDestroy()
        {
            _eventAdWheelRewards?.Clear();
            _eventAdWheelRewards = null;
            base.OnDestroy();
        }

        private void UpdateTimer(long obj)
        {
            var lureWheelManager = Data;
            if (lureWheelManager == null)
                return;

            text_time.text = ConvertTools.ConvertTime2(lureWheelManager.RemainingTime);
        }

        private void InitUI()
        {
            text_time.text = string.Empty;
            p_text.text = string.Empty;
            bubble_final.gameObject.SetActive(false);
        }

        private void InitData()
        {
            if (Data == null) return;
            Data.ShowProgress=null;
        }

        private void ShowUI()
        {
            if (Data == null) return;
            btn_spin.transform.parent.gameObject.SetActive(true);
            if (btn_close)
                btn_close.enabled = true;
            ShowProgressUI();
            ShowBtn();
            text_time.text = ConvertTools.ConvertTime2(Data.RemainingTime);

            _eventAdWheelRewards = Manager.GetEventRewards();
            if (_eventAdWheelRewards == null || _eventAdWheelRewards.Count == 0) return;

            p_wheel.SetData(_eventAdWheelRewards);
            p_wheel.ShowUI();
            var progressRewards = Manager.GetProgressRewards();
            bubble_final.SetData(progressRewards?.FirstOrDefault());
        }

        private void ShowProgressUI()
        {
            for (var i = 0; i < progressObjs.Length; i++) progressObjs[i].SetActive(i < Data.ShowProgress.Count);
        }

        private void ShowBtn()
        {
            var packConfig = Manager.GetPackConfig();
            var iapItem = Manager.Tables.TbIAPItemList?.GetOrDefault(packConfig.IAPID);
            var sKUDetailDataEvent = new SKUDetailDataEvent(iapItem);
            GContext.Publish(sKUDetailDataEvent);
            p_text.text = sKUDetailDataEvent.price;
        }

        private async void OnChlickBuy()
        {
            var packConfig = Manager.GetPackConfig();
            var iapItem = Data.Tables.TbIAPItemList?.GetOrDefault(packConfig.IAPID);

            var rewardIndex = Manager.GetRandomRewardIndex();
            if (_eventAdWheelRewards.Count <= rewardIndex)
                return;
            var reward = _eventAdWheelRewards[rewardIndex];

            var shopBuyTypeData = new ShopBuyTypeData
            {
                type = ShopBuyType.None,
                NoShow = true,
                extraPurcheData =new JObject{  {nameof(HookWheelData), reward.Index } }
            };
            
            var itemDatas = GContext.container.Resolve<PlayerItemData>()
                .GetItemDataByDropIdLureInflation(Data.InflationRate, reward.DropID);
            if (itemDatas == null) return;
            if (iapItem == null)
            {
                GContext.Publish(new ShowData(itemDatas));
                GContext.container.Resolve<PlayerItemData>().AddItem(itemDatas, null);
                OnBuySuccess(reward, rewardIndex);
                return;
            }

            var Result = await GContext.container.Resolve<PlayerShopData>()
                .OnBuy(packConfig.DropID, shopBuyTypeData, iapItem, itemDatas);
            if (Result) OnBuySuccess(reward, rewardIndex);
        }

        private void OnBuySuccess(IWheelReward reward, int index)
        {
            isRotating = true;
            Manager.AddProgress(reward.Index);
            btn_spin.transform.parent.gameObject.SetActive(false);
            btn_close.enabled = false;
            _ = p_wheel.PlayEffect(index, reward,
                () =>
                {
                    isRotating = false;
                    GContext.Publish(new ShowData());
                    p_wheel.ShowUI();
                });
        }

        public async void OnRewardPanelClose(RewardPanelClose e)
        {
            try
            {
                if (_isNeedRefreshUI)
                {
                    Data.IsRoundCompleted = false;
                    if (Data.CurrentRoundCount >= Data.WheelMain.PackManagerID.Count)
                    {
                        UIManager.Instance.DestroyUI(UITypes.EventHookWheelPopupPanel);
                        return;
                    }

                    await RefreshUI();
                }
                else
                {
                    await ShowProgressUIRewardFly();
                }
            }
            catch (Exception exception)
            {
                Debug.LogError($"jsd {exception}");
            }
        }

        private async Task RefreshUI()
        {
            _panelAni.Play("EventHookWheelPopupPanel_out");
            Data.ShowProgress = null;
            _isNeedRefreshUI = false;
            await Awaiters.Seconds(panelOutAniTime);
            ShowUI();
            _panelAni.Play("EventHookWheelPopupPanel_show");
        }

        private async Task ShowProgressUIRewardFly()
        {
            var targetRect = (RectTransform)progressObjs[Data.ShowProgress.Count - 1].transform;
            var request = new BatchedRewardFlyRequest
            {
                Icon = new BatchedRewardFlyRequestIcon
                {
                    iconName = "separate_icon_eventhookwheel"
                },
                StartPoint = new BatchedRewardFlyStartPoint(GettRewardFlySource()),
                EndPoint = new BatchedRewardFlyEndPoint(
                    targetRect.position,
                    rewardFlyTargetIconSize,
                    UIManager.Instance.transform.lossyScale.x
                ),
                IsDestinationRewardStash = true,
                AnimationParamIndex = 0
            };
            DelayShowProgress(RewardFlyBatchCtrl, targetRect);
            await RewardFlyBatchCtrl.OnRewardFlyRequestAsync(request);
            await Awaiters.Seconds(rewardFlyEndAwaitTime);
            await DropProgressReward();
            if (!_isNeedRefreshUI)
            {
                ShowBtn();
                btn_spin.transform.parent.gameObject.SetActive(true);
                if (btn_close)
                    btn_close.enabled = true;
            }
        }

        private async void DelayShowProgress(RewardFlyBatchController ctrl, RectTransform targetRect)
        {
            try
            {
                var param = ctrl.animationParamList.FirstOrDefault();
                await Awaiters.Seconds(param.FlyDuration + param.ShowDuration);
                ShowProgressUI();
                targetRect.gameObject.FindChildGameObject("fx_ui_hookwheel_target_reward").SetActive(true);
            }
            catch (Exception e)
            {
                Debug.LogError($"jsd + {e}");
            }
        }

        private async Task DropProgressReward()
        {
            if (Data is not { IsRoundCompleted: true })
                return;
            _targetAni.Play();
            await Awaiters.Seconds(targetAniAwaitTime);
            GContext.container.Resolve<IDeferredRewardStashService>()?.Flush(RewardType.NormalOne);
            GContext.Publish(new ShowData());
            _isNeedRefreshUI = true;
        }

        private RectTransform GettRewardFlySource()
        {
            var iWheelRewards = _eventAdWheelRewards.FindIndex(x => x.Index == Data.ShowProgress.LastOrDefault());
            return p_wheel.GetRewardFlySource(iWheelRewards);
        }

        #region UI_ELEMENTS

        private GameObject[] progressObjs;
        private RewardItemNew bubble_final;
        private HookWheelRewardComponent p_wheel;
        private TextMeshProUGUI text_time;
        private Button btn_spin;
        private Button btn_close;
        private TextMeshProUGUI p_text;
        private RewardFlyBatchController RewardFlyBatchCtrl;
        private Animation _targetAni;
        private Animation _panelAni;

        #endregion UI_ELEMENTS

        #region SerializeField

        [SerializeField] [Min(0)] private float rewardFlyTargetIconSize = 116f;
        [SerializeField] [Min(0)] private float rewardFlyEndAwaitTime = 0.2f;
        [SerializeField] [Min(0)] private float targetAniAwaitTime = 1.1f;
        [SerializeField] [Min(0)] private float panelOutAniTime = 0.3f;

        #endregion
    }
}