using DG.Tweening;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using TableConfig;
using UnityEngine;
using UnityEngine.UI;

namespace Snxxz.UI
{
    public class RuneXBWin : Window
    {
        [SerializeField] Transform horTopContent;
        [SerializeField] Transform horBottomContent;
        [SerializeField] Transform verLeftContent;
        [SerializeField] Transform verRightContent;
        [SerializeField] Button xbBtn;
        [SerializeField] Text xbBtnText;
        [SerializeField] Text xbBtnMoneyText;
        [SerializeField] Button xbManyBtn;
        [SerializeField] Text xbManyBtnText;
        [SerializeField] Text xbManyMoneyText;
        [SerializeField] Button freeXbBtn;
        [SerializeField] GameObject luckDesObj;
        [SerializeField] Text luckText;
        [SerializeField] Text freeXBTimeText;
        [SerializeField] Transform getXBItemParent;
        [SerializeField] GameObject xbResultObj;
        [SerializeField] Button lookRuneBtn;
        [SerializeField] GameObject maskObj;
        [SerializeField] GameObject toolXBShowObj;
        [SerializeField] Text toolNumText;
        [SerializeField] Image toolImg1;
        [SerializeField] Image toolImg2;

        [Header("控制寻宝转动圈数")]
        [SerializeField] int cycleTimes = 1;
        [Header("时间间隔")]
        [SerializeField] float delayTime = 0.1f;
        [Header("得到物品停留时间")]
        [SerializeField] float stopTime = 0.5f;
        [Header("寻宝得到物品动画时间")]
        [SerializeField] float scaleTime = 0.2f;

        List<XBItemCell> xbItemlist = new List<XBItemCell>();

        List<XBGetItem> targetIndexs;
        int curSelectIndex = 0;
        bool isHaveFreeTime = false;
        List<XBGetItem> getItemlist;
        int xbOneMoney = 0;
        int xbManyMoney = 0;
        List<GameObject> xbResultObjlist = new List<GameObject>();
        List<CommonItemBaisc> xbResultItemBasiclist = new List<CommonItemBaisc>();
        HappyXBModel XBModel { get { return ModelCenter.Instance.GetModel<HappyXBModel>(); } }
        PlayerPackModel playerPack { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }
        XBFuncSet funcSet;
        float coolTime = 3;
        protected override void BindController()
        {
            xbItemlist.Clear();
            int length = horTopContent.childCount;
            for(int i = 0; i < length; i++)
            {
                XBItemCell xbItem = horTopContent.GetChild(i).GetComponent<XBItemCell>();
                xbItemlist.Add(xbItem);
            }
            length = verRightContent.childCount;
            for (int i = 0; i < length; i++)
            {
                XBItemCell xbItem = verRightContent.GetChild(i).GetComponent<XBItemCell>();
                xbItemlist.Add(xbItem);
            }
            length = horBottomContent.childCount;
            for (int i = length - 1; i > - 1; i--)
            {
                XBItemCell xbItem = horBottomContent.GetChild(i).GetComponent<XBItemCell>();
                xbItemlist.Add(xbItem);
            }

            length = verLeftContent.childCount;
            for (int i = length - 1; i > -1; i--)
            {
                XBItemCell xbItem = verLeftContent.GetChild(i).GetComponent<XBItemCell>();
                xbItemlist.Add(xbItem);
            }

        }
        protected override void AddListeners()
        {
            xbBtn.AddListener(ClickXBBtn);
            xbManyBtn.AddListener(ClickXBManyBtn);
            freeXbBtn.AddListener(ClickFreeXbBtn);
            lookRuneBtn.AddListener(ClickLookRuneBtn);
        }

        private void ClickLookRuneBtn()
        {
            WindowCenter.Instance.Open<RunePreviewWin>();
        }

        protected override void OnPreOpen()
        {
            playerPack.RefreshItemCountAct += RefreshItemCount;
            XBModel.RefreshAgainXBAct += RefreshAgainXB;
            XBModel.RefreshRuneXBTimeAct += RefreshFreeTime;
            XBModel.RefreshXBTypeInfoAct += RefreshXBTypeInfo;
            XBModel.RefreshXBResultAct += RefreshXBResult;
            GlobalTimeEvent.Instance.secondEvent += RefreshSecond;
            getItemlist = XBModel.GetXBGetItemByID(2).Values.ToList();
            isHaveFreeTime = XBModel.IsHaveFreeXBTime(2);
            InitUI();
            TimeDownMgr.CoolTimeData data;
            if (TimeDownMgr.Instance.Get(TimeDownMgr.CoolTimeType.HappyFreeBestXB, out data))
            {
                data.func = RefreshFreeTime;
                RefreshFreeTime(Mathf.CeilToInt(data.duration - data.time));
            }
            else
            {
                RefreshFreeTime(0);
            }
        }

        protected override void OnAfterOpen()
        {
           
        }

        protected override void OnPreClose()
        {
            XBModel.RefreshAgainXBAct -= RefreshAgainXB;
            XBModel.RefreshRuneXBTimeAct -= RefreshFreeTime;
            XBModel.RefreshXBResultAct -= RefreshXBResult;
            XBModel.RefreshXBTypeInfoAct -= RefreshXBTypeInfo;
            playerPack.RefreshItemCountAct -= RefreshItemCount;
            GlobalTimeEvent.Instance.secondEvent -= RefreshSecond;
        }
        protected override void OnAfterClose()
        {

        }

        private void RefreshSecond()
        {
            if (XBModel.isXBCoolTime)
            {
                coolTime -= 1;
                if (coolTime < 0)
                {
                    XBModel.isXBCoolTime = false;
                    ResetXBItemState();
                    coolTime = 3;
                    DebugEx.Log("请求超时服务端未回包");
                }
            }
            else
            {
                coolTime = 3;
            }
        }

        private void InitUI()
        {
          
            for (int i = 0; i < xbItemlist.Count;i++)
            {
                if(getItemlist.Count > i)
                {
                    xbItemlist[i].gameObject.SetActive(true);
                    xbItemlist[i].SetModel(getItemlist[i].itemId, getItemlist[i].count, getItemlist[i].gridIndex);
                }
                else
                {
                    xbItemlist[i].gameObject.SetActive(false);
                }
              
            }
            maskObj.SetActive(false);
            luckDesObj.SetActive(true);
            getXBItemParent.gameObject.SetActive(false);
            xbResultObj.SetActive(false);
            freeXbBtn.gameObject.SetActive(false);
            funcSet = XBModel.GetXBFuncSet(2);
            if(funcSet != null)
            {
                xbBtnText.text = Language.Get("HappyXB101", funcSet.xbNums[0]);
                xbManyBtnText.text = Language.Get("HappyXB101", funcSet.xbNums[1]);
                xbBtnMoneyText.text = funcSet.xbPrices[0].ToString();
                xbManyMoneyText.text = funcSet.xbPrices[1].ToString();
                xbOneMoney = funcSet.xbPrices[0];
                xbManyMoney = funcSet.xbPrices[1];
                ItemConfig itemConfig1 = ConfigManager.Instance.GetTemplate<ItemConfig>(funcSet.costToolIds[0]);
                ItemConfig itemConfig2 = ConfigManager.Instance.GetTemplate<ItemConfig>(funcSet.costToolIds[1]);
                if (itemConfig1 != null)
                {
                    toolImg1.SetSprite(itemConfig1.IconKey);
                }
                if (itemConfig2 != null)
                {
                    toolImg2.SetSprite(itemConfig2.IconKey);
                }
            }

            RefreshXBTypeInfo();
            RefreshXBTools();
        }

        private void RefreshFreeTime(float time)
        {
            if(isHaveFreeTime)
            {
                if (XBModel.IsHaveFreeXB(2))
                {
                    freeXBTimeText.gameObject.SetActive(false);
                    freeXbBtn.gameObject.SetActive(true);
                    xbBtn.gameObject.SetActive(false);
                }
                else
                {
                    freeXBTimeText.gameObject.SetActive(true);
                    freeXBTimeText.text = Language.Get("HappyXB102", TimeUtility.SecondsToHMSCHSRetain((int)time));
                    if (!XBModel.IsHaveOneXBTool(2))
                    {
                        freeXbBtn.gameObject.SetActive(false);
                        xbBtn.gameObject.SetActive(true);
                    }
                }
            }
            else
            {
                freeXBTimeText.gameObject.SetActive(false);
            }
         
        }

        private void RefreshItemCount(PackType type, int index, int id)
        {
            if (type != PackType.rptItem || !XBModel.CheckIsXBTool(id, 2)) return;
            RefreshXBTools();
        }

        public void RefreshXBTools()
        {
            if (XBModel.IsHaveOneXBTool(2))
            {
                freeXbBtn.gameObject.SetActive(true);
                xbBtn.gameObject.SetActive(false);
            }
            else
            {
                freeXbBtn.gameObject.SetActive(false);
                xbBtn.gameObject.SetActive(true);

            }

            int xbToolCnt = 0;
            if (XBModel.IsHaveManyXBTool(2, out xbToolCnt))
            {
                toolXBShowObj.SetActive(true);
                toolNumText.text = StringUtility.Contact("x", xbToolCnt);
            }
            else
            {
                toolXBShowObj.SetActive(false);
            }
        }

        private void RefreshAgainXB(HappXBTitle title, int xbType)
        {
            if (title != HappXBTitle.Rune) return;
            if (xbType == 0) ClickXBBtn();
            else if (xbType == 1) ClickXBManyBtn();
        }

        bool isXBMany = false;
        private void ClickXBManyBtn()
        {
            if (XBModel.CheckIsEmptyGrid(PackType.rptRunePack))
            {
                int toolCnt = 0;
                if (XBModel.IsHaveManyXBTool(2, out toolCnt))
                {
                    int needToolCnt = funcSet.costToolNums[1] - toolCnt;
                    int needMoney = needToolCnt * xbOneMoney;
                    if (needToolCnt > 0)
                    {
                        ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("HappyXBCostTools", funcSet.costToolNums[1], needMoney, needToolCnt), (bool isOk) =>
                        {
                            if (isOk)
                            {
                                CheckXBManyLimit(needMoney);
                            }
                            return;
                        });
                    }
                    else
                    {
                        CheckXBManyLimit(xbManyMoney);
                    }

                }
                else
                {
                    CheckXBManyLimit(xbManyMoney);
                }
            }
        }

        private void CheckXBManyLimit(int needMoney)
        {
            if (UIHelper.GetMoneyCnt(1) >= (ulong)needMoney)
            {
                maskObj.SetActive(true);
                isXBMany = true;
                XBModel.SendXBQuest(2, 1, 0);
            }
            else
            {
                WindowCenter.Instance.Open<RechargeTipWin>();
            }
        }

        private void ClickXBBtn()
        {
            if(XBModel.CheckIsEmptyGrid(PackType.rptRunePack))
            {
                if (UIHelper.GetMoneyCnt(1) >= (ulong)xbOneMoney)
                {
                    maskObj.SetActive(true);
                    isXBMany = false;
                    XBModel.SendXBQuest(2, 0, 0);
                }
                else
                {
                    WindowCenter.Instance.Open<RechargeTipWin>();
                }
            }
        }

        private void ClickFreeXbBtn()
        {
            if (XBModel.CheckIsEmptyGrid(PackType.rptRunePack))
            {
                maskObj.SetActive(true);
                isXBMany = false;
                if (XBModel.IsHaveFreeXB(2))
                {
                    XBModel.SendXBQuest(2, 0, 1);
                }
                else if (XBModel.IsHaveOneXBTool(2))
                {
                    XBModel.SendXBQuest(2, 0, 2);
                }
            }
        }

        private void RefreshXBTypeInfo()
        {
            XBTypeInfo typeInfo = XBModel.GetXBInfoByType(2);
            if (typeInfo == null) return;

            luckText.text = typeInfo.luckValue.ToString();
        }

        private void RefreshXBResult()
        {
            CreateGetItem();
            targetIndexs = XBModel.rangelist;
            StartCoroutine(PlayXBAni(0,0));
        }

        private void CreateGetItem()
        {
            List<XBGetItem> xbResultlist = XBModel.rangelist;
            if (xbResultlist.Count < 2) return;
            luckDesObj.SetActive(false);
            getXBItemParent.gameObject.SetActive(true);
            DestroyGetItemlist();
            xbResultObjlist.Clear();
            xbResultItemBasiclist.Clear();
            for (int i = 0; i < xbResultlist.Count; i++)
            {
                XBGetItem xbItem = xbResultlist[i];
                GameObject item = Instantiate(xbResultObj);
                item.transform.SetParent(getXBItemParent);
                item.transform.localPosition = Vector3.zero;
                item.transform.localScale = Vector3.one;
                item.name = StringUtility.Contact("XBItem", i);
                item.gameObject.SetActive(true);
                CommonItemBaisc itemBasic = item.transform.Find("CommonItemCell").GetComponent<CommonItemBaisc>();
                ItemCellModel cellModel = new ItemCellModel(xbItem.itemId, false, (ulong)xbItem.count, xbItem.isBind);
                itemBasic.Init(cellModel);
                itemBasic.transform.localScale = Vector3.zero;
                itemBasic.transform.localPosition = Vector3.zero;
                xbResultObjlist.Add(item);
                itemBasic.gameObject.SetActive(false);
                xbResultItemBasiclist.Add(itemBasic);
            }
        }

        private void ShowXBResultCtrl(int index)
        {
            if (index < xbResultItemBasiclist.Count)
            {
                xbResultItemBasiclist[index].gameObject.SetActive(true);
                xbResultItemBasiclist[index].transform.DOScale(new Vector3(1, 1, 1), scaleTime).OnComplete(() =>
                {
                    if (index == xbResultItemBasiclist.Count - 1)
                    {
                        ResetXBItemState();
                        WindowCenter.Instance.Open<HappyXBGetItemWin>();
                    }
                }); ;
                if(xbResultItemBasiclist[index].itemConfig != null)
                {
                    XBModel.GetNotifyResult(xbResultItemBasiclist[index].itemConfig.ID, int.Parse(xbResultItemBasiclist[index].countText.text));
                }
            }
        }

        private void DestroyGetItemlist()
        {
            for (int i = 0; i < xbResultObjlist.Count; i++)
            {
                Destroy(xbResultObjlist[i]);
            }
        }

        IEnumerator PlayXBAni(int targetIndex, int curSelectIndex)
        {
            int cycle = 1;
            while (true)
            {
                curSelectIndex += 1;
                curSelectIndex %= xbItemlist.Count;
                if (curSelectIndex <= 0)
                {
                    curSelectIndex = xbItemlist.Count;
                }
                for (int i = 0; i < xbItemlist.Count; i++)
                {
                    if (isXBMany)
                    {
                        xbItemlist[i].RefreshSelectIcon(curSelectIndex);
                    }
                    else
                    {
                        xbItemlist[i].RefreshSelectIcon(curSelectIndex);
                    }
                }

                if (curSelectIndex == targetIndexs[targetIndex].gridIndex)
                {
                    if (cycle > cycleTimes)
                    {
                        if (isXBMany)
                        {
                            if (targetIndex >= targetIndexs.Count - 1)
                            {
                                StartCoroutine(PlaySelectItemAni(true));
                            }
                            else
                            {

                                StartCoroutine(PlaySelectItemAni(false, targetIndex, curSelectIndex));
                            }
                        }
                        else
                        {
                            StartCoroutine(PlaySelectItemAni(true));
                        }
                        break;
                    }
                    cycle += 1;
                }
                yield return new WaitForSeconds(delayTime);
            }
        }

        IEnumerator PlaySelectItemAni(bool isEndXB, int targetIndex = 0, int curSelectIndex = 0)
        {
            yield return new WaitForSeconds(stopTime);
            if (isEndXB)
            {
                if (targetIndexs.Count > 1)
                {
                    ShowXBResultCtrl(targetIndexs.Count - 1);
                }
                else
                {
                    ResetXBItemState();
                    WindowCenter.Instance.Open<HappyXBGetItemWin>();
                }
            }
            else
            {
                ShowXBResultCtrl(targetIndex);
                StartCoroutine(PlayXBAni(targetIndex + 1, curSelectIndex));
            }
        }

        private void ResetXBItemState()
        {
            luckDesObj.SetActive(true);
            maskObj.SetActive(false);
            getXBItemParent.gameObject.SetActive(false);
            for (int i = 0; i < xbItemlist.Count; i++)
            {
                xbItemlist[i].RefreshSelectIcon(0);
            }
        }
    }
}