using DG.Tweening;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

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 xbOneDesText;
        [SerializeField] Text xbBtnMoneyText;
        [SerializeField] Button xbManyBtn;
        [SerializeField] Text xbManyBtnText;
        [SerializeField] Text xbManyMoneyText;
        [SerializeField] Text xbManyDesText;
        [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;
        [SerializeField] Button skipBtn;
        [SerializeField] GameObject skipImg;
        [Header("控制寻宝转动圈数")]
        [SerializeField] int cycleTimes = 1;
        [Header("开始圈时间间隔")]
        [SerializeField] float startDelayTime = 0.15f;
        [Header("结束圈时间间隔")]
        [SerializeField] float endDelayTime = 0.005f;
        [Header("其他圈时间间隔")]
        [SerializeField] float otherDelayTime = 0.1f;
        [Header("开始圈初始加速度")]
        [SerializeField] float a1 = 0.3f;
        [Header("结束圈初始减速度")]
        [SerializeField] float a2 = 2f;
        [Header("其他圈初始加速度")]
        [SerializeField] float a3 = 0.5f;
        [Header("最大时间间隔")]
        [SerializeField] float maxTimeInter = 0.6f;
        [Header("最小时间间隔")]
        [SerializeField] float minTimeInter = 0.005f;
        [Header("闪烁次数")]
        [SerializeField] public int flashingTimes = 10;
        [Header("单次闪烁时间")]
        [SerializeField] public float flashingTime = 0.2f;

        [Header("得到物品停留时间")]
        [SerializeField] float stopTime = 0.5f;
        [Header("寻宝得到物品动画时间")]
        [SerializeField] float scaleTime = 0.2f;

        [Header("音效播放最短时间")]
        [SerializeField] float minPlayeAudioTime = 0.1f;

        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>(); } }
        PackModel playerPack { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        XBFuncSet funcSet;
        float coolTime = 3;
        private bool IsStartPlayAudio = false;
        private float playeAudioTime = 0;

        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);
            skipBtn.AddListener(ClickSkipBtn);
        }

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

        protected override void OnPreOpen()
        {
            XBModel.StartXBEvent += OnStartXB;
            playerPack.refreshItemCountEvent += 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 LateUpdate()
        {
            base.LateUpdate();
            if (IsStartPlayAudio)
            {
                if (playeAudioTime <= 0)
                {
                    SoundPlayer.Instance.PlayUIAudio(66);
                }
                playeAudioTime += Time.deltaTime;
                if (playeAudioTime > minPlayeAudioTime)
                {
                    playeAudioTime = 0;
                    IsStartPlayAudio = false;
                }
            }
        }
        protected override void OnPreClose()
        {
            XBModel.RefreshAgainXBAct -= RefreshAgainXB;
            XBModel.RefreshRuneXBTimeAct -= RefreshFreeTime;
            XBModel.RefreshXBResultAct -= RefreshXBResult;
            XBModel.RefreshXBTypeInfoAct -= RefreshXBTypeInfo;
            playerPack.refreshItemCountEvent -= RefreshItemCount;
            GlobalTimeEvent.Instance.secondEvent -= RefreshSecond;
            XBModel.StartXBEvent -= OnStartXB;
        }
        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);
                }

            }
            playeAudioTime = 0;
            IsStartPlayAudio = 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];
                xbOneDesText.text = Language.Get("HappyXB106", funcSet.costToolNums[0]);
                xbManyDesText.text = Language.Get("HappyXB106", funcSet.costToolNums[1]);
                ItemConfig itemConfig1 = ItemConfig.Get(funcSet.costToolIds[0]);
                ItemConfig itemConfig2 = ItemConfig.Get(funcSet.costToolIds[1]);
                if (itemConfig1 != null)
                {
                    toolImg1.SetSprite(itemConfig1.IconKey);
                }
                if (itemConfig2 != null)
                {
                    toolImg2.SetSprite(itemConfig2.IconKey);
                }
            }

            RefreshXBTypeInfo();
            RefreshXBTools();
            RefreshSkipUI();
        }

        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);
                    freeXbBtn.gameObject.SetActive(false);
                    xbBtn.gameObject.SetActive(true);
                    freeXBTimeText.text = Language.Get("HappyXB102", TimeUtility.SecondsToHMSCHSRetain((int)time));
                }
            }
            else
            {
                freeXBTimeText.gameObject.SetActive(false);
            }

        }

        private void RefreshSkipUI()
        {
            skipImg.SetActive(XBModel.isJumpRuneXB);
        }

        private void ClickSkipBtn()
        {
            XBModel.isJumpRuneXB = !XBModel.isJumpRuneXB;
            RefreshSkipUI();
            if (XBModel.isJumpRuneXB && XBModel.rangelist.Count > 0)
            {
                StopAllCoroutines();
                ResetXBItemState();
                WindowCenter.Instance.Open<HappyXBGetItemWin>();
            }
        }

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

        public void RefreshXBTools()
        {
            int xbToolCnt = 0;
            int needToolCnt = 0;
            if (XBModel.IsHaveManyXBTool(2, out xbToolCnt, out needToolCnt))
            {
                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()
        {
            XBModel.SendXBManyQuest(PackType.Treasure, 2);
        }

        private void ClickXBBtn()
        {
            XBModel.SendOneXBQuest(PackType.Treasure, 2);
        }

        private void ClickFreeXbBtn()
        {
            if (XBModel.CheckIsEmptyGrid(PackType.Treasure))
            {
                XBModel.SendXBQuest(2, 0, 1);
            }
        }

        private void OnStartXB(int oneOrMany)
        {
            maskObj.SetActive(true);
            if (oneOrMany == 0)
            {
                isXBMany = false;
            }
            else
            {
                isXBMany = true;
            }

        }

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

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

        private void RefreshXBResult()
        {
            if (XBModel.isJumpRuneXB)
            {
                ResetXBItemState();
                WindowCenter.Instance.Open<HappyXBGetItemWin>();
            }
            else
            {
                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);
                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>();
                    }
                });

                XBModel.GetNotifyResult(xbResultItemBasiclist[index].itemId, 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;
            float xbSpeed1 = startDelayTime;
            float xbSpeed2 = endDelayTime;
            float xbSpeed3 = otherDelayTime;
            float xbA1 = a1;
            float XbA2 = a2;
            float xbA3 = a3;
            while (true)
            {
                IsStartPlayAudio = true;
                curSelectIndex += 1;
                curSelectIndex %= xbItemlist.Count;
                if (curSelectIndex <= 0)
                {
                    curSelectIndex = xbItemlist.Count;
                }
                for (int i = 0; i < xbItemlist.Count; i++)
                {
                    xbItemlist[i].RefreshSelectIcon(curSelectIndex);
                }

                int remainIndex = targetIndexs[targetIndex].gridIndex - curSelectIndex;
                if (remainIndex < 0)
                {
                    remainIndex = xbItemlist.Count + remainIndex;
                }
                if (curSelectIndex == targetIndexs[targetIndex].gridIndex)
                {
                    if (cycle > cycleTimes)
                    {
                        for (int i = 0; i < xbItemlist.Count; i++)
                        {
                            xbItemlist[i].CheckToFlashing(2, curSelectIndex);
                        }

                        if (isXBMany)
                        {
                            if (targetIndex >= targetIndexs.Count - 1)
                            {
                                StartCoroutine(PlaySelectItemAni(true));
                            }
                            else
                            {

                                StartCoroutine(PlaySelectItemAni(false, targetIndex, curSelectIndex));
                            }
                        }
                        else
                        {
                            StartCoroutine(PlaySelectItemAni(true));
                        }
                        break;
                    }
                    cycle += 1;
                }
                switch (targetIndex)
                {
                    case 0:
                        xbSpeed1 -= xbA1 * 0.05f;
                        if (xbSpeed1 <= minTimeInter)
                        {
                            xbSpeed1 = minTimeInter;
                        }
                        yield return new WaitForSeconds(xbSpeed1);
                        break;
                    case 9:
                        if (cycle > cycleTimes && remainIndex <= 4)
                        {
                            xbSpeed2 += XbA2 * 0.05f;
                            if (xbSpeed2 >= maxTimeInter)
                            {
                                xbSpeed2 = maxTimeInter;
                            }
                        }
                        else
                        {
                            xbSpeed2 = endDelayTime;
                        }
                        yield return new WaitForSeconds(xbSpeed2);
                        break;
                    default:
                        xbSpeed3 -= xbA3 * 0.05f;
                        if (xbSpeed3 <= minTimeInter)
                        {
                            xbSpeed3 = minTimeInter;
                        }
                        yield return new WaitForSeconds(xbSpeed3);
                        break;
                }
            }
        }

        IEnumerator PlaySelectItemAni(bool isEndXB, int targetIndex = 0, int curSelectIndex = 0)
        {
            XBGetItemConfig getItemConfig = XBModel.GetXBItemConfigByType(2);
            if (getItemConfig != null && getItemConfig.LuckyGridNum == curSelectIndex)
            {
                yield return new WaitForSeconds(flashingTime * flashingTimes);
            }
            else
            {
                yield return new WaitForSeconds(stopTime);
            }

            if (isEndXB)
            {
                if (targetIndexs.Count > 1)
                {
                    ShowXBResultCtrl(targetIndexs.Count - 1);
                }
                else
                {
                    XBGetItem xbItem = targetIndexs[targetIndexs.Count - 1];
                    XBModel.GetNotifyResult(xbItem.itemId, xbItem.count);
                    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);
            }
        }
    }
}