//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Thursday, November 23, 2017
//--------------------------------------------------------

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

using System.Linq;

namespace Snxxz.UI
{

    public class TreasureNewGotWin : Window
    {
        [SerializeField] Transform m_ContainerMask;
        [SerializeField] RawImage m_GaussianMask;
        [SerializeField] RectTransform m_TreasureExhibitionPoint;
        [SerializeField] RectTransform m_ContainerFinishShow;
        [SerializeField] Button m_FinishShow;

        [SerializeField] UIAlphaTween m_FadeOut;
        [SerializeField] RectTransform m_FlyObjectPoint1;
        [SerializeField] RectTransform m_FlyObjectPoint2;
        [SerializeField] RectTransform m_FlyObjectPoint3;

        [SerializeField] UIEffect m_GotTreasureSfx;

        [SerializeField] Transform m_ContainerDescription;
        [SerializeField] RectTransform m_ContainerTreasureName;
        [SerializeField] UIAlphaTween m_FadeInTreasureName;
        [SerializeField] Slider m_TreasureNameSlider;
        [SerializeField] Text m_Category;
        [SerializeField] Text m_TreasureName;

        [SerializeField] RectTransform m_ContainerFuncUnLock;
        [SerializeField] Slider m_FuncUnLockSlider;
        [SerializeField] Text m_UnlockTip;
        [SerializeField] TreasureNewGotBehaviour[] m_TreasureNewGots;

        [SerializeField] RectTransform m_ContianerStory;
        [SerializeField] UIAlphaTween m_FadeInStory;
        [SerializeField] Text m_Story;

        [SerializeField] RectTransform m_ContainerProperty;
        [SerializeField] Slider m_PropertySlider;
        [SerializeField] UIAlphaTween m_FadeInProperty;
        [SerializeField] PropertyBehaviour[] m_BasePropertys;
        [SerializeField] PropertyBehaviour[] m_SpecialPropertys;

        [SerializeField] RectTransform m_ContainerFightPower;
        [SerializeField] Text m_FightPower;

        TreasureModel model { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }
        TaskModel taskmodel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }
        SkillModel skillModel { get { return ModelCenter.Instance.GetModel<SkillModel>(); } }
        KingTreasureModel kingTreasureModel { get { return ModelCenter.Instance.GetModel<KingTreasureModel>(); } }
        CrossServerOneVsOneModel oneVsOneModel { get { return ModelCenter.Instance.GetModel<CrossServerOneVsOneModel>(); } }

        FunctionUnlockFlyObject flyObject;
        FunctionUnlockFlyObject unlockFlyObject1;
        FunctionUnlockFlyObject unlockFlyObject2;
        TreasureNewGotBehaviour skillStageBehaviour;

        Treasure treasure;
        TreasureStage treasureStage;
        int displayStageCount = 0;
        float stageTime = 0.5f;
        public static event Action CloseTreasureNewGotWinEvent;

        ShowStep m_ShowStep = ShowStep.None;
        ShowStep showStep {
            get { return m_ShowStep; }
            set {
                if (m_ShowStep != value)
                {
                    m_ShowStep = value;

                    switch (m_ShowStep)
                    {
                        case ShowStep.None:
                            break;
                        case ShowStep.ShowModel:
                            OnEnterShowModel();
                            break;
                        case ShowStep.ShowSfx:
                            OnEnterShowSfx();
                            break;
                        case ShowStep.SliderName:
                            OnEnterSliderName();
                            break;
                        case ShowStep.ShowNameAndSliderUnlock:
                            OnEnterShowNameAndSliderUnlock();
                            break;
                        case ShowStep.ShowUnlock:
                            OnEnterShowFuncUnlock();
                            break;
                        case ShowStep.ShowStory:
                            OnEnterShowStory();
                            break;
                        case ShowStep.ShowProperty:
                            OnEnterShowProperty();
                            break;
                        case ShowStep.ShowComplete:
                            OnEnterShowComplete();
                            break;
                        case ShowStep.FadeOut:
                            OnEnterFadeOut();
                            break;
                        case ShowStep.FlyTo:
                            OnEnterFlyto();
                            break;
                    }

                }
            }
        }

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

        }

        protected override void AddListeners()
        {
            m_FinishShow.AddListener(FinishShow);
        }

        protected override void OnPreOpen()
        {
            PlayerDatas.Instance.hero.Behaviour.StopHandupAI();
            MapTransferUtility.Instance.Clear();
            PlayerDatas.Instance.hero.StopPathFind();

            m_ContainerMask.gameObject.SetActive(false);
            m_ContainerDescription.gameObject.SetActive(false);
            m_ContainerTreasureName.gameObject.SetActive(false);
            m_ContianerStory.gameObject.SetActive(false);
            m_ContainerFuncUnLock.gameObject.SetActive(false);
            m_UnlockTip.gameObject.SetActive(false);
            m_ContainerFinishShow.gameObject.SetActive(false);
            m_ContainerFightPower.gameObject.SetActive(false);
            m_ContainerProperty.gameObject.SetActive(false);

            for (int i = 0; i < m_TreasureNewGots.Length; i++)
            {
                m_TreasureNewGots[i].gameObject.SetActive(false);
            }

            model.TryGetTreasure(model.newGotTreasureId, out treasure);
            treasureStage = treasure.treasureStages.Find((x) =>
            {
                return x.stage == treasure.level;
            });
            showStep = ShowStep.None;
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {

        }

        protected override void OnAfterClose()
        {
            if (unlockFlyObject1 != null)
            {
                DestroyObject(unlockFlyObject1.gameObject);
                unlockFlyObject1 = null;
            }

            if (unlockFlyObject2 != null)
            {
                DestroyObject(unlockFlyObject2.gameObject);
                unlockFlyObject2 = null;
            }

            var config = TreasureConfig.Get(model.newGotTreasureId);
            if (config != null && config.Category == (int)TreasureCategory.Human)
            {
                if (PreFightMission.Instance.IsFinished())
                {
                    taskmodel.AutomaticTripToTask(taskmodel.currentMission);
                }
            }

            model.newGotTreasureId = 0;

            if (CloseTreasureNewGotWinEvent != null)
            {
                CloseTreasureNewGotWinEvent();
            }
        }

        protected override void OnActived()
        {
            base.OnActived();

            CameraUtility.ScreenShotCut(m_GaussianMask, DoPrepare, true);
        }

        #endregion

        float timer = 0f;
        protected override void LateUpdate()
        {
            base.LateUpdate();

            if (showStep != ShowStep.None)
            {
                timer += Time.deltaTime;
            }

            switch (showStep)
            {
                case ShowStep.None:
                    break;
                case ShowStep.ShowModel:
                    if (timer > 0.75f)
                    {
                        timer = 0f;
                        showStep = ShowStep.ShowSfx;
                    }
                    break;
                case ShowStep.ShowSfx:
                    if (timer > 0.3f)
                    {
                        timer = 0.0f;
                        showStep = ShowStep.SliderName;
                    }
                    break;
                case ShowStep.SliderName:
                    m_TreasureNameSlider.value = timer / 0.7f;
                    if (timer > 0.7f)
                    {
                        timer = 0f;
                        showStep = ShowStep.ShowNameAndSliderUnlock;
                    }
                    break;
                case ShowStep.ShowNameAndSliderUnlock:
                    m_FuncUnLockSlider.value = 0;
                    m_PropertySlider.value = 0;
                    if (timer > 0.7f)
                    {
                        timer = 0f;
                        showStep = ShowStep.ShowUnlock;
                    }
                    break;
                case ShowStep.ShowUnlock:
                    var length = m_TreasureNewGots.Length;
                    m_FuncUnLockSlider.value = timer / (length * stageTime);
                    if (timer > length * stageTime)
                    {
                        timer = 0f;
                        showStep = ShowStep.ShowComplete;
                    }
                    var index = (int)(timer / stageTime);
                    if (index < displayStageCount && index < m_TreasureNewGots.Length
                        && !m_TreasureNewGots[index].gameObject.activeSelf)
                    {
                        m_TreasureNewGots[index].Show();
                    }
                    break;
                case ShowStep.ShowStory:
                    if (timer > 0.7f)
                    {
                        timer = 0f;
                        showStep = ShowStep.ShowComplete;
                    }
                    break;
                case ShowStep.ShowProperty:
                    m_PropertySlider.value = timer / 0.7f;
                    if (timer > 0.7f)
                    {
                        timer = 0f;
                        showStep = ShowStep.ShowComplete;
                    }
                    break;
                case ShowStep.ShowComplete:
                    if (timer > 5f)
                    {
                        timer = 0f;
                        showStep = ShowStep.FadeOut;
                    }
                    break;
                case ShowStep.FadeOut:
                    if (timer > 1.5f)
                    {
                        timer = 0f;
                        showStep = ShowStep.FlyTo;
                    }
                    break;
                case ShowStep.FlyTo:
                    break;
            }

        }

        private void DoPrepare()
        {
            showStep = ShowStep.ShowModel;
            timer = 0f;

            var config = TreasureConfig.Get(treasure.id);
            m_TreasureName.text = config.Name;
            m_Story.text = config.Story;
            m_Category.text = Language.Get(string.Concat("GetTreasure_", config.Category));
            if ((TreasureCategory)config.Category == TreasureCategory.Human)
            {
                m_FightPower.text = model.GetTreasureFightPower(treasure.id, false).ToString();
            }

            switch ((TreasureCategory)config.Category)
            {
                case TreasureCategory.Fairy:
                case TreasureCategory.Human:
                    m_UnlockTip.text = Language.Get("TreasureCanAwake");
                    break;
                case TreasureCategory.Demon:
                    m_UnlockTip.text = Language.Get("TreasureAwaked");
                    break;
            }

            var instance = UIUtility.CreateWidget("TreasureUnlockFlyObject_1", "TreasureUnlockFlyObject_1");
            unlockFlyObject1 = instance.GetComponent<FunctionUnlockFlyObject>();
            Transform parent = (treasureStage != null && treasureStage.unlockType == TreasureStageUnlock.Skill) && treasure.id != 101
                && (TreasureCategory)config.Category != TreasureCategory.Fairy ? m_TreasureExhibitionPoint : m_FlyObjectPoint1;
            unlockFlyObject1.transform.SetParentEx(parent, Vector3.zero, Vector3.zero, Vector3.one);
            unlockFlyObject1.SetContent(FunctionUnlockType.Treasure, treasure.id);
            unlockFlyObject1.SetSpeed(treasure.id == 101 ? 3f : 5f);
            unlockFlyObject1.gameObject.SetActive(false);

            var _flyObjectPoint = m_FlyObjectPoint2;

            var index = 0;
            displayStageCount = 0;
            for (int i = 0; i < m_TreasureNewGots.Length; i++)
            {
                TreasureStage _stage = null;
                for (int k = index; k < treasure.treasureStages.Count; k++)
                {
                    index++;
                    if (treasure.treasureStages[k].unlockType == TreasureStageUnlock.Func ||
                        treasure.treasureStages[k].unlockType == TreasureStageUnlock.Skill)
                    {
                        _stage = treasure.treasureStages[k];
                        displayStageCount++;
                        break;
                    }
                }
                if (_stage != null)
                {
                    m_TreasureNewGots[i].Display(treasure.id, _stage.stage);
                    if (_stage.unlockType == TreasureStageUnlock.Skill)
                    {
                        skillStageBehaviour = m_TreasureNewGots[i];
                    }
                }
            }


            if (treasureStage != null && (TreasureCategory)config.Category != TreasureCategory.Fairy
                && treasureStage.unlockType == TreasureStageUnlock.Skill && treasure.id != 101)
            {
                var instance2 = UIUtility.CreateWidget("TreasureUnlockFlyObject_2", "TreasureUnlockFlyObject_2");
                unlockFlyObject2 = instance2.GetComponent<FunctionUnlockFlyObject>();
                unlockFlyObject2.transform.SetParentEx(_flyObjectPoint, Vector3.zero, Vector3.zero, Vector3.one);
                unlockFlyObject2.SetContent(FunctionUnlockType.TreasureSkill, treasure.id);
                unlockFlyObject2.gameObject.SetActive(false);
                flyObject = unlockFlyObject2;

                if ((TreasureCategory)config.Category == TreasureCategory.Demon && treasure.id != 203)
                {
                    ModelCenter.Instance.GetModel<SkillModel>().jumpToPass = true;
                }
                else
                {
                    ModelCenter.Instance.GetModel<SkillModel>().jumpToPass = false;
                }
            }
            else
            {
                switch (config.ID)
                {
                    case 302:
                    case 305:
                    case 306:
                    case 307:
                        m_Story.text = config.Verse.Length == 0 ? string.Empty : config.Verse[0];
                        break;
                    case 303:
                        {
                            var killNpcConfig = VIPKillNPCConfig.Get(1);
                            m_Story.text = string.Format(config.Verse[0], killNpcConfig.MaxAtk);
                        }
                        break;
                    case 304://签到相关配置移到功能配置表
                        var _propertyDict = model.GetSignInPropertys();
                        if (_propertyDict != null)
                        {
                            var _keyValue = _propertyDict.First();
                            var _propertyConfig = PlayerPropertyConfig.Get(_keyValue.Key);
                            m_Story.text = string.Format(config.Verse[0], _keyValue.Value, _propertyConfig.Name);
                        }
                        break;
                }
                flyObject = unlockFlyObject1;
            }

            if ((TreasureCategory)config.Category == TreasureCategory.King)
            {
                var season = 0;
                Dictionary<int, int> basePropertys = null;
                Dictionary<int, int> specialPropertys = null;
                if (kingTreasureModel.TryGetSeason(config.ID, out season))
                {
                    CrossServerOneVsOneModel.CrossServerOneVsOneHistory history;
                    if (oneVsOneModel.TryGetOneVsOneHistory(season, out history))
                    {
                        KingTreasureModel.Division division;
                        if (kingTreasureModel.TryGetDivision(config.ID, history.rewardLevel, out division))
                        {
                            basePropertys = division.basePropertys;
                            specialPropertys = division.specialPropertys;
                        }
                    }
                }
                var propertyIndex = 0;
                if (basePropertys != null)
                {
                    foreach (var key in basePropertys.Keys)
                    {
                        if (propertyIndex < m_BasePropertys.Length)
                        {
                            m_BasePropertys[propertyIndex].gameObject.SetActive(true);
                            m_BasePropertys[propertyIndex].DisplayUpper(key, basePropertys[key]);
                        }
                        propertyIndex++;
                    }
                }
                for (int i = propertyIndex; i < m_BasePropertys.Length; i++)
                {
                    m_BasePropertys[i].gameObject.SetActive(false);
                }
                propertyIndex = 0;
                if (specialPropertys != null)
                {
                    foreach (var key in specialPropertys.Keys)
                    {
                        if (propertyIndex < m_SpecialPropertys.Length)
                        {
                            m_SpecialPropertys[propertyIndex].gameObject.SetActive(true);
                            m_SpecialPropertys[propertyIndex].DisplayUpper(key, specialPropertys[key]);
                        }
                        propertyIndex++;
                    }
                }
                for (int i = propertyIndex; i < m_SpecialPropertys.Length; i++)
                {
                    m_SpecialPropertys[i].gameObject.SetActive(false);
                }
            }
        }

        private void FinishShow()
        {
            if (showStep == ShowStep.ShowComplete)
            {
                timer = 0f;
                showStep = ShowStep.FadeOut;
            }
        }

        private void FlyTo()
        {
            m_ContainerMask.gameObject.SetActive(false);
            m_ContainerDescription.gameObject.SetActive(false);
            flyObject.Begin(CloseClick);
        }

        public override void CloseClick()
        {
            if (treasure.id == TreasureModel.TREASURE_GUIDE_ID)
            {
                NewBieCenter.Instance.StartNewBieGuide(14);
            }
            else if (treasure.id == 203 && skillModel.PassOpenHoleCount() == 2)
            {
                NewBieCenter.Instance.StartNewBieGuide(45);
            }
            else if (treasure.id == 101)
            {
                NewBieCenter.Instance.StartNewBieGuide(3);
            }
            base.CloseClick();
        }

        private void OnEnterShowModel()
        {
            m_FadeOut.SetStartState();
            m_ContainerMask.gameObject.SetActive(true);
        }

        private void OnEnterShowSfx()
        {
            m_GotTreasureSfx.Play();
        }

        private void OnEnterSliderName()
        {
            unlockFlyObject1.gameObject.SetActive(true);
            m_ContainerDescription.gameObject.SetActive(true);
            m_TreasureNameSlider.value = 0f;
        }

        private void OnEnterShowFuncUnlock()
        {
            m_ContainerFuncUnLock.gameObject.SetActive(true);
            var config = TreasureConfig.Get(treasure.id);
            if ((TreasureCategory)config.Category == TreasureCategory.Human)
            {
                m_ContainerFightPower.gameObject.SetActive(false);
            }
            else if (config.Category == (int)TreasureCategory.Fairy && config.ID != 301)
            {
                m_ContainerFuncUnLock.gameObject.SetActive(false);
                showStep = ShowStep.ShowStory;
                return;
            }
            else if (config.Category == (int)TreasureCategory.King)
            {
                m_ContainerFuncUnLock.gameObject.SetActive(false);
                showStep = ShowStep.ShowProperty;
                return;
            }
            if (displayStageCount == 0)
            {
                showStep = ShowStep.ShowComplete;
            }
        }

        private void OnEnterShowNameAndSliderUnlock()
        {
            m_ContainerTreasureName.gameObject.SetActive(true);
            m_FadeInTreasureName.SetStartState();
            m_FadeInTreasureName.Play();

            m_UnlockTip.gameObject.SetActive(true);
        }

        private void OnEnterShowStory()
        {
            m_ContianerStory.gameObject.SetActive(true);
            m_FadeInStory.SetStartState();
            m_FadeInStory.Play();
        }

        private void OnEnterShowProperty()
        {
            m_ContainerProperty.gameObject.SetActive(true);
            m_FadeInProperty.SetStartState();
            m_FadeInProperty.Play();
        }

        private void OnEnterShowComplete()
        {
            m_ContainerFinishShow.gameObject.SetActive(true);
            if (skillStageBehaviour != null)
            {
                var worldpos = skillStageBehaviour.m_SkillContainer.TransformPoint(Vector3.zero);
                var localpos = (transform as RectTransform).InverseTransformPoint(worldpos);
                m_FlyObjectPoint2.localPosition = localpos;
            }
        }

        private void OnEnterFadeOut()
        {
            if (unlockFlyObject2 != null)
            {
                unlockFlyObject2.gameObject.SetActive(true);
            }
            m_FadeOut.SetStartState();
            m_FadeOut.Play();
        }

        private void OnEnterFlyto()
        {
            FlyTo();
        }

        enum ShowStep
        {
            None,
            ShowSfx,
            ShowModel,
            SliderName,
            ShowNameAndSliderUnlock,
            ShowUnlock,
            ShowStory,
            ShowProperty,
            ShowComplete,
            FadeOut,
            FlyTo,
        }


    }

}