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 EventRankPopupPanel : MonoBehaviour
{
    CanvasGroup canvasGroup;
    FishingEventData _fishingEventData;
    LeadboardData _leadboardData;
    Tables _tables;
    Button btn_close;
    GameObject rewardPanel;
    Button btn_claim;
    Button get_reward;
    Button btn_mask;
    Image bg;
    Button btn_questionmark;
    Image bar;
    RewardItemNew require;
    TMP_Text text_info;
    GameObject text_complete;
    GameObject layout_reward;
    GameObject btn_reward;
    RewardItemNew reward1;
    RewardItemNew reward2;
    RewardItemNew reward;

    TMP_Text text_title;
    TMP_Text text_time;
    GameObject text_end;
    Timer timer;
    GameObject rankRoot;
    PanelScroll scrollRect;
    Transform content;
    GameObject item;
    EventLeadboardItem selfItem;
    GameObject rank;
    GameObject bar_layout;
    GameObject unlock;
    GameObject toprank;
    GameObject toprank_bg_nml;
    GameObject toprank_bg_top3;
    TMP_Text text_unlock_conditions;


    RankTargets targetReward1;
    RankTargets targetReward2;
    RankTargets targetReward3;

    ItemData itemData1;
    ItemData itemData2;
    ItemData itemData3;

    int targetCount1;
    int targetCount2;
    int targetCount3;

    List<BarItemTips> barItemTips = new List<BarItemTips>();

    Image icon_unlock_conditions;
    bool isOpenRank;
    int curSelfRank;
    float itemHigh;
    List<EventLeadboardItemData> datas = new List<EventLeadboardItemData>();
    List<EventLeadboardItem> items = new List<EventLeadboardItem>();

    protected CompositeDisposable disposables = new CompositeDisposable();

    GameObject p_text;
    GameObject text_continue;

    TMP_Text top_text_rank;
    Head top_icon_head;
    RewardItem require_item;

    int SpecialShow = 100;

    RewardItemNew[] top_reward1;

    BgDownload bgDownload;
    private void Awake()
    {
        canvasGroup = GetComponent<CanvasGroup>();
        _fishingEventData = GContext.container.Resolve<FishingEventData>();
        _leadboardData = GContext.container.Resolve<LeadboardData>();
        btn_close = transform.Find("btn_close").GetComponent<Button>();
        rewardPanel = transform.Find("reward").gameObject;
        get_reward = transform.Find("reward/btn_play/btn_green").GetComponent<Button>();
        btn_mask = transform.Find("mask").GetComponent<Button>();
        btn_questionmark = transform.Find("root/rank/btn_questionmark").GetComponent<Button>();

        bg = transform.Find("root/bg").GetComponent<Image>();

        bar = transform.Find("root/bar_layout/bg_bar/bar").GetComponent<Image>();
        require = transform.Find("root/bar_layout/btn_icon/reward").GetComponent<RewardItemNew>();
        text_info = transform.Find("root/bar_layout/bg_info/text_info").GetComponent<TMP_Text>();
        layout_reward = transform.Find("root/bar_layout/bg_bar/layout_reward").gameObject;
        text_complete = transform.Find("root/bar_layout/bg_bar/text_complete").gameObject;
        reward1 = transform.Find("root/bar_layout/bg_bar/layout_reward/reward1").GetComponent<RewardItemNew>();
        reward2 = transform.Find("root/bar_layout/bg_bar/layout_reward/reward2").GetComponent<RewardItemNew>();
        btn_reward = transform.Find("root/bar_layout/btn_reward").gameObject;
        reward = transform.Find("root/bar_layout/btn_reward/reward").GetComponent<RewardItemNew>();

        text_title = transform.Find("root/text_title").GetComponent<TMP_Text>();
        text_time = transform.Find("root/text_time").GetComponent<TMP_Text>();
        text_end = transform.Find("root/text_end").gameObject;
        rankRoot = transform.Find("root/rank").gameObject;
        scrollRect = transform.Find("root/rank/ScrollView").GetComponent<PanelScroll>();
        content = transform.Find("root/rank/ScrollView/Viewport/Content").GetComponent<Transform>();
        selfItem = transform.Find("root/rank/ScrollView/Viewport/Item").GetComponent<EventLeadboardItem>();
        item = transform.Find("root/rank/ScrollView/Viewport/Content/Item").gameObject;

        rank = transform.Find("root/rank").gameObject;
        unlock = transform.Find("root/unlock").gameObject;
        toprank = transform.Find("root/toprank").gameObject;
        btn_claim = transform.Find("root/toprank/btn_claim/btn_green").GetComponent<Button>();
        toprank_bg_nml = transform.Find("root/toprank/bg_nml").gameObject;
        toprank_bg_top3 = transform.Find("root/toprank/bg_top3").gameObject;
        bar_layout = transform.Find("root/bar_layout").gameObject;

        text_unlock_conditions = transform.Find("root/unlock/unlock_conditions/text_unlock_conditions").GetComponent<TMP_Text>();
        icon_unlock_conditions = transform.Find("root/unlock/unlock_conditions/text_unlock_conditions/icon").GetComponent<Image>();
        _tables = GContext.container.Resolve<Tables>();

        barItemTips.Add(transform.Find("root/EventRankTips1").GetComponent<BarItemTips>());
        barItemTips.Add(transform.Find("root/EventRankTips2").GetComponent<BarItemTips>());
        barItemTips.Add(transform.Find("root/EventRankTips3").GetComponent<BarItemTips>());

        p_text = transform.Find("reward/btn_play/btn_green/Ani_Container/p_text").gameObject;
        text_continue = transform.Find("reward/btn_play/btn_green/Ani_Container/text_continue").gameObject;

        top_text_rank = transform.Find("root/toprank/text_rank").GetComponent<TMP_Text>();
        top_icon_head = transform.Find("root/toprank/btn_head").GetComponent<Head>();
        require_item = transform.Find("root/toprank/btn_head/icon_rank").GetComponent<RewardItem>();
        top_reward1 = transform.Find("root/toprank/reward_layout").GetComponentsInChildren<RewardItemNew>();
        bgDownload = transform.Find("root/download").GetComponent<BgDownload>();
    }
    protected void Start()
    {
        btn_close.onClick.AddListener(OnClose);
        btn_mask.onClick.AddListener(OnClose);
        btn_questionmark.OnClickAsObservable().Subscribe(async x =>
        {
            btn_questionmark.enabled = false;
            await UIManager.Instance.ShowUI(UITypes.EventRankInfoPopupPanel);
            btn_questionmark.enabled = true;
        }).AddTo(disposables);

        item.SetActive(false);
        itemHigh = item.GetComponent<RectTransform>().rect.height;
        scrollRect.loop = false;
        get_reward.onClick.AddListener(OnClose);
        btn_claim.onClick.AddListener(OnCloseToprank);
        SetState();
    }
    void OnClickReward(int index)
    {
        barItemTips[index].gameObject.SetActive(true);
    }
    void SetState()
    {
        bool isShowReward = _leadboardData.rankItemDatas != null && _leadboardData.rankItemDatas.Count > 0;
        text_time.gameObject.SetActive(!isShowReward);
        btn_close.gameObject.SetActive(!isShowReward);
        text_end.SetActive(isShowReward);
        rewardPanel.SetActive(isShowReward);
        isOpenRank = _fishingEventData.IsOpenRank() || isShowReward;
        IsRank();
        if (isShowReward)
        {
            InitReward();
        }
        else
        {
            Init();
            reward1.btn_click.onClick.AddListener(() => OnClickReward(0));
            reward2.btn_click.onClick.AddListener(() => OnClickReward(1));
            reward.btn_click.onClick.AddListener(() => OnClickReward(2));
        }
    }
    void OnCloseToprank()
    {
        CurRewardQCount curRewardQCount = new CurRewardQCount();
        GContext.Publish(curRewardQCount);
        if (curRewardQCount.count > 0)
        {
            ShowReward();
        }
        else
            UIManager.Instance.DestroyUI(UITypes.EventRankPopupPanel);
    }
    void SetToprank(List<ItemData> itemDatas)
    {
        rewardPanel.SetActive(false);
        get_reward.onClick.RemoveAllListeners();
        btn_close.onClick.RemoveAllListeners();
        btn_mask.onClick.RemoveAllListeners();
        text_continue.SetActive(false);
        p_text.SetActive(true);
        rank.SetActive(false);
        bar_layout.SetActive(false);
        toprank.SetActive(true);
        toprank_bg_nml.SetActive(selfItem.data.rank > 3);
        toprank_bg_top3.SetActive(selfItem.data.rank <= 3);
        require_item.SetData(selfItem.data.value);
        require_item.text_num.text = ConvertTools.GetNumberString2((int)selfItem.data.value.count);
        top_text_rank.text = LocalizationMgr.GetFormatTextValue("UI_EventChallengeCrocodilePanel_9", selfItem.data.rank);
        top_icon_head.SetData(GContext.container.Resolve<IUserService>().AvatarUrl);
        for (int i = 0; i < top_reward1.Length; i++)
        {
            if (i < itemDatas.Count)
            {
                top_reward1[i].gameObject.SetActive(true);
                top_reward1[i].SetData(itemDatas[i]);
                //top_reward1[i].text_num.text = $"x{ConvertTools.GetNumberString((int)itemDatas[i].count)}";
            }
            else
            {
                top_reward1[i].gameObject.SetActive(false);
            }
        }
        //get_reward.onClick.AddListener(OnCloseToprank);
        //btn_mask.onClick.AddListener(OnCloseToprank);
    }
    private void OnClose()
    {
        if (_leadboardData.rankItemDatas != null && _leadboardData.rankItemDatas.Count > 0)
        {
            var fishingStage = GContext.container.ResolveStage("FishingStage") as FishingStage;
            //目标奖励活动获得的奖励
            fishingStage.NextToQueue(LeadboardData.NextQueueKey);
            CurRewardQCount curRewardQCount = new CurRewardQCount();
            GContext.Publish(curRewardQCount);
            if (curRewardQCount.count > 0)
            {
                GContext.OnEvent<RewardPanelClose>().Subscribe(x =>
                {
                    UIManager.Instance.DestroyUI(UITypes.EventRankPopupPanel);
                }).AddTo(disposables);
                if (selfItem.data != null && selfItem.data.rank <= SpecialShow)
                {
                    SetToprank(_leadboardData.rankItemDatas);
                }
                else
                {
                    ShowReward();
                }
            }
            else
            {
                UIManager.Instance.DestroyUI(UITypes.EventRankPopupPanel);
            }
            _leadboardData.rankItemDatas = null;
        }
        else
        {
            UIManager.Instance.DestroyUI(UITypes.EventRankPopupPanel);
        }
    }

    void ShowReward()
    {
        GContext.Publish(new ShowData());
        canvasGroup.alpha = 0;
    }

    void IsRank()
    {
        rankRoot.SetActive(isOpenRank);
        unlock.gameObject.SetActive(!isOpenRank);
    }

    private void Init()
    {
        selfItem.gameObject.SetActive(false);
        RankTargets rankTarget = _fishingEventData.rankTarget;
        if (rankTarget != null)
        {
            SetReward(rankTarget, _fishingEventData.GetCurRankTarget(), _fishingEventData.rankInit);

            SetEndTime();

            if (isOpenRank)
            {
                GContext.OnEvent<EventRankData>().Subscribe(x =>
                {
                    SetRankData();
                }).AddTo(disposables);
                SetRankData();
            }
        }
    }
    bool isLoading = false;
    async void LoadBg(string BgTitle)
    {
        isLoading = true;
        ShowLoad();
        await GContext.container.Resolve<IUIService>().SetImageSprite(bg, BgTitle, "HomePanel");
        if (isLoading)
        {
            bgDownload.OnLoadSucceed();
        }
        isLoading = false;
    }
    async void ShowLoad()
    {
        bgDownload.gameObject.SetActive(false);
        await Awaiters.Seconds(1);
        if (isLoading)
        {
            bgDownload.gameObject.SetActive(true);
        }
    }
    void SetReward(RankTargets rankTarget, int curCount, RankInit rankInit)
    {
        var tables = GContext.container.Resolve<Tables>();
        Item item = tables.TbItem[rankInit.TokenID];
        GContext.container.Resolve<IUIService>().SetImageSprite(icon_unlock_conditions, item.Icon, "HomePanel");
        text_unlock_conditions.text = LocalizationMgr.GetFormatTextValue("UI_EventRankPopupPanel_1", rankInit.UnlockPoint);
        LoadBg(rankInit.BgTitle);
        PlayerItemData playerItemData = GContext.container.Resolve<PlayerItemData>();
        text_title.text = LocalizationMgr.GetText(rankInit.Title_l10n_key);

        require.SetData(item, isCanClick: true);
        require.text_num.gameObject.SetActive(false);
        var TargetList = rankInit.TargetList;
        int curIndex = TargetList.IndexOf(rankTarget.TaskID);
        text_info.text = LocalizationMgr.GetFormatTextValue("UI_EventRankPopupPanel_2", curIndex, TargetList.Count);

        if (rankTarget.NextTarget <= 0)
        {
            if (curCount >= rankTarget.TokenRequiredB)
            {
                layout_reward.SetActive(false);
                text_complete.SetActive(true);
                btn_reward.SetActive(false);
                bar.fillAmount = 1;
                text_info.text = LocalizationMgr.GetFormatTextValue("UI_EventRankPopupPanel_2", TargetList.Count, TargetList.Count);
                return;
            }
            //最后一个
            targetReward1 = tables.TbRankTargets.GetOrDefault(TargetList[^3]);
            targetReward2 = tables.TbRankTargets.GetOrDefault(TargetList[^2]);
            bar.fillAmount = curCount / ((float)rankTarget.TokenRequiredB * 3) + 0.666f;
        }
        else if (rankTarget.TaskID == TargetList[0])
        {
            //第一个
            targetReward1 = rankTarget;
            targetReward2 = tables.TbRankTargets.GetOrDefault(rankTarget.NextTarget);
            bar.fillAmount = curCount / ((float)rankTarget.TokenRequiredB * 3);
        }
        else
        {
            targetReward1 = tables.TbRankTargets.GetOrDefault(TargetList[curIndex - 1]);
            targetReward2 = rankTarget;
            bar.fillAmount = curCount / ((float)rankTarget.TokenRequiredB * 3) + 0.333f;
        }
        itemData1 = playerItemData.GetItemDataOneLureInflation(_fishingEventData.RankTargetInflation, targetReward1.DropID);
        reward1.SetData(itemData1);
        itemData2 = playerItemData.GetItemDataOneLureInflation(_fishingEventData.RankTargetInflation, targetReward2.DropID);
        reward2.SetData(itemData2);

        var maxCollectingTarget = tables.TbRankTargets.GetOrDefault(TargetList[^1]);
        targetReward3 = maxCollectingTarget;
        itemData3 = playerItemData.GetItemDataOneLureInflation(_fishingEventData.RankTargetInflation, maxCollectingTarget.DropID);
        reward.SetData(itemData3);

        if (rankTarget.TaskID != TargetList[0])
        {
            reward1.SetReceived(true);
            reward1.btn_click.enabled = false;
        }
        if (rankTarget.NextTarget <= 0)
        {
            reward2.SetReceived(true);
            reward2.btn_click.enabled = false;
        }

        //设置tips
        int targetCount = 0;
        for (int i = 0; i < TargetList.Count; i++)
        {
            var targetReward = tables.TbRankTargets.GetOrDefault(TargetList[i]);
            if (targetReward != null)
            {
                targetCount += targetReward.TokenRequiredB;
            }
            if (targetReward.TaskID == targetReward1.TaskID)
            {
                targetCount1 = targetCount;
            }
            if (targetReward.TaskID == targetReward2.TaskID)
            {
                targetCount2 = targetCount;
            }
            if (targetReward.TaskID == targetReward3.TaskID)
            {
                targetCount3 = targetCount;
            }
        }
        reward1.id = 0;
        reward2.id = 0;
        reward.id = 0;
        int allCount = _fishingEventData.GetAllRankTarget();
        barItemTips[0].Init(itemData1, item.Icon, targetCount1, allCount);
        barItemTips[1].Init(itemData2, item.Icon, targetCount2, allCount);
        barItemTips[2].Init(itemData3, item.Icon, targetCount3, allCount);
    }
    void InitReward()
    {
        selfItem.gameObject.SetActive(false);
        var rankTarget = _leadboardData.rankTarget;
        if (rankTarget != null)
        {
            //SpecialShow = _leadboardData.lastEventRank.SpecialShow;
            SetReward(rankTarget, _leadboardData.lastScore, _leadboardData.lastEventRank);

            var userService = GContext.container.Resolve<IUserService>();
            List<RankFormula> rankFormulas = _tables.TbRankFormula.DataList;
            List<int> rewardList = new List<int>();
            RewardData curEventRank = _leadboardData.eventRankReward;
            for (int i = 0; i < rankFormulas.Count; i++)
            {
                if (rankFormulas[i].RankTier == curEventRank.rankLevel)
                {
                    rewardList = rankFormulas[i].RewardList;
                    break;
                }
            }
            int rewardCount = rewardList.Count;
            curSelfRank = -1;
            for (int i = 0; i < curEventRank.ranks.Length; i++)
            {
                EventLeadboardItemData leadboardItemData = new EventLeadboardItemData();
                leadboardItemData.value = new ItemData
                {
                    id = _leadboardData.lastEventRank.TokenID,
                    count = Mathf.FloorToInt(curEventRank.ranks[i].score),
                };
                leadboardItemData.playFabId = curEventRank.ranks[i].id;
                leadboardItemData.isMe = curEventRank.ranks[i].isMe;
                leadboardItemData.rank = curEventRank.ranks[i].rank;
                if (rewardCount > i)
                {
                    RankReward rankReward = _tables.TbRankReward.GetOrDefault(rewardList[i]);
                    if (rankReward != null)
                    {
                        leadboardItemData.itemDatas = GContext.container.Resolve<PlayerItemData>().GetItemDataByDropId/*LureInflation(_fishingEventData.RankTargetInflation,*/(rankReward.DropID);
                    }
                }
                if (curEventRank.ranks[i].isMe)
                {
                    curSelfRank = i;
                    leadboardItemData.playFabId = userService.UserId;
                    leadboardItemData.value.count = _leadboardData.lastAllScore;
                    selfItem.data = leadboardItemData;
                    selfItem.OnInit();
                    text_continue.SetActive(leadboardItemData.rank <= SpecialShow);
                    p_text.SetActive(leadboardItemData.rank > SpecialShow);
                }

                datas.Add(leadboardItemData);
            }
            scrollRect.Init<EventLeadboardItem, EventLeadboardItemData>(itemHigh, item, null, datas);
            SetSelfItem();
        }
    }
    public void SetRankData()
    {
        if (isOpenRank)
        {
            if (GContext.container.Resolve<LeadboardData>().curEventRank == null)
            {
                return;
            }
            var userService = GContext.container.Resolve<IUserService>();
            GetLeaderboardsResp curEventRank = GContext.container.Resolve<LeadboardData>().curEventRank;
            List<RankFormula> rankFormulas = _tables.TbRankFormula.DataList;
            List<int> rewardList = new List<int>();
            for (int i = 0; i < rankFormulas.Count; i++)
            {
                if (rankFormulas[i].RankTier == curEventRank.rankLevel)
                {
                    rewardList = rankFormulas[i].RewardList;
                    break;
                }
            }
            int rewardCount = rewardList.Count;
            curSelfRank = -1;
            datas.Clear();
            for (int i = 0; i < curEventRank.data.Length; i++)
            {
                EventLeadboardItemData leadboardItemData = new EventLeadboardItemData();
                leadboardItemData.value = new ItemData
                {
                    id = _fishingEventData.rankInit.TokenID,
                    count = Mathf.FloorToInt(curEventRank.data[i].score),
                };
                leadboardItemData.playFabId = curEventRank.data[i].id;
                leadboardItemData.isMe = curEventRank.data[i].isMe;
                leadboardItemData.rank = curEventRank.data[i].rank;
                if (rewardCount > i)
                {
                    RankReward rankReward = _tables.TbRankReward.GetOrDefault(rewardList[i]);
                    if (rankReward != null)
                    {
                        leadboardItemData.itemDatas = GContext.container.Resolve<PlayerItemData>().GetItemDataByDropId/*LureInflation(_fishingEventData.RankTargetInflation,*/(rankReward.DropID);
                    }
                }
                if (curEventRank.data[i].isMe)
                {
                    curSelfRank = i;
                    leadboardItemData.playFabId = userService.UserId;
                    leadboardItemData.value.count = _fishingEventData.GetAllRankTarget();
                    selfItem.data = leadboardItemData;
                    selfItem.OnInit();
                }
                datas.Add(leadboardItemData);
            }
            if (datas.Count < 2)
            {
                ToastPanel.Show(LocalizationMgr.GetText("UI_ToastPanel_107"));
            }
            scrollRect.Init<EventLeadboardItem, EventLeadboardItemData>(itemHigh, item, null, datas);
            SetSelfItem();
        }
    }

    void SetSelfItem()
    {
        float selfPos = itemHigh * curSelfRank - scrollRect.viewport.rect.height + itemHigh;
        selfItem.gameObject.SetActive(scrollRect.content.anchoredPosition.y < selfPos && curSelfRank >= 0);
        if (curSelfRank >= 0)
        {
            scrollRect.onValueChanged.AddListener((Vector2 v2) =>
            {
                selfItem.gameObject.SetActive(scrollRect.content.anchoredPosition.y < selfPos);
            });
        }
    }
    void SetEndTime()
    {
        //显示倒计时
        if (timer == null)
        {
            DateTime endTime = _fishingEventData.GetRankEndTime();
            TimeSpan all = endTime - ZZTimeHelper.UtcNow().UtcNowOffset();
            double seconds = all.TotalSeconds;
            timer = this.AttachTimer((float)seconds,
                () => { UIManager.Instance.DestroyUI(UITypes.EventRankPopupPanel); },
                (elapsed) =>
                {
                    TimeSpan now = endTime - ZZTimeHelper.UtcNow().UtcNowOffset();

                    text_time.text = ConvertTools.ConvertTime2(now.Days, now.Hours, now.Minutes, now.Seconds);
                }, useRealTime: true);
        }
    }
    private void OnDestroy()
    {
        disposables?.Dispose();
        disposables = null;
        isLoading = false;
    }
}