//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Thursday, March 15, 2018
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using TableConfig;
using System;

namespace Snxxz.UI
{
    public class FairyTreasureCollectPanelPattern1 : FairyTreasureCollect
    {
        [SerializeField] RectTransform m_CollectContainer;
        [SerializeField] FairyTreasureCollectConditionBehaviour1[] m_Conditions;
        [SerializeField] Text m_LevelNeed;
        [SerializeField] Button m_UnLockTreasure;

        [SerializeField] RectTransform m_LevelUpContainer;
        [SerializeField] Text m_StoveLevel;
        [SerializeField] RectTransform m_CurrentProperty;
        [SerializeField] Text[] m_CurrentPropertyNames;
        [SerializeField] Text[] m_CurrentPropertyValues;

        [SerializeField] RectTransform m_NextProperty;
        [SerializeField] Text[] m_NextPropertyNames;
        [SerializeField] Text[] m_NextPropertyValues;

        [SerializeField] RectTransform m_MaxLevelContainer;

        [SerializeField] Button m_GotoStove;

        PlayerPackModel packModel { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }
        BlastFurnaceModel blastFurnaceModel { get { return ModelCenter.Instance.GetModel<BlastFurnaceModel>(); } }
        Item[] needItems = null;

        public override void Display(int _treasureId, bool _tween = false)
        {
            base.Display(_treasureId);
            if (!model.TryGetTreasure(_treasureId, out treasure))
            {
                return;
            }

            needItems = treasure.needItems;

            switch (treasure.state)
            {
                case TreasureState.Collected:
                    DisplayCollectedState();
                    break;
                case TreasureState.Locked:
                    DisplayLockedState();
                    break;
            }

            CheckAchievementGuide();

            m_UnLockTreasure.RemoveAllListeners();
            m_GotoStove.RemoveAllListeners();

            m_UnLockTreasure.AddListener(UnLockTreasure);
            m_GotoStove.AddListener(GotoStove);

            model.treasureStateChangeEvent += OnTreasureStateChange;
        }

        public override void Dispose()
        {
            base.Dispose();

            model.treasureStateChangeEvent -= OnTreasureStateChange;
            m_UnLockTreasure.RemoveAllListeners();
            m_GotoStove.RemoveAllListeners();
        }

        private void DisplayCollectedState()
        {
            m_CollectContainer.gameObject.SetActive(false);
            m_LevelUpContainer.gameObject.SetActive(true);

            var stoveLevel = blastFurnaceModel.StoveLV;
            m_StoveLevel.text = Language.Get("BlastFurnace101", stoveLevel);

            var configNow = ConfigManager.Instance.GetTemplate<RefineStoveConfig>(stoveLevel);
            var min = Mathf.Min(m_CurrentPropertyNames.Length, m_CurrentPropertyValues.Length);
            for (int i = 0; i < min; i++)
            {
                if (i < configNow.AttrID.Length)
                {
                    m_CurrentPropertyNames[i].gameObject.SetActive(true);
                    m_CurrentPropertyValues[i].gameObject.SetActive(true);

                    var propertyId = configNow.AttrID[i];
                    var propertyConfig = ConfigManager.Instance.GetTemplate<PlayerPropertyConfig>(propertyId);
                    m_CurrentPropertyNames[i].text = propertyConfig.Name;
                    m_CurrentPropertyValues[i].text = StringUtility.Contact("+", configNow.AttrValue[i]);
                }
                else
                {
                    m_CurrentPropertyNames[i].gameObject.SetActive(false);
                    m_CurrentPropertyValues[i].gameObject.SetActive(false);
                }
            }

            var isMax = false;
            m_NextProperty.gameObject.SetActive(!isMax);
            m_MaxLevelContainer.gameObject.SetActive(isMax);

            if (!isMax)
            {
                var configNext = ConfigManager.Instance.GetTemplate<RefineStoveConfig>(stoveLevel + 1);
                var min1 = Mathf.Min(m_NextPropertyNames.Length, m_NextPropertyValues.Length);
                for (int i = 0; i < min1; i++)
                {
                    if (i < configNext.AttrID.Length)
                    {
                        m_NextPropertyNames[i].gameObject.SetActive(true);
                        m_NextPropertyValues[i].gameObject.SetActive(true);

                        var propertyId = configNext.AttrID[i];
                        var propertyConfig = ConfigManager.Instance.GetTemplate<PlayerPropertyConfig>(propertyId);
                        m_NextPropertyNames[i].text = propertyConfig.Name;
                        m_NextPropertyValues[i].text = StringUtility.Contact("+", configNext.AttrValue[i]);
                    }
                    else
                    {
                        m_NextPropertyNames[i].gameObject.SetActive(false);
                        m_NextPropertyValues[i].gameObject.SetActive(false);
                    }
                }
            }
        }

        private void DisplayLockedState()
        {
            m_CollectContainer.gameObject.SetActive(true);
            m_LevelUpContainer.gameObject.SetActive(false);

            var config = ConfigManager.Instance.GetTemplate<TreasureConfig>(treasure.id);
            m_LevelNeed.text = Language.Get("TreasureLvRequire", config.ChallengeLevel);

            for (int i = 0; i < m_Conditions.Length; i++)
            {
                var condition = m_Conditions[i];
                if (i < needItems.Length)
                {
                    condition.gameObject.SetActive(true);
                    condition.Display(needItems[i].id, needItems[i].count);
                }
                else
                {
                    condition.gameObject.SetActive(false);
                }
            }
        }

        private bool TestCollectConditions(out int _error)
        {
            for (int i = 0; i < needItems.Length; i++)
            {
                var item = needItems[i];
                var own = packModel.GetItemCountByID(PackType.rptItem, item.id);
                if (own < item.count)
                {
                    _error = 1;
                    return false;
                }
            }

            var config = ConfigManager.Instance.GetTemplate<TreasureConfig>(treasure.id);
            var playerLevel = PlayerDatas.Instance.baseData.LV;

            if (playerLevel < config.ChallengeLevel)
            {
                _error = 2;
                return false;
            }

            _error = 0;
            return true;
        }

        private void UnLockTreasure()
        {
            var error = 0;
            if (TestCollectConditions(out error))
            {
                var unlock = new CA50E_tagCMOpenMagicWeapon();
                unlock.MWID = (uint)treasure.id;
                GameNetSystem.Instance.SendInfo(unlock);

                WindowCenter.Instance.Close<TreasureLevelUpWin>();
                WindowCenter.Instance.Open<MainInterfaceWin>();
            }
            else
            {
                switch (error)
                {
                    case 1:
                        SysNotifyMgr.Instance.ShowTip("TreasureItemUnenough");
                        break;
                    case 2:
                        SysNotifyMgr.Instance.ShowTip("TreasureLvUnenough");
                        break;
                }
            }
        }

        private void GotoStove()
        {
            WindowCenter.Instance.Close<TreasureLevelUpWin>();

            WindowCenter.Instance.Close<MainInterfaceWin>();
            WindowCenter.Instance.Open<BlastFurnaceWin>();
        }

        protected override void OnTreasureStateChange(int _treasureId)
        {
            if (treasure.id != _treasureId)
            {
                return;
            }

            switch (treasure.state)
            {
                case TreasureState.Collected:
                    DisplayCollectedState();
                    break;
                case TreasureState.Locked:
                    DisplayLockedState();
                    break;
            }
        }

        private void CheckAchievementGuide()
        {
            if (AchievementGoto.guideAchievementId != 0)
            {
                var config = ConfigManager.Instance.GetTemplate<SuccessConfig>(AchievementGoto.guideAchievementId);
                var condition = config.Type == 115;

                if (condition)
                {
                    var guideEffect = AchievementGuideEffectPool.Require(1);
                    guideEffect.transform.SetParentEx(m_UnLockTreasure.transform, Vector3.zero, Vector3.zero, Vector3.one);
                }
            }
        }

    }

}