//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Thursday, May 03, 2018
//--------------------------------------------------------

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

using UnityEngine;
using UnityEngine.UI;

namespace Snxxz.UI
{
    [XLua.Hotfix]
    public class HumanTreasureWin : Window
    {
        [SerializeField] Transform m_ContainerDisplay;
        [SerializeField] Transform m_Container;
        [SerializeField] PositionTween m_PositionTween1;
        [SerializeField] PositionTween m_PositionTween2;
        [SerializeField] Image m_TreasureName;
        [SerializeField] Text m_TaskTitle;
        [SerializeField] Text m_TreasureStory;
        [SerializeField] Button m_ViewDetail;
        [SerializeField] Image m_SkillIcon;
        [SerializeField] Text m_SkillName;
        [SerializeField] Button m_Challenge;
        [SerializeField] Text m_ChallengeCondition;
        [SerializeField] Slider m_TaskSlider;
        [SerializeField] Text m_TaskProgress;
        [SerializeField] UIEffect m_EffectInduction;
        [SerializeField] UIEffect m_EffectInduction1;

        [SerializeField] Transform m_ContainerSkillDetial;
        [SerializeField] Image m_SkillDetailIcon;
        [SerializeField] Text m_SkillDetailName;
        [SerializeField] Text m_SkillCoolDown;
        [SerializeField] Button m_Preview;
        [SerializeField] Text m_SkillDescription;
        

        [SerializeField] ScrollerController m_TaskController;

        bool animationStep = false;

        float displayTime = 0f;

        List<int> animationClues = new List<int>();

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

        TaskModel taskModel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }

        protected override void BindController()
        {
            m_TaskController.lockType = EnhanceLockType.KeepVertical;
        }

        protected override void AddListeners()
        {
            m_Challenge.AddListener(Challenge);
            m_Preview.SetListener(Preview);
            m_ViewDetail.AddListener(ViewDetail);

            m_TaskController.OnRefreshCell += OnRefreshCell;
        }

        protected override void OnPreOpen()
        {
            m_ContainerSkillDetial.gameObject.SetActive(false);

            animationStep = false;

            TreasureBaseWin.allowSelectTreasure += AllowSelectTreasure;
            model.treasureSelectedEvent += TreasureSelectedEvent;
            model.onInductionTaskComplete += OnInductionTaskComplete;
        }

        protected override void OnActived()
        {
            base.OnActived();
            Display();
            DisplayAnimation();
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            TreasureBaseWin.allowSelectTreasure -= AllowSelectTreasure;
            model.treasureSelectedEvent -= TreasureSelectedEvent;
            model.onInductionTaskComplete -= OnInductionTaskComplete;

            StopAllCoroutines();
        }

        protected override void OnAfterClose()
        {
        }

        void Display()
        {
            DisplayBase();
            DisplayProgress();
            DisplayTasks();
        }

        void DisplayBase()
        {
            var config = TreasureConfig.Get(model.selectedTreasure);
            m_TreasureName.SetSprite(config.TreasureNameIcon);
            m_TreasureStory.text = config.Story;

            var chapterConfig = TreasureChapterConfig.Get(model.selectedTreasure);
            m_ChallengeCondition.text = chapterConfig.condition;

            List<int> tasks = null;
            if (model.TryGetTreasureTasks(model.selectedTreasure, out tasks))
            {
                var taskConfig = TaskListConfig.Get(tasks[0]);
                m_TaskTitle.text = taskConfig.ChapterName;
            }

            Treasure treasure;
            if (model.TryGetTreasure(model.selectedTreasure, out treasure))
            {
                var skillId = treasure.skillId;
                var skillConfig = SkillConfig.Get(skillId);
                m_SkillIcon.SetSprite(skillConfig.IconName);
                m_SkillName.text = skillConfig.SkillName;
            }
        }

        void DisplayProgress()
        {
            Treasure treasure;
            if (model.TryGetTreasure(model.selectedTreasure, out treasure))
            {
                var satisfyChallenge = model.SatisfyChallenge(model.selectedTreasure);

                m_Challenge.gameObject.SetActive(satisfyChallenge);

                var progress = 1f;

                Dictionary<int, List<int>> clues;
                if (model.TryGetTreasureClues(model.selectedTreasure, out clues))
                {
                    var count = model.GetCompleteTaskCount(model.selectedTreasure);
                    progress = Mathf.Clamp01((float)count / clues.Count);
                    m_TaskProgress.text = StringUtility.Contact((int)(progress * 100), "%");
                }

                m_TaskSlider.value = progress;
            }
        }

        void DisplayTasks(bool taskAnimation = false)
        {
            var inductionTaskId = 0;
            model.TryGetLatestInductionTask(model.selectedTreasure, out inductionTaskId);

            var inductionState = model.GetTreasureInductionState(model.selectedTreasure);

            animationClues.Clear();

            displayTime = 0f;

            var index = -1;
            var jumpIndex = -1;

            m_TaskController.Refresh();
            Dictionary<int, List<int>> clues;
            if (model.TryGetTreasureClues(model.selectedTreasure, out clues))
            {
                var lastClue = 0;
                foreach (var clue in clues.Keys)
                {
                    var display = false;
                    var tasks = clues[clue];
                    switch (inductionState)
                    {
                        case -1:
                        case 0:
                            display = inductionTaskId > tasks[tasks.Count - 1];
                            break;
                        case 1:
                            display = true;
                            break;
                    }

                    var clueState = model.GetClueState(model.selectedTreasure, clue);

                    if (display)
                    {
                        if (taskAnimation)
                        {
                            if (model.displayInductionId < tasks[tasks.Count - 1])
                            {
                                animationClues.Add(clue);
                            }
                        }

                        index++;
                        m_TaskController.AddCell(ScrollerDataType.Header, clue);
                        lastClue = clue;

                        if (clueState == 1 && jumpIndex != -1)
                        {
                            jumpIndex = index;
                        }
                    }
                }
                HumanTreasureTaskCell.lastClue = lastClue;
                if (inductionState == 0)
                {
                    index++;
                    HumanTreasureTaskCell.lastClue = -1;
                    m_TaskController.AddCell(ScrollerDataType.Normal, inductionTaskId);
                    jumpIndex = index;
                }
            }
            m_TaskController.Restart();

            if (taskAnimation)
            {
                Clock.AlarmAfter(Mathf.CeilToInt(displayTime + 0.6f), () =>
                {
                    m_TaskController.mScrollRect.enabled = true;
                    animationClues.Clear();
                });
            }
            else
            {
                m_TaskController.mScrollRect.enabled = true;
                if (jumpIndex != -1)
                {
                    m_TaskController.JumpIndex(jumpIndex);
                }
            }
        }

        void DisplayAnimation()
        {
            animationStep = true;

            m_PositionTween1.Play();
            m_PositionTween2.Play();

            UI3DTreasureSelectStage.Instance.Tween(OnTweenComplete);

            m_Container.gameObject.SetActive(false);
        }

        void DisplaySkillDetail()
        {
            if (!m_ContainerSkillDetial.gameObject.activeSelf)
            {
                m_ContainerSkillDetial.gameObject.SetActive(true);
                Treasure treasure;
                if (model.TryGetTreasure(model.selectedTreasure, out treasure))
                {
                    var skillId = treasure.skillId;
                    var skillConfig = SkillConfig.Get(skillId);
                    m_SkillDetailIcon.SetSprite(skillConfig.IconName);
                    m_SkillDetailName.text = skillConfig.SkillName;
                    m_SkillDescription.text = skillConfig.Description;
                    m_SkillCoolDown.text = skillConfig.CoolDownTime == 0 ? string.Empty :
                        Language.Get("L1065", skillConfig.CoolDownTime / 1000);
                }
            }
        }

        private void OnTweenComplete()
        {
            animationStep = false;
            m_Container.gameObject.SetActive(true);
        }

        private void TreasureSelectedEvent(int obj)
        {
            StopAllCoroutines();

            m_PositionTween1.Stop();
            m_PositionTween2.Stop();
            m_PositionTween1.SetEndState();
            m_PositionTween2.SetEndState();
            m_Container.gameObject.SetActive(true);
            m_ContainerSkillDetial.gameObject.SetActive(false);
            UI3DTreasureSelectStage.Instance.SetEndState();
            Display();
        }

        private void OnInductionTaskComplete(int id)
        {
            if (id == model.selectedTreasure)
            {
                var count = m_TaskController.GetNumberOfCells(m_TaskController.m_Scorller);
                m_TaskController.JumpIndex(count - 1);
                m_EffectInduction.Play();
                m_EffectInduction1.Play();
                m_TaskController.mScrollRect.enabled = false;
                StartCoroutine(Co_DelayShowTask());
            }
        }

        IEnumerator Co_DelayShowTask()
        {
            yield return WaitingForSecondConst.WaitMS3000;
            DisplayTasks(true);
        }

        private void Challenge()
        {
            var config = TreasureConfig.Get(model.selectedTreasure);
            if (config != null)
            {
                if (model.selectedTreasure == 101)
                {
                    ClientTreasureDungeon.RequestEnter(101);
                    return;
                }
                if (PlayerDatas.Instance.baseData.LV >= config.ChallengeLevel)
                {
                    model.collectingHuman = model.selectedTreasure;
                    ModelCenter.Instance.GetModel<DungeonModel>().SingleChallenge(TreasureModel.TREASURE_DATAMAPID, config.LineId);
                }
            }
        }

        private void ViewDetail()
        {
            DisplaySkillDetail();
        }

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

        private void OnRefreshCell(ScrollerDataType type, CellView cell)
        {
            if (type == ScrollerDataType.Header)
            {
                var taskCell = cell as HumanTreasureTaskCell;
                taskCell.transform.SetParent(m_TaskController.m_Scorller.LayoutGroup.transform);
                var animation = false;
                if (animationClues.Contains(cell.index))
                {
                    animation = true;
                    displayTime += 0.6f;
                }
                taskCell.Display(cell.index, animation, displayTime);
            }
        }

        private void Preview()
        {
            UI3DTreasureSelectStage.Instance.CloseRenderCamera();
            m_ContainerDisplay.gameObject.SetActive(false);
            var baseWin = WindowCenter.Instance.Get<TreasureBaseWin>();
            if (baseWin != null)
            {
                baseWin.DisplayContainer(false);
            }
            UI3DHeroSkillShow.Instance.ShowTreasureSkill(model.selectedTreasure, () =>
            {
                UI3DTreasureSelectStage.Instance.OpenRenderCamera();
                m_ContainerDisplay.gameObject.SetActive(true);
                baseWin.DisplayContainer(true);
            });
        }
    }
}