//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Tuesday, November 13, 2018
//--------------------------------------------------------

using System;
using System.Collections;
using System.Collections.Generic;

using UnityEngine;
using UnityEngine.UI;

namespace vnxbqy.UI
{
    
    public class DemonTreasureWin : Window
    {
        [SerializeField] TreasureDemonBehaviour m_TreasureDemonBehaviour;
        [SerializeField] Image m_TreasureNameIcon;
        [SerializeField] Text m_PropertyTitle;
        [SerializeField] PropertyBehaviour[] m_Propertys;
        [SerializeField] Text m_SkillTitle;
        [SerializeField] Image m_SkillIcon;
        [SerializeField] Text m_SkillState;
        [SerializeField] Text m_SkillName;
        [SerializeField] Text m_SkillDescription;
        [SerializeField] ScrollRect m_ScrollRect;
        [SerializeField] RectTransform m_DungeonsContent;
        [SerializeField] Transform m_ContainerDungeons;
        [SerializeField] DemonDungeonBehaviour[] m_DungeonBehaviours;

        [SerializeField] Transform m_ContainerChallenge;
        [SerializeField] Button m_Challenge;
        [SerializeField] Text m_RecommondPower;
        [SerializeField] Text m_RecommondDefense;
        [SerializeField] Button m_ViewProperty;

        [SerializeField] float m_Expand = 1.05f;

        [SerializeField] PositionTween m_TreasureGainTween;
        [SerializeField] PositionTween m_DescriptionTween;
        [SerializeField] PositionTween m_SkillTween;
        [SerializeField] UIAlphaTween m_DungeonAlphaTween;

        [SerializeField] float m_SelectHeight = 253f;

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

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

        static Dictionary<int, int> currentPropertyDict = new Dictionary<int, int>();
        static List<int> displayPropertys = new List<int>();
        static Dictionary<int, int> addPropertyDict = new Dictionary<int, int>();

        public static float expand = 1.05f;

        bool treasureTweening = false;

        AnimationStep m_Step = AnimationStep.None;
        AnimationStep step
        {
            get { return m_Step; }
            set
            {
                if (m_Step != value)
                {
                    m_Step = value;
                    DisplayAnimation();
                }
            }
        }

        float timer = 0f;
        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_ViewProperty.onClick.AddListener(ViewProperty);
            m_Challenge.onClick.AddListener(Challenge);
        }

        protected override void OnPreOpen()
        {
            expand = m_Expand;
            m_Step = AnimationStep.None;
            treasureTweening = false;
        }

        protected override void OnActived()
        {
            base.OnActived();
            model.treasureSelectedEvent += TreasureSelectedEvent;
            model.treasureStateChangeEvent += TreasureStateChangeEvent;
            model.demonTreasureDungeonUpdate += DemonTreasureDungeonUpdate;
            TreasureBaseWin.allowSelectTreasure += AllowSelectTreasure;
            Display();

            Treasure treasure;
            if (model.TryGetTreasure(model.selectedTreasure, out treasure))
            {
                switch (treasure.state)
                {
                    case TreasureState.Collecting:
                    case TreasureState.Collected:
                        step = AnimationStep.None2Collect;
                        break;
                    case TreasureState.Locked:
                        step = AnimationStep.None2Lock;
                        break;
                }
            }
        }

        protected override void OnAfterOpen()
        {

        }

        protected override void OnPreClose()
        {
            model.treasureSelectedEvent -= TreasureSelectedEvent;
            model.treasureStateChangeEvent -= TreasureStateChangeEvent;
            model.demonTreasureDungeonUpdate -= DemonTreasureDungeonUpdate;
            TreasureBaseWin.allowSelectTreasure -= AllowSelectTreasure;
            model.SetUnlockAnim(TreasureCategory.Demon, 0);
            treasureTweening = false;
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        protected override void LateUpdate()
        {
            base.LateUpdate();
            timer += Time.deltaTime;
            if (timer > 1f)
            {
                timer = 0f;
                treasureTweening = false;
            }
        }

        private bool AllowSelectTreasure(int treasureId)
        {
            if (NewBieCenter.Instance.inGuiding || treasureTweening)
            {
                return false;
            }
            return true;
        }

        private void ViewProperty()
        {
            WindowCenter.Instance.Open<DemonTreasurePropertyWin>();
        }

        private void Challenge()
        {
            Treasure treasure;
            if (!model.TryGetTreasure(model.selectedTreasure, out treasure))
            {
                return;
            }
            var fightPower = PlayerDatas.Instance.baseData.FightPoint;
            var defense = (int)UIHelper.GetPropertyValue(PropertyType.DEF);
            var recommandPower = 0;
            var recommandDefense = 0;
            TreasureDungeon treasureDungeon;
            if (model.TryGetTreasureDungeon(model.selectedTreasure, out treasureDungeon))
            {
                var dungeonInfo = treasureDungeon.Get(treasureDungeon.currentLevel + 1);
                if (!dungeonInfo.Equals(default(TreasureDungeonInfo)))
                {
                    recommandPower = dungeonInfo.fightPower;
                    recommandDefense = dungeonInfo.defense;
                }
            }

            if (fightPower < (ulong)recommandPower || defense < recommandDefense)
            {
                DemonDungeonChallengeConfirmWin.treasureId = model.selectedTreasure;
                WindowCenter.Instance.Open<DemonDungeonChallengeConfirmWin>();
                return;
            }

            var config = TreasureConfig.Get(model.selectedTreasure);
            dungeonModel.SingleChallenge(TreasureModel.TREASURE_DATAMAPID, config.LineId);
        }

        private void Display()
        {
            m_TreasureDemonBehaviour.Display(model.selectedTreasure);
            DisplayProperty();
            DisplaySkill();
            DisplayDungeons();
            DisplayChallenge();
            DisplayDungeonPosition();
            DisplayTreasureName();
        }

        private void DisplayAnimation()
        {
            switch (step)
            {
                case AnimationStep.None2Lock:
                    m_DescriptionTween.Play();
                    m_SkillTween.Play();
                    m_TreasureGainTween.SetStartState();
                    UI3DTreasureSelectStage.Instance.SetStartState();
                    m_ContainerDungeons.SetActive(false);
                    break;
                case AnimationStep.None2Collect:
                    m_ContainerDungeons.SetActive(true);
                    m_DungeonAlphaTween.Play();
                    treasureTweening = true;
                    timer = 0f;
                    StopAllLine();
                    m_TreasureNameIcon.SetActive(false);
                    UI3DTreasureSelectStage.Instance.Tween(OnTreasureTweenComplete);
                    m_DescriptionTween.SetStartState();
                    m_SkillTween.SetStartState();
                    m_TreasureGainTween.Play();
                    break;
                case AnimationStep.Lock2Collect:
                    m_ContainerDungeons.SetActive(true);
                    m_DungeonAlphaTween.Play();
                    treasureTweening = true;
                    timer = 0f;
                    StopAllLine();
                    UI3DTreasureSelectStage.Instance.Tween(OnTreasureTweenComplete);
                    m_DescriptionTween.Play(true);
                    m_SkillTween.Play(true);
                    m_TreasureGainTween.Play();
                    break;
                case AnimationStep.Collect2Lock:
                    m_ContainerDungeons.SetActive(false);
                    UI3DTreasureSelectStage.Instance.SetStartState();
                    m_DescriptionTween.Play();
                    m_SkillTween.Play();
                    m_TreasureGainTween.Play(true);
                    break;
            }
        }

        void OnTreasureTweenComplete()
        {
            treasureTweening = false;
            DisplayLines();
            DisplayTreasureName();
        }

        private void DisplayTreasureName()
        {
            if (treasureTweening)
            {
                m_TreasureNameIcon.SetActive(false);
                return;
            }
            m_TreasureNameIcon.SetActive(true);
            var config = TreasureConfig.Get(model.selectedTreasure);
            m_TreasureNameIcon.SetSprite(config.TreasureNameIcon);
        }

        private void DisplayProperty()
        {
            TreasureDungeon treasureDungeon;
            currentPropertyDict.Clear();
            addPropertyDict.Clear();
            displayPropertys.Clear();
            if (model.TryGetTreasureDungeon(model.selectedTreasure, out treasureDungeon))
            {
                var info = treasureDungeon.Get(treasureDungeon.currentLevel);
                if (treasureDungeon.currentLevel > 0)
                {
                    foreach (var key in info.propertyDict.Keys)
                    {
                        currentPropertyDict.Add(key, info.propertyDict[key]);
                        displayPropertys.Add(key);
                    }
                }
                info = treasureDungeon.Get(treasureDungeon.currentLevel + 1);
                if (!info.Equals(default(TreasureDungeonInfo)))
                {
                    foreach (var key in info.propertyDict.Keys)
                    {
                        if (!addPropertyDict.ContainsKey(key))
                        {
                            addPropertyDict.Add(key, info.propertyDict[key]);
                        }
                        if (currentPropertyDict.ContainsKey(key))
                        {
                            addPropertyDict[key] -= currentPropertyDict[key];
                        }
                        if (!displayPropertys.Contains(key))
                        {
                            displayPropertys.Add(key);
                        }
                    }
                }
                if (treasureDungeon.currentLevel == treasureDungeon.maxLevel)
                {
                    m_PropertyTitle.text = Language.Get("GetTreasurePropertyTitle");
                }
                else
                {
                    m_PropertyTitle.text = Language.Get("PassTreasureDungeonPropertyTitle");
                }
            }
            for (int i = 0; i < m_Propertys.Length; i++)
            {
                if (i < displayPropertys.Count)
                {
                    m_Propertys[i].SetActive(true);
                    var currentValue = 0;
                    if (currentPropertyDict.ContainsKey(displayPropertys[i]))
                    {
                        currentValue = currentPropertyDict[displayPropertys[i]];
                    }
                    var addValue = 0;
                    if (addPropertyDict.ContainsKey(displayPropertys[i]))
                    {
                        addValue = addPropertyDict[displayPropertys[i]];
                    }
                    m_Propertys[i].DisplayAdd(displayPropertys[i], currentValue, addValue);
                }
                else
                {
                    m_Propertys[i].SetActive(false);
                }
            }
        }

        private void DisplaySkill()
        {
            Treasure treasure;
            if (model.TryGetTreasure(model.selectedTreasure, out treasure))
            {
                var skillConfig = SkillConfig.Get(treasure.skillId);
                if (skillConfig != null)
                {
                    m_SkillIcon.SetSprite(skillConfig.IconName);
                    m_SkillName.text = skillConfig.SkillName;
                    m_SkillDescription.text = skillConfig.Description;
                    if (treasure.state == TreasureState.Collected)
                    {
                        m_SkillState.text = Language.Get("DemonTreasureSkillGot");
                        m_SkillState.color = UIHelper.GetUIColor(TextColType.Green, true);
                    }
                    else
                    {
                        m_SkillState.text = Language.Get("DemonTreasureSkillGetting");
                        m_SkillState.color = UIHelper.GetUIColor(TextColType.Red, true);
                    }
                }
            }
            TreasureDungeon treasureDungeon;
            if (model.TryGetTreasureDungeon(model.selectedTreasure, out treasureDungeon))
            {
                var dungeonInfo = treasureDungeon.Get(treasureDungeon.maxLevel);
                if (!dungeonInfo.Equals(default(TreasureDungeonInfo)))
                {
                    var config = TreasureDungeonConfig.Get(dungeonInfo.key);
                    m_SkillTitle.text = Language.Get("PassTreasureDungeonSkillTitle", config.bossName);
                }
            }
        }

        private void DisplayChallenge()
        {
            Treasure treasure;
            if (!model.TryGetTreasure(model.selectedTreasure, out treasure))
            {
                return;
            }
            m_ContainerChallenge.SetActive(treasure.state == TreasureState.Collecting);
            var fightPower = PlayerDatas.Instance.baseData.FightPoint;
            var defense = (int)UIHelper.GetPropertyValue(PropertyType.DEF);
            var recommandPower = 0;
            var recommandDefense = 0;
            TreasureDungeon treasureDungeon;
            if (model.TryGetTreasureDungeon(model.selectedTreasure, out treasureDungeon))
            {
                var dungeonInfo = treasureDungeon.Get(treasureDungeon.currentLevel + 1);
                if (!dungeonInfo.Equals(default(TreasureDungeonInfo)))
                {
                    recommandPower = dungeonInfo.fightPower;
                    recommandDefense = dungeonInfo.defense;
                }
            }
            m_RecommondPower.text = Language.Get("TreasureRecommendAttr", StringUtility.Contact(fightPower, "/", recommandPower));
            m_RecommondPower.color = UIHelper.GetUIColor(fightPower >= (ulong)recommandPower ? TextColType.Green : TextColType.Red);


            m_RecommondDefense.text = Language.Get("TreasureRecommendDefense", StringUtility.Contact(defense, "/", recommandDefense));
            m_RecommondDefense.color = UIHelper.GetUIColor(defense >= recommandDefense ? TextColType.Green : TextColType.Red);
        }

        private void DisplayDungeons()
        {
            TreasureDungeon treasureDungeon;
            DemonDungeonScriptable config = ScriptableObjectLoader.LoadSoDemonDungeon(model.selectedTreasure);
            if (model.TryGetTreasureDungeon(model.selectedTreasure, out treasureDungeon))
            {
                for (int i = 0; i < m_DungeonBehaviours.Length; i++)
                {
                    if (i < treasureDungeon.dungeonInfos.Count)
                    {
                        m_DungeonBehaviours[i].SetActive(true);
                        m_DungeonBehaviours[i].Display(model.selectedTreasure, treasureDungeon.dungeonInfos[i].level);
                        if (config != null)
                        {
                            m_DungeonBehaviours[i].transform.localPosition = config.GetPosition(i);
                        }
                    }
                    else
                    {
                        m_DungeonBehaviours[i].SetActive(false);
                    }
                }
            }

            DisplayLines();
        }

        private void TreasureStateChangeEvent(int id)
        {
            if (!model.isServerReady)
            {
                return;
            }
            if (id == model.selectedTreasure)
            {
                DisplaySkill();
                DisplayProperty();
                DisplayChallenge();
                DisplayDungeons();

                UpdateAnimationStep();
            }
        }

        private void TreasureSelectedEvent(int id)
        {
            Display();
            UpdateAnimationStep();
        }

        private void DemonTreasureDungeonUpdate(int id)
        {
            if (!model.isServerReady)
            {
                return;
            }
            if (id == model.selectedTreasure)
            {
                DisplayDungeons();
                DisplayChallenge();
            }
        }

        private void UpdateAnimationStep()
        {
            Treasure treasure;
            if (model.TryGetTreasure(model.selectedTreasure, out treasure))
            {
                switch (treasure.state)
                {
                    case TreasureState.Collecting:
                    case TreasureState.Collected:
                        switch (step)
                        {
                            case AnimationStep.Collect2Lock:
                            case AnimationStep.None2Lock:
                                step = AnimationStep.Lock2Collect;
                                break;
                        }
                        break;
                    case TreasureState.Locked:
                        switch (step)
                        {
                            case AnimationStep.None2Collect:
                            case AnimationStep.Lock2Collect:
                                step = AnimationStep.Collect2Lock;
                                break;
                        }
                        break;
                }
            }
        }

        private void DisplayDungeonPosition()
        {
            TreasureDungeon treasureDungeon;
            var scriptable = ScriptableObjectLoader.LoadSoDemonDungeon(model.selectedTreasure);
            if (scriptable == null)
            {
                return;
            }
            var height = (m_DungeonBehaviours[0].transform as RectTransform).sizeDelta.y;
            var viewAreaHeight = (m_ContainerDungeons as RectTransform).sizeDelta.y;
            if (model.TryGetTreasureDungeon(model.selectedTreasure, out treasureDungeon))
            {
                var selectLevel = treasureDungeon.currentLevel == treasureDungeon.maxLevel ?
                    treasureDungeon.maxLevel : (treasureDungeon.currentLevel + 1);
                var selectPosition = scriptable.GetPosition(selectLevel - 1);
                var lastPosition = scriptable.GetPosition(treasureDungeon.maxLevel - 1);
                m_DungeonsContent.sizeDelta = m_DungeonsContent.sizeDelta.SetY(lastPosition.y + height / 2 * expand);
                m_ScrollRect.vertical = (lastPosition.y + height / 2 * expand) > viewAreaHeight;
                if (selectPosition.y + (height / 2) * expand <= viewAreaHeight)
                {
                    m_DungeonsContent.anchoredPosition = Vector3.zero;
                    return;
                }
                else if (lastPosition.y - selectPosition.y + height * expand + m_SelectHeight <= viewAreaHeight)
                {
                    var delta = lastPosition.y + (height / 2) * expand - viewAreaHeight;
                    m_DungeonsContent.anchoredPosition = m_DungeonsContent.localPosition.SetY(-delta);
                }
                else
                {
                    var delta = selectPosition.y - m_SelectHeight;
                    m_DungeonsContent.anchoredPosition = m_DungeonsContent.localPosition.SetY(-delta);
                }
            }
        }

        #region 特效
        const string LINE_STATE_2 = "Effect_FaBao_Xian3_02";
        public const float LINE_NORMAL_LENGTH = 200f;
        public const float LINE_NORMAL_SCALE = 0.78f;
        private void DisplayLines()
        {
            Treasure treasure;
            model.TryGetTreasure(model.selectedTreasure, out treasure);
            TreasureDungeon treasureDungeon;
            var scriptable = ScriptableObjectLoader.LoadSoDemonDungeon(model.selectedTreasure);
            if (scriptable == null || treasureTweening || treasure == null || treasure.state == TreasureState.Locked)
            {
                StopAllLine();
                return;
            }
            if (model.TryGetTreasureDungeon(model.selectedTreasure, out treasureDungeon))
            {
                for (int i = 1; i <= treasureDungeon.maxLevel; i++)
                {
                    var index = i - 1;
                    if (index < m_DungeonBehaviours.Length)
                    {
                        var line = m_DungeonBehaviours[index].line;
                        line.StopImediatly();
                        if (i <= treasureDungeon.currentLevel && treasureDungeon.maxLevel > i)
                        {
                            line.Play();
                            if (line.target != null)
                            {
                                var transform = line.target.transform;
                                var animator = line.target.GetAnimator();
                                var angle = VectorUtility.VectorAngle(scriptable.GetPosition(index + 1),
                                    scriptable.GetPosition(index));
                                line.target.transform.localEulerAngles = Vector3.zero.SetZ(angle);
                                if (animator != null)
                                {
                                    animator.Play(LINE_STATE_2, 0, 0);
                                    animator.transform.localScale = Vector3.one.SetY(Vector2.Distance(scriptable.GetPosition(index),
                                        scriptable.GetPosition(index + 1)) / LINE_NORMAL_LENGTH * LINE_NORMAL_SCALE);
                                }
                            }
                        }
                    }
                }
            }
        }

        private void StopAllLine()
        {
            for (int i = 0; i < m_DungeonBehaviours.Length; i++)
            {
                m_DungeonBehaviours[i].line.StopImediatly();
            }
        }
        #endregion

        enum AnimationStep
        {
            None,
            None2Lock,
            None2Collect,
            Lock2Collect,
            Collect2Lock,
        }

#if UNITY_EDITOR
        [SerializeField] DemonDungeonScriptable m_EditorScriptable;

        [ContextMenu("应用位置信息")]
        void ApplyPositions()
        {
            if (m_EditorScriptable == null)
            {
                return;
            }
            var index = 0;
            for (int i = 0; i < m_DungeonBehaviours.Length; i++)
            {
                if (m_DungeonBehaviours[i].gameObject.activeSelf)
                {
                    m_EditorScriptable.ApplyPosition(index, m_DungeonBehaviours[i].transform.localPosition);
                    index++;
                }
            }
        }
#endif
    }

}