using asap.core;
using cfg;
using game;
using GameCore;
using System;
using System.Collections.Generic;
using TMPro;
using UniRx;
using UnityEngine;
using UnityEngine.UI;

public class ComebackChainsPopupPanel : MonoBehaviour
{
    const int PhaseItemCount = 7;
    List<ComeBackItem> comeBackItems = new List<ComeBackItem>();
    GameObject panel1;
    GameObject panel2;
    GameObject text_info;
    Button btn_close;
    Tables tables;
    EventWelcomeBackManager manager;
    GameObject clickMask;
    protected CompositeDisposable disposables = new CompositeDisposable();
    Button reward_button;
    Button btn_gray;
    TMP_Text p_text;
    List<ComeBackData> comeBackDatas = new List<ComeBackData>();
    Timer timer;
    Timer timerAll;
    TMP_Text text_time;
    DateTime nextClaimTime;
    DateTime endTime;
    private void Awake()
    {
        tables = GContext.container.Resolve<Tables>();
        manager = new EventWelcomeBackManager();
        panel1 = transform.Find("root/reward_layout1").gameObject;
        panel2 = transform.Find("root/reward_layout2").gameObject;
        text_info = transform.Find("reward/text_info").gameObject;
        ComeBackItem comeBackItem;
        for (int i = 1; i <= PhaseItemCount; i++)
        {
            comeBackItem = transform.Find("root/reward_layout1/reward" + i).GetComponent<ComeBackItem>();
            comeBackItem.Init();
            comeBackItems.Add(comeBackItem);
        }
        for (int i = 1; i <= PhaseItemCount; i++)
        {
            comeBackItem = transform.Find("root/reward_layout2/reward" + i).GetComponent<ComeBackItem>();
            comeBackItem.Init();
            comeBackItems.Add(comeBackItem);
        }
        text_time = transform.Find("root/text_time").GetComponent<TMP_Text>();
        btn_close = transform.Find("btn_close").GetComponent<Button>();
        reward_button = transform.Find("reward/btn_play/btn_green").GetComponent<Button>();
        btn_gray = transform.Find("reward/btn_play/btn_gray").GetComponent<Button>();
        p_text = transform.Find("reward/btn_play/btn_gray/Ani_Container/p_text").GetComponent<TMP_Text>();
        clickMask = transform.Find("clickMask").gameObject;
    }
    protected void Start()
    {
        WelcomeBackData welcomeBackData = manager.LoadData();
        clickMask.SetActive(false);
        btn_close.onClick.AddListener(OnClose);
        reward_button.onClick.AddListener(OnClickReward);
        var dataList = tables.TbEventWelcomeBackTimeReward.DataList;
        string title = LocalizationMgr.GetText("UI_ComebackGiftPopupPanel_7");
        for (int i = 0; i < dataList.Count; i++)
        {
            ComeBackData comeBackData = new ComeBackData();
            comeBackData.index = i;
            comeBackData.title = string.Format(title, (i % PhaseItemCount) + 1);
            comeBackData.timeReward = dataList[i];
            comeBackDatas.Add(comeBackData);
        }
        ShowPhaseItems();
        ShowRewardPanel();
        StartTimer();
    }

    void ShowPhaseItems()
    {
        int start = manager.welcomeBackData.received < PhaseItemCount ? 0 : PhaseItemCount;
        int end = manager.welcomeBackData.received < PhaseItemCount ? Math.Min(PhaseItemCount, comeBackDatas.Count) : comeBackDatas.Count;
        string baseTimeStr = manager.welcomeBackData.received < PhaseItemCount
            ? manager.welcomeBackData.openTime
            : manager.welcomeBackData.rewardTime;
        int lastClaimIndex = -1;
        int nextTimeIndex = -1;
        for (int i = start; i < end; i++)
        {
            comeBackDatas[i].state = manager.GetState(i, comeBackDatas[i].timeReward);
            if (comeBackDatas[i].state == 1)
            {
                lastClaimIndex = i;
            }
            if (nextTimeIndex < 0 && comeBackDatas[i].state == 0)
            {
                nextTimeIndex = i;
                if (!string.IsNullOrEmpty(baseTimeStr))
                    nextClaimTime = DateTime.Parse(baseTimeStr).AddMinutes(comeBackDatas[i].timeReward.Time);
            }
            comeBackItems[i].ShowData(comeBackDatas[i], OnClickClaim, false);
        }
        int glowIndex = lastClaimIndex >= 0 ? lastClaimIndex : nextTimeIndex;
        if (glowIndex >= 0)
        {
            comeBackItems[glowIndex].ShowData(comeBackDatas[glowIndex], OnClickClaim, true);
        }
    }
    void ShowRewardPanel()
    {
        var curReward = manager.GetCurRefreshTime();
        bool canClaim = true;
        if (curReward != null)
        {
            var curTime = ZZTimeHelper.UtcNow();
            var claimTime = System.DateTime.Parse(manager.welcomeBackData.rewardTime);
            claimTime = claimTime.AddMinutes(curReward.Time);
            if (claimTime > curTime)
            {
                canClaim = false;
            }
        }
        reward_button.gameObject.SetActive(canClaim);
        btn_gray.gameObject.SetActive(!canClaim);
        panel1.SetActive(manager.welcomeBackData.received < PhaseItemCount);
        panel2.SetActive(manager.welcomeBackData.received >= PhaseItemCount);
        text_info.SetActive(manager.welcomeBackData.received < PhaseItemCount);
        SetEndTime();
    }

    void StartTimer()
    {
        if (timer == null && nextClaimTime > ZZTimeHelper.UtcNow())
        {
            var now = nextClaimTime - ZZTimeHelper.UtcNow();
            timer = this.AttachTimer((float)now.TotalSeconds, RefreshTimer,
                (elapsed) =>
                {
                    now = nextClaimTime - ZZTimeHelper.UtcNow();
                    p_text.text = LocalizationMgr.GetFormatTextValue("UI_ComebackGiftPopupPanel_9", ConvertTools.ConvertTime(now));
                }, useRealTime: true);
        }
    }

    void RefreshTimer()
    {
        GContext.Publish(new ClaimComeBack() { state = 1 });
        reward_button.gameObject.SetActive(true);
        btn_gray.gameObject.SetActive(false);
        timer?.Cancel();
        timer = null;
        RefreshItems();
        StartTimer();
    }

    void RefreshItems()
    {
        int start = manager.welcomeBackData.received < PhaseItemCount ? 0 : PhaseItemCount;
        int end = manager.welcomeBackData.received < PhaseItemCount ? Math.Min(PhaseItemCount, comeBackDatas.Count) : comeBackDatas.Count;
        string baseTimeStr = manager.welcomeBackData.received < PhaseItemCount
            ? manager.welcomeBackData.openTime
            : manager.welcomeBackData.rewardTime;
        int lastNewClaimIndex = -1;
        int nextWaitIndex = -1;
        for (int i = start; i < end; i++)
        {
            if (comeBackDatas[i].state != 0) continue;
            int newState = manager.GetState(i, comeBackDatas[i].timeReward);
            if (newState == 1)
            {
                comeBackDatas[i].state = 1;
                comeBackItems[i].ShowData(comeBackDatas[i], OnClickClaim, false);
                lastNewClaimIndex = i;
            }
            else
            {
                if (!string.IsNullOrEmpty(baseTimeStr))
                    nextClaimTime = DateTime.Parse(baseTimeStr).AddMinutes(comeBackDatas[i].timeReward.Time);
                nextWaitIndex = i;
                break;
            }
        }
        int refreshGlowIndex = lastNewClaimIndex >= 0 ? lastNewClaimIndex : nextWaitIndex;
        if (refreshGlowIndex >= 0)
        {
            comeBackItems[refreshGlowIndex].ShowData(comeBackDatas[refreshGlowIndex], OnClickClaim, true);
        }
    }

    void SetEndTime()
    {
        endTime = manager.GetCurrentRoundEndTime();
        TimeSpan now = endTime - ZZTimeHelper.UtcNow();
        double seconds = now.TotalSeconds;
        if (seconds <= 0)
        {
            OnClose();
            return;
        }
        timerAll?.Cancel();
        timerAll = null;
        timerAll =
        this.AttachTimer((float)seconds,
            () => { OnClose(); },
            (elapsed) =>
            {
                now = endTime - ZZTimeHelper.UtcNow();
                text_time.text = ConvertTools.ConvertTime2(now.Days, now.Hours, now.Minutes, now.Seconds);
            }, useRealTime: true);
    }

    void OnClickClaim(ComeBackData backData)
    {
        OnClickReward();
    }

    async void OnClickReward()
    {
        int oldIndex = manager.welcomeBackData.received;
        var claimedDropIds = manager.ClaimReward();
        if (claimedDropIds == null || claimedDropIds.Count == 0)
        {
            return;
        }
#if AGG
        using (var e = GEvent.GameEvent("event_welcomeback"))
        {
            e.AddContent("event_count", manager.welcomeBackData.eventCount)
             .AddContent("reward_list", string.Join(",", claimedDropIds));
        }
#endif
        GContext.Publish(new ClaimComeBack() { state = 2 });
        int newIndex = manager.welcomeBackData.received;
        for (int i = oldIndex; i < newIndex; i++)
        {
            comeBackDatas[i].state = 2;
            comeBackItems[i].Refresh();
        }
        clickMask.SetActive(true);
        timer?.Cancel();
        timer = null;
        bool switchPhase = oldIndex < PhaseItemCount && newIndex >= PhaseItemCount;
        CurRewardQCount curRewardQCount = new CurRewardQCount();
        GContext.Publish(curRewardQCount);
        if (switchPhase && curRewardQCount.count > 0)
        {
            await Awaiters.Seconds(2);
            GContext.OnEvent<RewardPanelClose>().First().Subscribe(_ =>
            {
                ShowPhaseItems();
                ShowRewardPanel();
                StartTimer();
                clickMask.SetActive(false);
            }).AddTo(disposables);
            GContext.Publish(new ShowData());
        }
        else
        {
            await Awaiters.Seconds(2);
            if (switchPhase)
                ShowPhaseItems();
            else
                RefreshItems();
            ShowRewardPanel();
            StartTimer();
            if (curRewardQCount.count > 0)
            {
                GContext.Publish(new ShowData());
            }
            clickMask.SetActive(false);
        }
    }

    void OnClose()
    {
        UIManager.Instance.DestroyUI(gameObject.name);
    }
}