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


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<VictoryReward> victoryRewards = new List<VictoryReward>();
        [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;
        Color32 receiveColor = new Color32(200, 200, 200, 128);
        Color32 unReceiveColor = new Color32(255, 255, 255, 255);

        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);
            int remainTime = heavenModel.GetActivityRemainTime();
            RefreshRemainTimeText(remainTime);
            TimeDownMgr.Instance.Begin(TimeDownMgr.CoolTimeType.HeavenBattleReaminTime, remainTime, RefreshRemainTimeText);
        }

        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];
            DisplayVictoryReward();
        }

        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 = SysInfoConfig.Get(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 = SysInfoConfig.Get(gameRecInfo.StrValue1);
            text.text = sysInfo.richText;
            height = text.preferredHeight;
            return true;
        }

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

            UpdateVictoryReward();

            if (victoryCnt >= victoryCntlist[0])
            {
                rewardSlider.value = victoryCnt;
            }
            else
            {
                rewardSlider.value = victoryCntlist[0];
            }
        }

        private void DisplayVictoryReward()
        {
            for (int i = victoryCntlist.Count - 1; i > -1; i--)
            {
                int index = i;
                int victoryNum = victoryCntlist[i];
                XMZZVictoryRewardInfo rewardInfo = heavenModel.heavenAwardDict[victoryNum][0];
                var victoryReward = victoryRewards[index];
                victoryReward.victoryNum.text = Language.Get("XMZZ115", victoryCntlist[i]);
                victoryReward.rewardCount.text = rewardInfo.itemCnt.ToString();
                ItemConfig itemConfig = ItemConfig.Get(rewardInfo.itemId);
                victoryReward.rewardImg.SetSprite(itemConfig.IconKey);
                victoryReward.bgImg.SetItemBackGround(itemConfig.ItemColor);
                if (rewardInfo.itemCnt > 1)
                {
                    victoryReward.rewardCount.gameObject.SetActive(true);
                }
                else
                {
                    victoryReward.rewardCount.gameObject.SetActive(false);
                }
                victoryReward.rewardBtn.RemoveAllListeners();
                victoryReward.rewardBtn.AddListener(() => { ClickRewardIcon(rewardInfo, index); });
            }
        }

        private void UpdateVictoryReward()
        {
            for(int i = 0; i < victoryCntlist.Count; i++)
            {
                int victoryNum = victoryCntlist[i];
                var victoryReward = victoryRewards[i];
                if (HeavenBattleInfo.Instance.IsGetAwardByIndex(i))
                {
                    victoryReward.completeObj.SetActive(true);
                    victoryReward.effect.Stop();
                    victoryReward.bgImg.color = receiveColor;
                }
                else
                {
                    victoryReward.completeObj.SetActive(false);
                    victoryReward.bgImg.color = unReceiveColor;
                    if (victoryNum <= HeavenBattleInfo.Instance.WinCnt)
                    {
                        victoryReward.effect.Play();
                    }
                    else
                    {
                        victoryReward.effect.Stop();
                    }
                }
            }
        }

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

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

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

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

        private void CloseWin()
        {
            Close();
        }

        [Serializable]
        public class VictoryReward
        {
            public Image bgImg;
            public Image rewardImg;
            public Button rewardBtn;
            public GameObject completeObj;
            public UIEffect effect;
            public Text rewardCount;
            public Text victoryNum;
        }
    }
}