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

namespace Snxxz.UI
{
    public class HeavenBattleWin : Window
    {
        #region 成员变量
        [SerializeField] ScrollerController _batterInfoCtrl;
        [SerializeField] Button campRewardBtn;
        //[SerializeField] Text campAwardText;
        [SerializeField] Button _closeBtn;
        [SerializeField] RichText text;      
        [SerializeField] Text curCampText;
        [SerializeField] Text camp1ScoreText;
        [SerializeField] Text camp2ScoreText;
        [SerializeField] Text remainTimeText;
        [SerializeField] Slider rewardSlider;
        [SerializeField] GameObject singleReward;
        [SerializeField] Text victoryCntText;
        [SerializeField] Text getScoreText;
        [SerializeField] Button matchBtn;
        [SerializeField] Text matchCntText;
        [SerializeField] Button ruleBtn;
        [SerializeField] GameObject bettingTip;
        [SerializeField] List<Text> rewardlist = new List<Text>();
        [SerializeField] List<Image> rewardIconlist = new List<Image>();
        [SerializeField] List<Image> rewardBglist = new List<Image>();
        [SerializeField] List<Button> rewardBtnlist = new List<Button>();
        [SerializeField] List<Text> rewardItemCntlist = new List<Text>();
        [SerializeField] List<string> batterInfolist = new List<string>();
        [SerializeField] Button achieveBtn;
        #endregion

        HeavenBattleModel _heavenModel;
        HeavenBattleModel heavenModel
        {
            get { return _heavenModel ?? (_heavenModel = ModelCenter.Instance.GetModel<HeavenBattleModel>()); }
        }

        DungeonModel m_DungeonModel;
        DungeonModel dungeonModel { get { return m_DungeonModel ?? (m_DungeonModel = ModelCenter.Instance.GetModel<DungeonModel>()); } }

        //日常活动
        DailyQuestModel _dailyQuestModel;
        public DailyQuestModel dailyQuestModel
        {
            get { return _dailyQuestModel ?? (_dailyQuestModel = ModelCenter.Instance.GetModel<DailyQuestModel>()); }
        }

        ItemTipsModel _itemTipsModel;
        ItemTipsModel itemTipsModel { get { return _itemTipsModel ?? (_itemTipsModel = ModelCenter.Instance.GetModel<ItemTipsModel>()); } }

        List<int> victoryCntlist = new List<int>();
        List<GameRecInfo> reclist = null;
        private int remainTimes;
        private int totalTimes;
        private readonly int dungeonId = 14;

        private readonly int BATTLEINFO_TYPE = 0;
        private float refreshBetTime = 2;

        protected override void BindController()
        {
            _batterInfoCtrl.OnRefreshCell += RefreshBatterInfo;
            _batterInfoCtrl.OnGetDynamicSize += OnGetDynamicSize;
        }

        protected override void AddListeners()
        {
            _closeBtn.AddListener(CloseWin);
            ruleBtn.AddListener(ClickRuleBtn);
            matchBtn.AddListener(ClickMatchBtn);
            achieveBtn.AddListener(ClickAchieveBtn);
        }

        protected override void OnPreOpen()
        {
            heavenModel.RefreshGameRecInfoAct += RefreshBattleInfo;
            dungeonModel.dungeonRecordChangeEvent += RefreshEnterTimes;
            heavenModel.RefreshBattleInfoAct += RefreshCampUI;
            heavenModel.RefreshPlayerBattleInfoAct += RefreshPlayerInfoUI;
            heavenModel.SendCampSoreQuest();
            heavenModel.SendBattleInfoQuest();
            Init();
        }

        protected override void OnAfterOpen()
        {
            //this.transform.SetAsLastSibling();
            RefreshPlayerInfoUI();
            RefreshBattleInfo(BATTLEINFO_TYPE);
        }

        protected override void OnPreClose()
        {
            heavenModel.RefreshBattleInfoAct -= RefreshCampUI;
            heavenModel.RefreshPlayerBattleInfoAct -= RefreshPlayerInfoUI;
            dungeonModel.dungeonRecordChangeEvent -= RefreshEnterTimes;
            heavenModel.RefreshGameRecInfoAct -= RefreshBattleInfo;
        }

        protected override void OnAfterClose()
        {
           
        }

        private void Init()
        {
            bettingTip.SetActive(false);
            if (heavenModel.campVicRewardDict != null)
            {
                campRewardBtn.RemoveAllListeners();
                campRewardBtn.AddListener(()=>
                {
                    WindowCenter.Instance.Open<XMZZCampVicRewardWin>();
                });
            }

            RefreshCampUI();

            if(HeavenBattleInfo.Instance.Faction == 0)
            {
                heavenModel.SendSignQuest();
            }

            RefreshEnterTimes(dungeonId);
            victoryCntlist = heavenModel.heavenAwardDict.Keys.ToList();
            rewardSlider.minValue = victoryCntlist[0];
            rewardSlider.maxValue = victoryCntlist[victoryCntlist.Count - 1];
            int remainTime = heavenModel.GetActivityRemainTime();
            RefreshRemainTimeText(remainTime);
            TimeDownMgr.Instance.Begin(TimeDownMgr.CoolTimeType.HeavenBattleReaminTime, remainTime, RefreshRemainTimeText);

            for (int i = victoryCntlist.Count - 1; i > -1; i--)
            {
                XMZZVictoryRewardInfo rewardInfo = heavenModel.heavenAwardDict[victoryCntlist[i]][0];
                int index = i;
                rewardlist[i].text = Language.Get("XMZZ115", victoryCntlist[i]);
                if(rewardInfo.itemCnt > 1)
                {
                    rewardItemCntlist[i].gameObject.SetActive(true);
                    rewardItemCntlist[i].text = rewardInfo.itemCnt.ToString();
                }
                else
                {
                    rewardItemCntlist[i].gameObject.SetActive(false);
                }
              
                ItemConfig itemConfig = Config.Instance.Get<ItemConfig>(rewardInfo.itemId);
                rewardIconlist[i].SetSprite(itemConfig.IconKey);
                rewardBglist[i].SetItemBackGround(itemConfig.ItemColor);
                rewardBtnlist[i].RemoveAllListeners();
                rewardBtnlist[i].AddListener(() => { ClickRewardIcon(rewardInfo, index); });
            }
        }

        private void RefreshRemainTimeText(float time)
        {
            remainTimeText.text = TimeUtility.SecondsToMS((int)time);
            if(time <= 0)
            {
                CloseImmediately();
            }
        }


        private void RefreshEnterTimes(int id)
        {
            if (id != dungeonId) return;

            totalTimes = dailyQuestModel.GetDailyQuestTotalTimes(dungeonId);
            remainTimes = totalTimes - dailyQuestModel.GetDailyQuestCompletedTimes(dungeonId);
            matchCntText.text = StringUtility.Contact("(",remainTimes, "/", totalTimes,")");
        }

        private void RefreshCampUI()
        {
            HeavenBattleInfo battleInfo = HeavenBattleInfo.Instance;
            camp1ScoreText.text = battleInfo.Score1.ToString();
            camp2ScoreText.text = battleInfo.Score2.ToString();
        }

        private void RefreshPlayerInfoUI()
        {
            HeavenBattleInfo battleInfo = HeavenBattleInfo.Instance;
            string campStr = "";
            switch(battleInfo.Faction)
            {
                case 1:
                    campStr = Language.Get("XMZZ102");
                    break;
                case 2:
                    campStr = Language.Get("XMZZ103");
                    break;
            }
            curCampText.text = campStr.ToString();
            SetRewardSlider(battleInfo.WinCnt);
            victoryCntText.text = Language.Get("XMZZ105", battleInfo.WinCnt);
            getScoreText.text = Language.Get("XMZZ106", battleInfo.PlayerScore);
        }

        private void RefreshBattleInfo(int type)
        {
            if (type != BATTLEINFO_TYPE) return;

            CreateBatterInfo();
        }

        private void CreateBatterInfo()
        {
            _batterInfoCtrl.lockType = EnhanceLockType.LockVerticalBottom;
            _batterInfoCtrl.Refresh();
            reclist = heavenModel.GetBatterInfoListByType(BATTLEINFO_TYPE);
            if(reclist != null)
            {
                int i = 0;
                for (i = 0; i < reclist.Count; i++)
                {
                    _batterInfoCtrl.AddCell(ScrollerDataType.Header, i);
                }
            }
          
            _batterInfoCtrl.Restart();
        }

        private void RefreshBatterInfo(ScrollerDataType type, CellView cell)
        {
            RichText info = cell.GetComponent<RichText>();
            GameRecInfo gameRecInfo = reclist[cell.index];
            SysInfoConfig sysInfo = Config.Instance.Get<SysInfoConfig>(gameRecInfo.StrValue1);
            info.SetExtenalData(gameRecInfo.value3list);
            info.text = sysInfo.richText;
        }

        private bool OnGetDynamicSize(ScrollerDataType type, int index, out float height)
        {
            GameRecInfo gameRecInfo = reclist[index];
            SysInfoConfig sysInfo = Config.Instance.Get<SysInfoConfig>(gameRecInfo.StrValue1);
            text.text = sysInfo.richText;
            height = text.preferredHeight;
            return true;
        }

        private void SetRewardSlider(int victoryCnt)
        {
            if (victoryCntlist == null) return;

            RefreshRewardIconState();

            if (victoryCnt >= victoryCntlist[0])
            {
                rewardSlider.value = victoryCnt;
            }
            else
            {
                rewardSlider.value = victoryCntlist[0];
            }
            //StartCoroutine(SetSliderValue(getValue,1));
        }

        private void RefreshRewardIconState()
        {
            for(int i = 0; i < victoryCntlist.Count; i++)
            {
                Image btnColor = rewardBtnlist[i].GetComponent<Image>();
                GameObject completeIcon = rewardBtnlist[i].transform.Find("completeIcon").gameObject;
                UIEffect effect = rewardBtnlist[i].transform.Find("UIEffect").GetComponent<UIEffect>();
                if (HeavenBattleInfo.Instance.IsGetAwardByIndex(i))
                {
                    completeIcon.SetActive(true);
                    effect.Stop();
                    btnColor.color = new Color32(200,200,200,128);
                    btnColor.transform.localRotation = Quaternion.Euler(0,0,0);
                }
                else
                {
                    completeIcon.SetActive(false);
                    btnColor.color = new Color32(255, 255, 255, 255);
                    if(victoryCntlist[i] <= HeavenBattleInfo.Instance.WinCnt)
                    {
                        effect.Play();
                    }
                    else
                    {
                        effect.Stop();
                        btnColor.transform.localRotation = Quaternion.Euler(0, 0, 0);
                    }
                }
            }
           
        }

        private void ClickRewardIcon(XMZZVictoryRewardInfo info,int index)
        {
            if(victoryCntlist[index] <= HeavenBattleInfo.Instance.WinCnt
                && !HeavenBattleInfo.Instance.IsGetAwardByIndex(index))
            {
                heavenModel.SendGetAwardQuest(victoryCntlist[index]);
            }
            else
            {
                ItemAttrData attrData = new ItemAttrData(info.itemId,false,(ulong)info.itemCnt,-1,info.isBind);
                itemTipsModel.SetItemTipsModel(attrData);
            }
        }

        private void ClickRuleBtn()
        {
            //WindowCenter.Instance.Open<HowToPlayWin>();
        }

        private void ClickMatchBtn()
        {
            dungeonModel.SingleChallengeDungeon(dungeonModel.currentDungeon);
            CloseWin();
        }

        IEnumerator SetSliderValue(float value,float delayTime)
        {
            bool isChange = true;
            float speed = (value - rewardSlider.value) / delayTime;
            float sliderValue = rewardSlider.value;
            float time = 0;
            while (isChange)
            {
                time += Time.deltaTime;
                rewardSlider.value = sliderValue + speed * time;
                DebugEx.Log("进度：" + rewardSlider.value);
                if(rewardSlider.value >= value)
                {
                    isChange = false;
                }
                yield return new WaitForEndOfFrame();
            }       
        }

        private void ClickAchieveBtn()
        {
            WindowCenter.Instance.Open<XMZZAchieveWin>();
        }

        private void CloseWin()
        {
            Close();
        }

    }
}