//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, November 20, 2017
//--------------------------------------------------------


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

namespace Snxxz.UI
{

    public class RuneMosaicWin : Window
    {
        [SerializeField] List<RuneDisplay> runeHoleDatas;
        [SerializeField] List<Button> runeHoleBtns;
        [SerializeField] RectTransform m_ContainerSelectRune;

        [SerializeField] Button m_RuneLevelUpBtn;
        [SerializeField] Text m_LevelUpBtnTxt;
        [SerializeField] Text m_ReplaceBtnTxt;
        [SerializeField] Button m_RuneReplaceBtn;
        [SerializeField] Button m_RunePreviewBtn;

        [SerializeField] Image presentRuneImg;
        [SerializeField] Text presentRuneNameTxt;
        [SerializeField] Text presentRuneAttrTxt;

        //[SerializeField] RectTransform m_ContainerLevelUp;
        [SerializeField] RectTransform m_ContainerLvUp1;
        [SerializeField] RectTransform m_ContainerLvUp2;
        [SerializeField] RectTransform m_ContainerItem;
        [SerializeField] RectTransform m_ContaienrMaxLevel;
        [SerializeField] Text runeLevelUpAttr1;
        [SerializeField] Text runeLevelUpAttr2;
        [SerializeField] Text runeLevelUpAttrNum1;
        [SerializeField] Text runeLevelUpAttrNum2;
        [SerializeField] Text runeLevelUpItemNum;

        [SerializeField] RectTransform m_ContainerGetRune;
        [SerializeField] Button m_GotoGetRuneBtn;

        [SerializeField] Text m_RuneUnlockTip;
        [SerializeField] UIEffect m_RuneLvUpEffect;

        Color m_LevelUpCacheColor;

        RuneModel m_Model;
        RuneModel model
        {
            get
            {
                return m_Model ?? (m_Model = ModelCenter.Instance.GetModel<RuneModel>());
            }
        }

        bool m_IsRuneLvUp = false;
        #region Built-in
        protected override void BindController()
        {
            m_LevelUpCacheColor = m_LevelUpBtnTxt.color;
        }

        protected override void AddListeners()
        {
            m_RuneReplaceBtn.onClick.AddListener(OnRuneReplaceBtn);
            m_RuneLevelUpBtn.onClick.AddListener(OnRuneUpBtn);
            m_RunePreviewBtn.onClick.AddListener(OnRunePreviewBtn);
            m_GotoGetRuneBtn.onClick.AddListener(OnGotoGetRune);
            for (int i = 0; i < runeHoleBtns.Count; i++)
            {
                var _index = i;
                runeHoleBtns[i].onClick.AddListener(() =>
                {
                    OnRuneHoleClick(_index);
                });
            }
        }

        protected override void OnPreOpen()
        {
            model.OnRefreshRuneHole += OnRuneHoleRefresh;
            model.OnRefreshRuneExp += OnUpdateRuneHoleInfo;

            m_RuneLevelUpBtn.gameObject.SetActive(false);
            m_RuneReplaceBtn.gameObject.SetActive(false);
            m_ContainerGetRune.gameObject.SetActive(false);
            OpenOrCloseSelect(false);
            model.sltRuneHole = -1;
            foreach (var _hole in runeHoleDatas)
            {
                _hole.SetSelect(false);
            }
            InitRuneHoles();
        }

        protected override void OnAfterOpen()
        {
            if (!HandleAchievement())
            {
                OnRuneHoleClick(CheckOpenSelect());
            }
        }

        protected override void OnPreClose()
        {
            model.OnRefreshRuneHole -= OnRuneHoleRefresh;
            model.OnRefreshRuneExp -= OnUpdateRuneHoleInfo;
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        private void OnGotoGetRune()
        {
            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.RuneTower);
        }

        bool HandleAchievement()
        {
            if (AchievementGoto.achievementType == AchievementGoto.RuneLevelUp)
            {
                int _hole = 0;
                if(model.CanLevelUpRune(out _hole))
                {
                    OnRuneHoleClick(_hole);
                    var _effect = AchievementGuideEffectPool.Require(1);
                    _effect.transform.SetParentEx(m_RuneLevelUpBtn.transform, Vector3.zero, Vector3.zero, Vector3.one);
                    return true;
                }
                else
                {
                    SysNotifyMgr.Instance.ShowTip("Achievement_45");
                }
                AchievementGoto.achievementType = 0;
            }
            var _color = AchievementGoto.guideAchievementId == AchievementGoto.EquipRune1 ? 1 :
                AchievementGoto.guideAchievementId == AchievementGoto.EquipRune2 ? 2 : 0;
            if (_color > 0)
            {
                int _hole = 0;
                if (model.CanEquipRune(_color, out _hole))
                {
                    OnRuneHoleClick(_hole);
                    var _effect = AchievementGuideEffectPool.Require(1);
                    _effect.transform.SetParentEx(m_RuneReplaceBtn.transform, Vector3.zero, Vector3.zero, Vector3.one);
                    return true;
                }
                else
                {
                    SysNotifyMgr.Instance.ShowTip("Achievement_44");
                }
                AchievementGoto.guideAchievementId = 0;
            }
            return false;
        }

        void OpenOrCloseSelect(bool _open)
        {
            m_ContainerSelectRune.gameObject.SetActive(_open);
            m_RuneLevelUpBtn.interactable = _open;
            m_LevelUpBtnTxt.color = _open ? m_LevelUpCacheColor : Color.grey;
        }

        int CheckOpenSelect()
        {
            for (int i = 0; i < 8; i++)
            {
                if (model.GetRedpoint(i).state == RedPointState.Simple)
                {
                    return i;
                }
            }
            return 0;
        }

        void OnRuneHoleClick(int _hole)
        {
            if (model.IsRuneHoleOpen(_hole))
            {
                //if (model.sltRuneHole == _hole && model.GetHoleRune(_hole) == null)
                //{
                //    WindowCenter.Instance.Open<RunePackWin>();
                //    return;
                //}
                for (int i = 0; i < runeHoleDatas.Count; i++)
                {
                    if (i != _hole)
                    {
                        runeHoleDatas[i].SetSelect(false);
                        runeHoleDatas[i].redpoint.gameObject.SetActive(true);
                    }
                }
                model.sltRuneHole = _hole;
                m_RuneLevelUpBtn.gameObject.SetActive(true);
                m_RuneReplaceBtn.gameObject.SetActive(true);
                OnUpdateRuneHoleInfo();
                runeHoleDatas[_hole].SetSelect(true);
                runeHoleDatas[_hole].redpoint.gameObject.SetActive(false);
                m_ReplaceBtnTxt.text = model.GetHoleRune(_hole) != null ? Language.Get("RuneMosaic_6") : Language.Get("KnapS120");
            }
            else
            {
                int[] towerArray = model.runeUnlockArray;
                RuneTowerFloorConfig cfg = Config.Instance.Get<RuneTowerFloorConfig>(towerArray[_hole]);
                var tower = Config.Instance.Get<RuneTowerConfig>(cfg.TowerId);
                SysNotifyMgr.Instance.ShowTip("RuneUnlock", StringUtility.Contact(tower.TowerName, cfg.FloorName));
            }
        }

        private void OnUpdateRuneHoleInfo()
        {
            model.runeLevelUpRedpoint.state = RedPointState.None;
            model.runeReplaceRedpoint.state = RedPointState.None;
            if (model.sltRuneHole == -1)
            {
                return;
            }
            RuneData data = model.GetHoleRune(model.sltRuneHole);

            var _redpoint = model.GetRedpoint(model.sltRuneHole);
            if (_redpoint.state == RedPointState.Simple)
            {
                if (data == null)
                {
                    model.runeReplaceRedpoint.state = RedPointState.Simple;
                }
                else if (model.CanEquipBetterRune(model.sltRuneHole))
                {
                    model.runeReplaceRedpoint.state = RedPointState.Simple;
                }
                else
                {
                    model.runeLevelUpRedpoint.state = RedPointState.Simple;
                }
            }

            OpenOrCloseSelect(false);
            if (data == null)
            {
                m_ContainerGetRune.gameObject.SetActive(true);
                return;
            }
            m_ContainerGetRune.gameObject.SetActive(false);
            m_LevelUpBtnTxt.color = Color.grey;
            OpenOrCloseSelect(true);
            var _runeCfg = Config.Instance.Get<RuneConfig>(data.id);
            bool _doubleProperty = _runeCfg.AttrType.Length > 1;
            m_ContainerLvUp2.gameObject.SetActive(_doubleProperty);
            var _itemCfg = Config.Instance.Get<ItemConfig>(data.id);
            presentRuneImg.SetSprite(_itemCfg.IconKey);
            presentRuneAttrTxt.text = model.GetRuneAttrStr(data.id, data.lv);
            presentRuneNameTxt.text = StringUtility.Contact(_itemCfg.ItemName, Language.Get("Z1024", data.lv));
            presentRuneNameTxt.color = UIHelper.GetUIColor(_itemCfg.ItemColor);

            var _propertyCfg = Config.Instance.Get<PlayerPropertyConfig>(_runeCfg.AttrType[0]);
            var _propertyValue = model.GetRuneAttrVal(data.id, data.lv, _runeCfg.AttrType[0]);
            runeLevelUpAttr1.text = StringUtility.Contact(_propertyCfg.Name, "  ", "+", UIHelper.ReplacePercentage(_propertyValue, _propertyCfg.ISPercentage),
                _propertyCfg.ISPercentage == 1 ? "%" : string.Empty);

            bool _isRuneMaxLv = data.lv >= model.GetRuneMaxLevelByItem(data.id);
            runeLevelUpAttrNum1.gameObject.SetActive(!_isRuneMaxLv);
            if (!_isRuneMaxLv)
            {
                _propertyValue = model.GetRuneAttrVal(data.id, data.lv + 1, _runeCfg.AttrType[0]);
                runeLevelUpAttrNum1.text = StringUtility.Contact("+", UIHelper.ReplacePercentage(_propertyValue, _propertyCfg.ISPercentage),
                            _propertyCfg.ISPercentage == 1 ? "%" : string.Empty);
            }

            if (_doubleProperty)
            {
                _propertyCfg = Config.Instance.Get<PlayerPropertyConfig>(_runeCfg.AttrType[1]);
                _propertyValue = model.GetRuneAttrVal(data.id, data.lv, _runeCfg.AttrType[1]);
                runeLevelUpAttr2.text = StringUtility.Contact(_propertyCfg.Name, "  ", "+", UIHelper.ReplacePercentage(_propertyValue, _propertyCfg.ISPercentage),
                             _propertyCfg.ISPercentage == 1 ? "%" : string.Empty);
                runeLevelUpAttrNum2.gameObject.SetActive(!_isRuneMaxLv);
                if (!_isRuneMaxLv)
                {
                    _propertyValue = model.GetRuneAttrVal(data.id, data.lv + 1, _runeCfg.AttrType[1]);
                    runeLevelUpAttrNum2.text = StringUtility.Contact("+", UIHelper.ReplacePercentage(_propertyValue, _propertyCfg.ISPercentage),
                                _propertyCfg.ISPercentage == 1 ? "%" : string.Empty);
                }
            }
            int _levelUpExp = model.GetRuneNeedExp(data.id, data.lv);
            m_RuneLevelUpBtn.interactable = !_isRuneMaxLv /*&& model.RuneSplinters >= _levelUpExp*/;
            m_LevelUpBtnTxt.color = m_RuneLevelUpBtn.interactable ? m_LevelUpCacheColor : Color.grey;
            runeLevelUpItemNum.gameObject.SetActive(!_isRuneMaxLv);
            m_ContainerLvUp1.gameObject.SetActive(!_isRuneMaxLv);
            m_ContainerItem.gameObject.SetActive(!_isRuneMaxLv);
            m_RuneLevelUpBtn.gameObject.SetActive(!_isRuneMaxLv);
            //m_ContainerLevelUp.gameObject.SetActive(!_isRuneMaxLv);
            m_ContaienrMaxLevel.gameObject.SetActive(_isRuneMaxLv);
            runeLevelUpItemNum.text = StringUtility.Contact(UIHelper.GetTextColorByItemColor(
                model.RuneSplinters >= _levelUpExp ? TextColType.Green : TextColType.Red
                , model.RuneSplinters.ToString(), true), "/", _levelUpExp);
        }

        void InitRuneHoles()
        {
            int towerCnt = model.GetOpenTowerCnt();
            int[] towerArray = model.runeUnlockArray;
            if (towerCnt >= towerArray.Length)
            {
                var _tower = 0;
                foreach (var _key in model.doublePropRuneInlayDict.Keys)
                {
                    if (model.RuneTowerOpenLV < _key)
                    {
                        _tower = _key;
                        break;
                    }
                }
                if (_tower == 0)
                {
                    m_RuneUnlockTip.text = Language.Get("L1060",model.doublePropRuneInlayDict.Values.Last());
                }
                else
                {
                    RuneTowerFloorConfig cfg = Config.Instance.Get<RuneTowerFloorConfig>(_tower);
                    var tower = Config.Instance.Get<RuneTowerConfig>(cfg.TowerId);
                    m_RuneUnlockTip.text = Language.Get("RuneDoubleAttr", StringUtility.Contact(tower.TowerName, cfg.FloorName)
                        , model.doublePropRuneInlayDict[_tower]);
                }
            }
            else
            {
                RuneTowerFloorConfig cfg = Config.Instance.Get<RuneTowerFloorConfig>(towerArray[towerCnt]);
                var tower = Config.Instance.Get<RuneTowerConfig>(cfg.TowerId);
                m_RuneUnlockTip.text = Language.Get("RuneUnlock", StringUtility.Contact(tower.TowerName, cfg.FloorName));
            }
            for (int i = 0; i < runeHoleDatas.Count; i++)
            {
                RuneData data = model.GetHoleRune(i);
                runeHoleDatas[i].SetRuneHole(!model.IsRuneHoleOpen(i));
                if (data == null || !model.IsRuneHoleOpen(i))
                {
                    runeHoleDatas[i].Display(0, 0);
                }
                else
                {
                    runeHoleDatas[i].Display(data.id, data.lv);
                }
            }
        }

        void OnRuneHoleRefresh()
        {
            InitRuneHoles();
            OnUpdateRuneHoleInfo();
            if (model.sltRuneHole != -1)
            {
                OnRuneHoleClick(model.sltRuneHole);
            }
            if (m_IsRuneLvUp)
            {
                m_RuneLvUpEffect.Play();
                m_IsRuneLvUp = false;
            }
        }

        private void OnRuneReplaceBtn()
        {
            WindowCenter.Instance.Open<RunePackWin>();
        }

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

        void OnRuneUpBtn()
        {
            RuneData data = model.GetHoleRune(model.sltRuneHole);
            if (data == null)
            {
                return;
            }
            var _runeCfg = Config.Instance.Get<RuneConfig>(data.id);
            var _itemCfg = Config.Instance.Get<ItemConfig>(data.id);
            if (data.lv >= model.GetRuneMaxLevelByItem(data.id))
            {
                return;
            }
            float _levelUpExp = model.GetRuneNeedExp(data.id, data.lv);
            if (model.RuneSplinters < _levelUpExp)
            {
                SysNotifyMgr.Instance.ShowTip("RuneEssenceLack");
                return;
            }
            m_IsRuneLvUp = true;
            CA565_tagCMRuneUp runeUpPack = new CA565_tagCMRuneUp();
            runeUpPack.PlaceIndex = (ushort)data.index;
            runeUpPack.PlaceType = (byte)data.placetype;
            GameNetSystem.Instance.SendInfo(runeUpPack);
        }
        [Serializable]
        public class RuneDisplay
        {
            [SerializeField] Image m_RuneIcon;
            [SerializeField] Image m_RuneUnlock;
            [SerializeField] Text m_RuneNameLvTxt;
            [SerializeField] Image m_RuneSelect;
            [SerializeField] Image m_RuneAdd;
            [SerializeField] UIEffect m_Effect;
            [SerializeField] RedpointBehaviour m_Redpoint;

            RuneModel m_Model;
            RuneModel model { get { return m_Model ?? (m_Model = ModelCenter.Instance.GetModel<RuneModel>()); } }

            public RectTransform Container
            {
                get
                {
                    return m_RuneIcon.rectTransform;
                }
            }

            public RedpointBehaviour redpoint { get { return m_Redpoint; } }

            public void Display(int _runeId, int _lv)
            {
                m_RuneIcon.gameObject.SetActive(_runeId != 0);
                m_RuneNameLvTxt.gameObject.SetActive(_runeId != 0);
                m_RuneAdd.gameObject.SetActive(_runeId == 0);
                var _itemCfg = Config.Instance.Get<ItemConfig>(_runeId);
                if (_itemCfg != null)
                {
                    m_RuneIcon.SetSprite(_itemCfg.IconKey);
                    m_RuneNameLvTxt.color = UIHelper.GetUIColor(_itemCfg.ItemColor);
                }
                m_RuneNameLvTxt.text = Language.Get("Z1024", _lv);
                if (_runeId != 0 && model.doublePropertyRunes.Contains(_runeId))
                {
                    if (!m_Effect.IsPlaying)
                    {
                        m_Effect.Play();
                    }
                }
                else
                {
                    if (m_Effect.IsPlaying)
                    {
                        m_Effect.StopImediatly();
                    }
                }
            }

            public void SetRuneHole(bool _lock)
            {
                m_RuneUnlock.gameObject.SetActive(_lock);
                m_RuneAdd.gameObject.SetActive(!_lock);
            }

            public void SetSelect(bool _select)
            {
                m_RuneSelect.gameObject.SetActive(_select);
            }
        }
    }

}