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


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

using System.Linq;

namespace vnxbqy.UI
{

    public class RuneMosaicWin : Window
    {
        [SerializeField] RuneHoleBehaviour[] m_RuneHoles;

        [SerializeField] Transform m_ContainerEquiped;
        [SerializeField] Transform m_ContainerGetRune;
        [SerializeField] Transform m_ContainerSpecialLock;

        [SerializeField] Button m_LevelUp;
        [SerializeField] Text m_LevelUpLabel;
        [SerializeField] Button m_ReplaceRune;
        [SerializeField] Text m_ReplaceLabel;
        [SerializeField] Button m_RunePreview;
        [SerializeField] RedpointBehaviour m_LevelUpRedpoint;
        [SerializeField] RedpointBehaviour m_ReplaceRedpoint;

        [SerializeField] Image m_RuneIcon;
        [SerializeField] Text m_RuneName;
        [SerializeField] Text m_RuneProperty;
        [SerializeField] Transform m_ContainerLevelUp;
        [SerializeField] PropertyBehaviour[] m_Propertys;
        [SerializeField] Text m_CostEssence;
        [SerializeField] RectTransform m_ContaienrMaxLevel;

        [SerializeField] Button m_GotoGetRuneBtn;
        [SerializeField] Button m_GotoFindRune;

        [SerializeField] RectTransform m_ContainerSpecial;
        [SerializeField] Button m_UnlockSpecialHole;
        [SerializeField] Text m_SpecialCostRemind;
        [SerializeField] Text m_SpecialLevelRemind;

        [SerializeField] Text m_RuneUnlockRemind;
        [SerializeField] UIEffect m_LevelUpEffect;
        [SerializeField] UIEffect m_SpecialHoleEffect;

        [SerializeField] Button m_XunBao;

        RuneHoleState selectHoleState = RuneHoleState.Lock;
        Coroutine m_CacheCoroutine;

        bool doLevelUp = false;

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

        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_ReplaceRune.onClick.AddListener(OpenRunePack);
            m_LevelUp.onClick.AddListener(OnLevelUp);
            m_RunePreview.onClick.AddListener(OpenRunePreview);
            m_GotoGetRuneBtn.onClick.AddListener(OnGotoGetRune);
            m_GotoFindRune.onClick.AddListener(GotoFindRune);
            m_UnlockSpecialHole.onClick.AddListener(UnlockSpecialHole);
            m_XunBao.onClick.AddListener(OpenXB);
        }

        protected override void OnPreOpen()
        {
            model.unlockingSpecialHole = false;

            model.onSelectHoleRefresh += OnSelectHoleRefresh;
            model.onRuneHoleRefresh += OnRuneHoleRefresh;
            model.onOpenNewHole += OnOpenNewHole;
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
            Display();
        }

        protected override void OnAfterOpen()
        {
            HandleAchievement();
            model.SetDayRemind();
        }

        protected override void OnPreClose()
        {
            model.onSelectHoleRefresh -= OnSelectHoleRefresh;
            model.onRuneHoleRefresh -= OnRuneHoleRefresh;
            model.onOpenNewHole -= OnOpenNewHole;
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;

            doLevelUp = false;

            for (int i = 0; i < m_RuneHoles.Length; i++)
            {
                m_RuneHoles[i].Dispose();
            }

            if (m_CacheCoroutine != null)
            {
                StopCoroutine(m_CacheCoroutine);
                m_CacheCoroutine = null;
            }
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        void SetDefaultSelect()
        {
            if (NewBieCenter.Instance.inGuiding)
            {
                model.selectHole = 0;
            }
            if (model.specialHoleRedpoint.state == RedPointState.Simple)
            {
                model.selectHole = model.specialHole;
                return;
            }
            for (int i = 0; i < RuneModel.RUNE_HOLE_COUNT; i++)
            {
                RuneModel.RuneHoleRedpoint redpoint;
                if (model.TryGetRedpoint(i, out redpoint))
                {
                    if (redpoint.redpoint.state == RedPointState.Simple)
                    {
                        model.selectHole = i;
                        return;
                    }
                }
            }
            model.selectHole = 0;
        }

        void Display()
        {
            SetDefaultSelect();

            for (int i = 0; i < m_RuneHoles.Length; i++)
            {
                m_RuneHoles[i].Display(i);
            }

            DisplayHoleDetail();
            DisplayUnlockRemind();
            DisplaySpecialHole();
        }

        void DisplayHoleDetail()
        {
            if (!model.IsRuneHoleOpen(model.selectHole, model.holeState))
            {
                selectHoleState = RuneHoleState.Lock;
            }
            else
            {
                RuneItem item;
                if (!model.TryGetRuneHoleItem(model.selectHole, out item))
                {
                    selectHoleState = RuneHoleState.UnEquip;
                }
                else
                {
                    selectHoleState = RuneHoleState.Equiped;
                }
            }

            RuneModel.RuneHoleRedpoint redpoint;
            if (model.TryGetRedpoint(model.selectHole, out redpoint))
            {
                m_LevelUpRedpoint.redpointId = redpoint.levelUpRedpoint.id;
                m_ReplaceRedpoint.redpointId = redpoint.replaceRedpoint.id;
            }

            m_ContainerEquiped.SetActive(selectHoleState == RuneHoleState.Equiped);
            m_ContainerGetRune.SetActive(selectHoleState == RuneHoleState.UnEquip);
            m_ContainerSpecialLock.SetActive(selectHoleState == RuneHoleState.Lock
                && model.selectHole == model.specialHole);
            m_ReplaceRune.SetActive(selectHoleState != RuneHoleState.Lock);
            m_LevelUp.SetActive(selectHoleState == RuneHoleState.Equiped);

            switch (selectHoleState)
            {
                case RuneHoleState.Lock:
                    if (model.selectHole == model.specialHole)
                    {
                        DisplaySpecialHoleDetail();
                    }
                    break;
                case RuneHoleState.UnEquip:
                    break;
                case RuneHoleState.Equiped:
                    DisplayEquipedHoleDetail();
                    break;
            }
        }

        void DisplayEquipedHoleDetail()
        {
            RuneItem item;
            model.TryGetRuneHoleItem(model.selectHole, out item);
            var config = RuneConfig.Get(item.id);
            var multiProperty = model.IsMultiPropertyRune(item.id);

            var itemConfig = ItemConfig.Get(item.id);
            m_RuneIcon.SetSprite(itemConfig.IconKey);
            m_RuneProperty.text = model.GetRunePropertyDescription(item.id, item.level);
            m_RuneName.text = StringUtility.Contact(itemConfig.ItemName, Language.Get("Z1024", item.level));
            m_RuneName.color = UIHelper.GetUIColor(itemConfig.ItemColor, true);

            var isMax = model.IsRuneMaxLevel(item.id, item.level);
            m_ContaienrMaxLevel.SetActive(isMax);
            m_ContainerLevelUp.SetActive(!isMax);

            if (!isMax)
            {
                for (int i = 0; i < m_Propertys.Length; i++)
                {
                    m_Propertys[i].SetActive(i < config.AttrType.Length);
                    if (i < config.AttrType.Length)
                    {
                        var propertyValue = model.GetPropertyValue(item.id, item.level, config.AttrType[i]);
                        var upValue = model.GetPropertyValue(item.id, item.level + 1, config.AttrType[i]);
                        m_Propertys[i].DisplayUp(config.AttrType[i], propertyValue, upValue);
                    }
                }

                int requireEssence = model.GetLevelUpRequireRuneEssence(item.id, item.level);
                ulong essence = PlayerDatas.Instance.GetPlayerDataByType(PlayerDataType.RuneSplinters);
                var essenceLabel = UIHelper.AppendColor(essence >= (ulong)requireEssence ? TextColType.Green : TextColType.Red
                           , essence.ToString(), true);
                m_CostEssence.text = StringUtility.Contact(essenceLabel, "/", requireEssence);
            }

            m_LevelUp.SetInteractable(m_LevelUpLabel, !isMax);
            m_LevelUp.SetActive(!isMax);
        }

        void DisplaySpecialHoleDetail()
        {
            RuneHoleCondition condition;
            if (model.TryGetRuneHoleCondition(model.selectHole, out condition))
            {
                m_SpecialCostRemind.text = Language.Get("RuneSpecialHoleCost", condition.diamond);
                m_SpecialLevelRemind.text = Language.Get("RuneSpecialHoleLevel", condition.playerLevel);
            }
        }

        void DisplayUnlockRemind()
        {
            var lockHole = -1;
            for (int i = 0; i < RuneModel.RUNE_HOLE_COUNT; i++)
            {
                if (i == model.specialHole)
                {
                    continue;
                }
                if (!model.IsRuneHoleOpen(i, model.holeState))
                {
                    lockHole = i;
                    break;
                }
            }
            if (lockHole != -1)
            {
                RuneHoleCondition condition;
                if (model.TryGetRuneHoleCondition(lockHole, out condition))
                {
                    var config = RuneTowerFloorConfig.Get(condition.runeTowerFloor);
                    var tower = RuneTowerConfig.Get(config.TowerId);
                    m_RuneUnlockRemind.text = Language.Get("RuneUnlock",
                        StringUtility.Contact(tower.TowerName, config.FloorName));
                }
            }
            else
            {
                var _tower = 0;
                if (model.IsUnlockAllMultiPropertyInlay(out _tower))
                {
                    m_RuneUnlockRemind.text = Language.Get("L1060", model.GetMultiPropertyInlayCount());
                }
                else
                {
                    var config = RuneTowerFloorConfig.Get(_tower);
                    var tower = RuneTowerConfig.Get(config.TowerId);
                    m_RuneUnlockRemind.text = Language.Get("RuneDoubleAttr",
                        StringUtility.Contact(tower.TowerName, config.FloorName)
                        , model.GetMultiPropertyInlayCount(_tower));
                }
            }
        }

        void DisplaySpecialHole()
        {
            m_SpecialHoleEffect.StopImediatly();
            if (!model.IsRuneHoleOpen(model.specialHole, model.holeState))
            {
                m_SpecialHoleEffect.Play();
            }
        }

        private void OnSelectHoleRefresh()
        {
            DisplayHoleDetail();
        }

        private void OnRuneHoleRefresh()
        {
            if (model.selectHole == model.specialHole && model.unlockingSpecialHole)
            {
                return;
            }

            DisplayHoleDetail();

            if (doLevelUp)
            {
                m_LevelUpEffect.Play();
                doLevelUp = false;
            }
        }

        private void PlayerDataRefreshEvent(PlayerDataType dataType)
        {
            if (dataType == PlayerDataType.RuneSplinters)
            {
                if (selectHoleState == RuneHoleState.Equiped)
                {
                    DisplayEquipedHoleDetail();
                }
            }
        }

        void OnOpenNewHole(int hole)
        {
            if (model.specialHole == hole)
            {
                model.unlockingSpecialHole = true;
                EffectMgr.Instance.PlayUIEffect(3068, 2500, m_RuneHoles[hole].transform, false);
                m_CacheCoroutine = StartCoroutine(Co_RefreshHole());
            }
        }

        IEnumerator Co_RefreshHole()
        {
            yield return WaitingForSecondConst.WaitMS800;
            model.unlockingSpecialHole = false;
            DisplaySpecialHole();
            if (model.selectHole == model.specialHole)
            {
                DisplayHoleDetail();
            }
        }

        private void OpenXB()
        {
            m_SpecialHoleEffect.Stop();
            var xbModel = ModelCenter.Instance.GetModel<HappyXBModel>();
            var functionOrder = 1;
            if (xbModel.runeXBRed.state == RedPointState.Simple)
            {
                functionOrder = 1;
            }
            else if (xbModel.xbWarehouseRed.state == RedPointState.Simple)
            {
                functionOrder = 3;
            }
            WindowCenter.Instance.Open<HappyXBWin>(false, functionOrder);
        }

        private void UnlockSpecialHole()
        {
            if (model.selectHole != model.specialHole)
            {
                return;
            }
            if (model.IsRuneHoleOpen(model.selectHole, model.holeState))
            {
                return;
            }
            int error = 0;
            if (!TestUnlockSpeicalHole(model.selectHole, out error))
            {
                ProcessUnlockError(error, model.selectHole);
                return;
            }
            CA513_tagCMUnlockRuneHole pak = new CA513_tagCMUnlockRuneHole();
            pak.HoleIndex = (byte)model.selectHole;
            GameNetSystem.Instance.SendInfo(pak);
        }

        bool TestUnlockSpeicalHole(int hole, out int error)
        {
            error = 0;
            RuneHoleCondition condition;
            if (model.TryGetRuneHoleCondition(hole, out condition))
            {
                if (PlayerDatas.Instance.baseData.LV < condition.playerLevel)
                {
                    error = 1;
                    return false;
                }
                if (PlayerDatas.Instance.baseData.diamond < condition.diamond)
                {
                    error = 2;
                    return false;
                }
            }
            return true;
        }

        void ProcessUnlockError(int error, int hole)
        {
            switch (error)
            {
                case 1:
                    RuneHoleCondition condition;
                    if (model.TryGetRuneHoleCondition(hole, out condition))
                    {
                        SysNotifyMgr.Instance.ShowTip("RuneSpecialHoleLevelError", condition.playerLevel);
                    }
                    break;
                case 2:
                    WindowCenter.Instance.Open<RechargeTipWin>();
                    break;
            }
        }

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

        private void GotoFindRune()
        {
            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.RuneXB);
        }

        void HandleAchievement()
        {
            if (AchievementGoto.achievementType == AchievementGoto.RuneLevelUp)
            {
                for (int i = 0; i < RuneModel.RUNE_HOLE_COUNT; i++)
                {
                    if (model.SatisfyLevelUpHole(i))
                    {
                        model.selectHole = i;
                        var _effect = AchievementGuideEffectPool.Require(1);
                        _effect.transform.SetParentEx(m_LevelUp.transform, Vector3.zero, Vector3.zero, Vector3.one);
                        AchievementGoto.achievementType = 0;
                        return;
                    }
                }
                SysNotifyMgr.Instance.ShowTip("Achievement_45");
                AchievementGoto.achievementType = 0;
            }
            else
            {
                var _color = AchievementGoto.guideAchievementId == AchievementGoto.EquipRune1 ? 1 :
                AchievementGoto.guideAchievementId == AchievementGoto.EquipRune2 ? 2 : 0;
                if (_color > 0)
                {
                    int _hole = 0;
                    if (model.TryEquipRuneByColor(_color, out _hole))
                    {
                        model.selectHole = _hole;
                        var _effect = AchievementGuideEffectPool.Require(1);
                        _effect.transform.SetParentEx(m_ReplaceRune.transform, Vector3.zero, Vector3.zero, Vector3.one);
                    }
                    else
                    {
                        SysNotifyMgr.Instance.ShowTip("Achievement_44");
                    }
                }
                AchievementGoto.guideAchievementId = 0;
            }
        }

        private void OpenRunePack()
        {
            RunePackWin.selectHole = model.selectHole;
            WindowCenter.Instance.Open<RunePackWin>();
        }

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

        
        void OnLevelUp()
        {
            RuneItem item;
            if (!model.TryGetRuneHoleItem(model.selectHole, out item))
            {
                return;
            }
            if (model.IsRuneMaxLevel(item.id, item.level))
            {
                return;
            }
            var config = RuneConfig.Get(item.id);
            var itemConfig = ItemConfig.Get(item.id);
            var requireEssence = model.GetLevelUpRequireRuneEssence(item.id, item.level);
            LimitedTimeLuxuryGiftModel.Instance.IsItemIdShow(54, 41, requireEssence, 2, 0);
            if (PlayerDatas.Instance.GetPlayerDataByType(PlayerDataType.RuneSplinters) < (ulong)requireEssence)
            {
                SysNotifyMgr.Instance.ShowTip("RuneEssenceLack");
                return;
            }
            CA565_tagCMRuneUp pak = new CA565_tagCMRuneUp();
            pak.PlaceIndex = (ushort)item.index;
            pak.PlaceType = (byte)item.placeType;
            GameNetSystem.Instance.SendInfo(pak);

            doLevelUp = true;
        }

        public enum RuneHoleState
        {
            Lock,
            UnEquip,
            Equiped,
        }
    }
}