using asap.core;
using cfg;
using DG.Tweening;
using GameCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using UniRx;
using UnityEngine;
using UnityEngine.UI;
public class GetBuffPosEvent
{
    public Vector3 Pos;
}

public class HomeBuffPanel : MonoBehaviour
{
    RectTransform defaultStyle;
    RectTransform targetStyle;
    HomeBuffItem btn_buff_prefab;
    HomeBuffItem btn_buff_target;
    HomeBuffItem btn_buff;
    Animation anim;
    Button btn_open;
    Transform buffRoot;
    List<HomeBuffItem> homeBuffItems = new List<HomeBuffItem>();
    int curCount;
    BuffDataCenter buffDataCenter;
    FishingData fishingData;
    List<FishBuffTimeData> fishBuffTimeData;
    FishBuffTimeData targetBuffTimeData;
    IDisposable _disposable;

    float buffShowTime = 2f; // Buff显示时间
    float buffFlyTime = 0.5f; // Buff飞行时间

    private void Awake()
    {
        fishingData = GContext.container.Resolve<FishingData>();
        defaultStyle = transform.Find("style/defaultStyle").GetComponent<RectTransform>();
        targetStyle = transform.Find("style/targetStyle").GetComponent<RectTransform>();
        btn_buff_prefab = transform.Find("layout_buff/buffRoot/btn_buff_prefab").GetComponent<HomeBuffItem>();
        btn_buff = transform.Find("buff/btn_buff_beilv").GetComponent<HomeBuffItem>();
        anim = GetComponent<Animation>();
        btn_open = transform.Find("layout_buff").GetComponent<Button>();
        buffRoot = transform.Find("layout_buff/buffRoot");
    }
    private void Start()
    {
        btn_open.onClick.AddListener(OpenPanel);
    }
    private void OnEnable()
    {
        _disposable?.Dispose();
        _disposable = GContext.OnEvent<EventHomeBuffPanelRefresh>().Subscribe(_ => RefreshPanel());

        btn_buff_prefab.gameObject.SetActive(false);
        buffDataCenter = GContext.container.Resolve<BuffDataCenter>();

        ShowBuff();
        SetCollectionTargetWeightBuffShow();
    }

    public async void OpenPanel()
    {
        await UIManager.Instance.ShowUI(new UIType("FishingBuffLayoutPopupPanel"));
    }

    bool isShowBuff = false;
    async void PlayAnim()
    {
        fishBuffTimeData = fishBuffTimeData.Where(x => x.isEnd == false).ToList();
        //fishBuffTimeData.Sort((a, b) => b.SortID.CompareTo(a.SortID));
        var fishData = fishBuffTimeData.Where(x => !x.isNew).ToList();
        if (fishData.Count == 0)
        {
            btn_buff.gameObject.SetActive(false);
            btn_open.gameObject.SetActive(true);

            anim.Play();
            return;
        }
        var item = Instantiate(btn_buff_prefab.gameObject, buffRoot);
        var homeBuffItem = item.GetComponent<HomeBuffItem>();
        homeBuffItems.Add(homeBuffItem);

        if (targetBuffTimeData != null && fishData[0].buffID == targetBuffTimeData.buffID)
        {
            btn_buff_target = homeBuffItem;
            homeBuffItem.gameObject.SetActive(false);
            homeBuffItem.InitPanel(fishData[0], "", targetStyle);
            ShowBuffTarget();
        }
        else
        {
            homeBuffItem.InitPanel(fishData[0], "", defaultStyle);
        }
        await Awaiters.Seconds(buffShowTime);
        //播放动画

        btn_buff.gameObject.SetActive(false);
        btn_open.gameObject.SetActive(true);

        anim.Play();
    }
    public async Task BuffShow()
    {
        HomeBuffPopupPanel homeBuffPopupPanel = null;
        try
        {

            if (isShowBuff)
            {
                return;
            }
            if (buffDataCenter == null) return;
            var showFishBuffIds = buffDataCenter.showFishBuffIds;
            if (showFishBuffIds.Count == 0)
            {
                return;
            }
            ShowBuff();

            isShowBuff = true;
            for (int i = 0; i < showFishBuffIds.Count; i++)
            {
                FishBuffTimeData newBuffTimeData = showFishBuffIds[i];
                if (btn_buff_prefab == null)
                {
                    return;
                }
                HomeBuffItem newHomeBuffItem = null;
                if (curCount == 0 || (!newBuffTimeData.isNew && curCount == 1))
                {
                    btn_buff.gameObject.SetActive(false);
                    btn_open.gameObject.SetActive(false);
                    newHomeBuffItem = btn_buff;
                }
                else
                {
                    int showCount = 0;
                    if (!newBuffTimeData.isNew)
                    {
                        for (int j = homeBuffItems.Count - 1; j >= 0; j--)
                        {
                            if (homeBuffItems[j].gameObject.activeSelf)
                            {
                                if (homeBuffItems[j].buffTimeData.buffID == newBuffTimeData.buffID)
                                {
                                    newHomeBuffItem = homeBuffItems[j];
                                    break;
                                }
                                showCount++;
                                if (showCount >= 4)
                                {
                                    homeBuffItems[j].gameObject.SetActive(false);
                                    break;
                                }
                            }
                        }
                    }
                    else
                    {
                        if (curCount == 1)
                        {
                            PlayAnim();
                        }
                        for (int j = homeBuffItems.Count - 1; j >= 0; j--)
                        {
                            if (homeBuffItems[j].gameObject.activeSelf)
                            {
                                showCount++;
                                homeBuffItems[j].gameObject.SetActive(showCount < 4);
                            }
                        }
                    }
                    if (newHomeBuffItem == null)
                    {
                        var item = Instantiate(btn_buff_prefab.gameObject, buffRoot);
                        newHomeBuffItem = item.GetComponent<HomeBuffItem>();
                        homeBuffItems.Add(newHomeBuffItem);
                    }
                }
                newHomeBuffItem.InitPanel(newBuffTimeData, "", defaultStyle);
                Transform Ani_ContainerSou = newHomeBuffItem.transform.Find("Ani_Container");
                if (newBuffTimeData.isNew)
                {
                    curCount++;
                    Ani_ContainerSou.gameObject.SetActive(false);
                }
                Transform Ani_Container = Instantiate(Ani_ContainerSou.gameObject, newHomeBuffItem.transform).transform;
                newBuffTimeData.isNew = false;
                var go = await UIManager.Instance.ShowUI(UITypes.HomeBuffPopupPanel);
                homeBuffPopupPanel = go.GetComponent<HomeBuffPopupPanel>();
                if (homeBuffPopupPanel != null)
                {
                    homeBuffPopupPanel.Init(newBuffTimeData);
                    await Awaiters.Seconds(buffShowTime);
                    homeBuffPopupPanel.Hide();
                }
                if (newHomeBuffItem != null)
                {
                    newHomeBuffItem.gameObject.SetActive(true);
                    Ani_Container.gameObject.SetActive(true);
                }
                else if (btn_buff_prefab == null)
                {
                    UIManager.Instance.DestroyUI(UITypes.HomeBuffPopupPanel);
                    return;
                }

                GetBuffPosEvent getBuffPosEvent = new GetBuffPosEvent();
                GContext.Publish(getBuffPosEvent);
                Ani_Container.position = getBuffPosEvent.Pos;
                Ani_Container.localScale = Vector3.one * 1.660156f / newHomeBuffItem.transform.localScale.x;
                Ani_Container.DOScale(Vector3.one, buffFlyTime);
                Ani_Container.DOLocalMove(Vector3.zero, buffFlyTime);
                newBuffTimeData.addDown = 0;
                await Awaiters.Seconds(buffFlyTime);
                if (btn_buff_prefab == null)
                {
                    UIManager.Instance.DestroyUI(UITypes.HomeBuffPopupPanel);
                    return;
                }
                Ani_ContainerSou.gameObject.SetActive(true);
                Ani_Container.gameObject.SetActive(false);
            }
            showFishBuffIds.Clear();
            if (homeBuffPopupPanel != null)
            {
                homeBuffPopupPanel.Close();
            }
            isShowBuff = false;
        }
        catch (Exception e)
        {
            if (homeBuffPopupPanel != null)
            {
                homeBuffPopupPanel.Close();
            }
            Debug.LogError(e);
        }
    }

    void ShowBuff(int showCount = 4)
    {
        fishBuffTimeData = buffDataCenter.GetGroupBuff();
        int mapId = fishingData.MapId;
        var mapBuffTimeData = buffDataCenter.GetMapBuffTimeData(mapId);
        if (mapBuffTimeData != null)
        {
            fishBuffTimeData.Add(mapBuffTimeData);
        }
        targetBuffTimeData = buffDataCenter.GetBuffData<CollectionTargetWeight>();
        if (targetBuffTimeData != null)
        {
            fishBuffTimeData.Add(targetBuffTimeData);
        }

        fishBuffTimeData = fishBuffTimeData.Where(x => x.isEnd == false).ToList();
        fishBuffTimeData.Sort((a, b) => b.SortID.CompareTo(a.SortID));
        var fishBuffData = fishBuffTimeData.Where(x => !x.isNew).ToList();
        int dataCount = fishBuffData.Count;
        if (dataCount < showCount)
        {
            showCount = dataCount;
        }
        curCount = showCount;

        int itemsCount = homeBuffItems.Count;

        if (showCount == 1)
        {
            btn_buff.gameObject.SetActive(true);
            btn_open.gameObject.SetActive(false);
            var homeBuffItem = btn_buff;
            if (targetBuffTimeData != null && fishBuffData[0].buffID == targetBuffTimeData.buffID)
            {
                btn_buff_target = homeBuffItem;
                homeBuffItem.gameObject.SetActive(false);
                homeBuffItem.InitPanel(fishBuffData[0], "", targetStyle);
            }
            else
            {
                homeBuffItem.InitPanel(fishBuffData[0], "", defaultStyle);
            }
            return;
        }
        else
        {
            for (int i = 0; i < itemsCount; i++)
            {
                homeBuffItems[i].gameObject.SetActive(false);
            }
            //anim.Play();
            btn_open.gameObject.SetActive(curCount > 0);
            btn_buff.gameObject.SetActive(false);
        }
        for (int i = 0; i < showCount; i++)
        {
            HomeBuffItem homeBuffItem;
            if (itemsCount > i)
            {
                homeBuffItem = homeBuffItems[i];
            }
            else
            {
                var item = Instantiate(btn_buff_prefab.gameObject, buffRoot);
                homeBuffItem = item.GetComponent<HomeBuffItem>();
                homeBuffItems.Add(homeBuffItem);
            }
            if (targetBuffTimeData != null && fishBuffData[i].buffID == targetBuffTimeData.buffID)
            {
                btn_buff_target = homeBuffItem;
                homeBuffItem.gameObject.SetActive(false);
                homeBuffItem.InitPanel(fishBuffData[i], "", targetStyle);
            }
            else
            {
                homeBuffItem.gameObject.SetActive(true);
                homeBuffItem.InitPanel(fishBuffData[i], "", defaultStyle);
            }
        }
    }
    async void SetCollectionTargetWeightBuffShow()
    {
        if (fishingData.isAddTargetBuff)
        {
            await Awaiters.Until(() => fishingData.isShowTargetPanel);
            fishingData.isShowTargetPanel = false;
            fishingData.isAddTargetBuff = false;
            await Awaiters.Seconds(2.5f);
            Transform Ani_Container = btn_buff_prefab.transform.Find("Ani_Container");
            if (btn_buff_target != null)
            {
                Ani_Container = btn_buff_target.transform.Find("Ani_Container");
            }
            GetBuffPosEvent getBuffPosEvent = new GetBuffPosEvent();
            GContext.Publish(getBuffPosEvent);
            Ani_Container.position = getBuffPosEvent.Pos;
            Ani_Container.DOLocalMove(Vector3.zero, 1);
        }
        ShowBuffTarget();
    }
    void ShowBuffTarget()
    {
        if (btn_buff_target != null)
        {
            CollectingTargetInit targetWeightInit = GContext.container.Resolve<FishingEventData>().collectingTargetInit;

            if (targetWeightInit != null)
            {
                btn_buff_target.InitPanel(targetBuffTimeData, targetWeightInit.BuffIcon, targetStyle);
            }
        }
        GContext.Publish(new BuffChangeEvent());
    }
    private void RefreshPanel()
    {
        if (isShowBuff)
        {
            return;
        }
        

        ShowBuff();
        ShowBuffTarget();
    }

    private void OnDisable()
    {
        _disposable?.Dispose();
        _disposable = null;
    }
}
public class EventHomeBuffPanelRefresh
{

}