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

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

namespace Snxxz.UI
{

    public class TreasureBaseWin : Window
    {
        [SerializeField] RectTransform m_DisplayContainer;
        [SerializeField] Image m_TreasureTitle;
        [SerializeField] DragSelectComponent m_DragSelect;
        [SerializeField] Button m_Left;
        [SerializeField] Button m_Right;
        [SerializeField] Button m_Back;

        public static event Func<int, bool> allowSelectTreasure;
        public static event Func<int> allowBack;
        public static event Action<int> prepareSelectTreasure;
        public static event Action prepareBack;

        bool backToSelectWindow = false;

        TreasureModel model
        {
            get { return ModelCenter.Instance.GetModel<TreasureModel>(); }
        }
        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_Left.onClick.AddListener(Left);
            m_Right.onClick.AddListener(Right);
            m_Back.onClick.AddListener(Back);
        }

        protected override void OnPreOpen()
        {
            backToSelectWindow = false;
            m_DisplayContainer.gameObject.SetActive(false);
            if (UI3DTreasureSelectStage.Instance.IsOpen)
            {
                if (UI3DTreasureSelectStage.Instance.jumpTreasure != 0)
                {
                    model.selectedTreasure = UI3DTreasureSelectStage.Instance.jumpTreasure;
                }
                else
                {
                    model.selectedTreasure = UI3DTreasureSelectStage.Instance.selectTreasure;
                }
            }
        }

        protected override void OnAfterOpen()
        {
            UI3DTreasureSelectStage.Instance.OnCameraCloserComplete += OnCameraCloserComplete;
            UI3DTreasureSelectStage.Instance.OnCameraBackComplete += OnCameraBackComplete;
            m_DragSelect.onDragComplete += OnDragComplete;
            model.treasureSelectedEvent += TreasureSelectedEvent;

            CameraManager.uiCamera.enabled = true;
            if (!UI3DTreasureSelectStage.Instance.IsOpen)
            {
                UI3DTreasureSelectStage.Instance.Open(true, model.currentCategory);
                var _list = model.GetTreasureCategory(model.currentCategory);
                var _index = _list.FindIndex((x) =>
                {
                    return x == model.selectedTreasure;
                });
                UI3DTreasureSelectStage.Instance.GotoImmediatly(_index);
                OnCameraCloserComplete();
            }
            else if (UI3DTreasureSelectStage.Instance.CloserComplete)
            {
                OnCameraCloserComplete();
            }
        }

        protected override void OnPreClose()
        {
            CloseSubWindows();

            UI3DTreasureSelectStage.Instance.OnCameraCloserComplete -= OnCameraCloserComplete;
            UI3DTreasureSelectStage.Instance.OnCameraBackComplete -= OnCameraBackComplete;
            m_DragSelect.onDragComplete -= OnDragComplete;
            model.treasureSelectedEvent -= TreasureSelectedEvent;

            if (!backToSelectWindow)
            {
                UI3DTreasureSelectStage.Instance.Close();
            }
        }

        protected override void OnAfterClose()
        {
        }
        #endregion

        private void TreasureSelectedEvent(int treasureId)
        {
            DisplaySelects();
            var list = model.GetTreasureCategory(model.currentCategory);
            var index = list.FindIndex((x) =>
            {
                return x == treasureId;
            });
            if (index != -1)
            {
                UI3DTreasureSelectStage.Instance.GotoImmediatly(index);
            }
        }

        private void OnCameraCloserComplete()
        {
            if (WindowCenter.Instance.IsOpen<EffectToFaBaoWin>())
            {
                WindowCenter.Instance.CloseImmediately<EffectToFaBaoWin>();
            }
            CloseSubWindows();
            m_DisplayContainer.gameObject.SetActive(true);
            UI3DTreasureSelectStage.Instance.SetStartState();
            switch (model.currentCategory)
            {
                case TreasureCategory.Human:
                    m_TreasureTitle.SetSprite("XT_FB_45");
                    m_Left.image.SetSprite("XT_FB_33");
                    m_Right.image.SetSprite("XT_FB_34");
                    WindowCenter.Instance.Open<TreasureLevelUpWin>();
                    break;
                case TreasureCategory.Demon:
                    m_TreasureTitle.SetSprite("XT_FB_46");
                    m_Left.image.SetSprite("XT_FB_35");
                    m_Right.image.SetSprite("XT_FB_36");
                    WindowCenter.Instance.Open<DemonTreasureWin>();
                    break;
                case TreasureCategory.Fairy:
                    m_TreasureTitle.SetSprite("XT_FB_47");
                    m_Left.image.SetSprite("XT_FB_33");
                    m_Right.image.SetSprite("XT_FB_34");
                    WindowCenter.Instance.Open<FairyTreasureWin>();
                    break;
            }
            DisplaySelects();
        }

        private void DisplaySelects()
        {
            var leftRifht = Config.Instance.Get<TreasureConfig>(model.selectedTreasure + 1);
            m_Right.gameObject.SetActive(leftRifht != null);
            leftRifht = Config.Instance.Get<TreasureConfig>(model.selectedTreasure - 1);
            m_Left.gameObject.SetActive(leftRifht != null);
        }

        private void OnCameraBackComplete()
        {
            backToSelectWindow = true;
            CloseImmediately();
        }

        private void OnDragComplete(int result)
        {
            if (result > 0)
            {
                Right();
            }
            else if (result < 0)
            {
                Left();
            }
        }

        private void Left()
        {
            var selectTreasure = model.selectedTreasure - 1;
            if (!AllowSelectTreasure(selectTreasure))
            {
                return;
            }
            if (prepareSelectTreasure != null)
            {
                prepareSelectTreasure(selectTreasure);
            }
            model.selectedTreasure = selectTreasure;
        }

        private void Right()
        {
            var selectTreasure = model.selectedTreasure + 1;
            if (!AllowSelectTreasure(selectTreasure))
            {
                return;
            }
            if (prepareSelectTreasure != null)
            {
                prepareSelectTreasure(selectTreasure);
            }
            model.selectedTreasure = selectTreasure;
        }

        private void Back()
        {
            var returnCode = 0;
            if (allowBack != null)
            {
                returnCode = allowBack();
            }
            if (returnCode != 0)
            {
                return;
            }
            if (PlayerDatas.Instance.baseData.LV < model.treasureBackLvLimit
                            && !WindowJumpMgr.Instance.IsJumpState)
            {
                StartBack();
                return;
            }
            if (!WindowJumpMgr.Instance.IsJumpState && model.openFromTreasureList)
            {
                StartBack();
                return;
            }
            if (!WindowJumpMgr.Instance.IsJumpState && model.exitRecord >= 4)
            {
                StartBack();
                model.exitRecord = 0;
                return;
            }
            model.openFromTreasureList = false;
            CloseImmediately();
            if (!WindowJumpMgr.Instance.IsJumpState)
            {
                model.exitRecord++;
                WindowCenter.Instance.Open<MainInterfaceWin>();
            }
        }

        void StartBack()
        {
            if (prepareBack != null)
            {
                prepareBack();
            }
            model.openFromTreasureList = false;
            CloseSubWindows();
            m_DisplayContainer.gameObject.SetActive(false);
            WindowCenter.Instance.Open<TreasureSelectWin>(true);
            UI3DTreasureSelectStage.Instance.StartBack();
        }

        private bool AllowSelectTreasure(int treasureId)
        {
            Treasure treasure;
            if (!model.TryGetTreasure(treasureId, out treasure))
            {
                return false;
            }
            if (allowSelectTreasure != null && !allowSelectTreasure(treasureId))
            {
                return false;
            }
            return true;
        }

        private void CloseSubWindows()
        {
            var childrens = WindowConfig.Get().FindChildWindows("TreasureBaseWin");
            foreach (var window in childrens)
            {
                WindowCenter.Instance.Close(window);
            }
        }
    }

}