using System;
using System.Collections;
using System.Collections.Generic;
using TableConfig;
using UnityEngine;
using UnityEngine.UI;
using DG.Tweening;
namespace Snxxz.UI
{
    public class TreasureMeridianBehaviour : MonoBehaviour
    {
        [SerializeField] CanvasGroup m_CanvasGroup;
        [SerializeField] ScaleTween m_ScaleTween;
        [SerializeField] PositionTween m_PositionTween;
        [SerializeField] Image m_IconBottom;
        [SerializeField] Image m_Bottom;
        [SerializeField] Image m_Icon;
        [SerializeField] Button m_Button;
        [SerializeField] List<Text> m_Descs;
        [SerializeField] UIEffect m_LineSfx;
        [SerializeField] UIEffect m_SelectSfx;
        TreasureModel m_Model;
        TreasureModel model
        {
            get
            {
                return m_Model ?? (m_Model = ModelCenter.Instance.GetModel<TreasureModel>());
            }
        }

        Treasure m_Treasure;
        TreasureStage m_TreasureStage;
        TreasureLevelUpWin m_TreasureLevelUpWin;

        int stageIndex = 0;
        int lineState = 0;
        float timer = 0;
        float duration = 0;

        public Animator lineAnimator
        {
            get
            {
                if (m_LineSfx.target != null)
                {
                    return m_LineSfx.target.GetAnimator();
                }
                return null;
            }
        }

        public ScaleTween scaleTween
        {
            get
            {
                return m_ScaleTween;
            }
        }

        public PositionTween positionTween
        {
            get
            {
                return m_PositionTween;
            }
        }

        public UIEffect selectSfx
        {
            get
            {
                return m_SelectSfx;
            }
        }

        private void Awake()
        {
            m_Button.onClick.AddListener(OnStageClick);
        }

        private void OnDisable()
        {
            if (m_TreasureLevelUpWin != null)
            {
                m_TreasureLevelUpWin.OnLineStepComplete -= OnLineStepComplete;
            }
        }

        private void OnStageClick()
        {
            if (m_TreasureStage != null&&  m_TreasureStage.unlockType != TreasureStageUnlock.Property)
            {
                if (m_TreasureStage.unlockType == TreasureStageUnlock.Item)
                {
                    var item = m_TreasureStage.item;
                    ItemAttrData itemAttrData = new ItemAttrData(item.id, true, (ulong)item.count, -1, item.bind ? 1 : 0);
                    ModelCenter.Instance.GetModel<ItemTipsModel>().SetItemTipsModel(itemAttrData);
                    return;
                }
                model.selectedStage = m_TreasureStage.stage;
                if (!WindowCenter.Instance.CheckOpen<TreasureStageTipWin>())
                {
                    TreasureStageTipWin.SetTargetPosition(this.transform as RectTransform);
                    WindowCenter.Instance.Open<TreasureStageTipWin>();
                }
            }
        }

        public void SetScale(float _scale)
        {
            m_Icon.transform.localScale = _scale * Vector3.one;
            m_IconBottom.transform.localScale = _scale * Vector3.one;
        }

        public void Display(int _stage, int _stageIndex, TreasureLevelUpWin _win)
        {
            m_TreasureLevelUpWin = _win;
            m_TreasureLevelUpWin.OnLineStepComplete -= OnLineStepComplete;
            m_TreasureLevelUpWin.OnLineStepComplete += OnLineStepComplete;
            stageIndex = _stageIndex;
            if (model.TryGetTreasure(model.selectedTreasure, out m_Treasure))
            {
                var _list = m_Treasure.treasureStages;
                m_TreasureStage = _list.Find((x) =>
                {
                    return x.stage == _stage;
                });
                if (m_TreasureStage == null)
                {
                    return;
                }
                for (int i = 0; i < m_Descs.Count; i++)
                {
                    m_Descs[i].gameObject.SetActive(false);
                }
                m_Descs[0].transform.localScale = Vector3.one;
                var _config = ScriptableObjectLoader.LoadSoTreasureMeridian(model.selectedTreasure);
                m_Bottom.transform.localScale = _config[stageIndex].scale * Vector3.one;
                switch (m_TreasureStage.unlockType)
                {
                    case TreasureStageUnlock.Property:
                        var _index = 0;
                        foreach (var _key in m_TreasureStage.propertyDict.Keys)
                        {
                            m_Descs[_index].gameObject.SetActive(true);
                            m_Descs[_index].color = UIHelper.s_LightYellow;
                            var _propertyCfg = Config.Instance.Get<PlayerPropertyConfig>(_key);
                            m_Descs[_index].text = StringUtility.Contact(_propertyCfg.Name, " +"
                                , UIHelper.ReplaceLargeNum(m_TreasureStage.propertyDict[_key]));
                            _index++;
                            if (GeneralConfig.Instance.propertyIconDict.ContainsKey(_key))
                            {
                                m_Icon.SetSprite(GeneralConfig.Instance.propertyIconDict[_key]);
                            }
                        }
                        m_Icon.SetNativeSize();
                        break;
                    case TreasureStageUnlock.Skill:
                        var _skillId = m_TreasureStage.GetSkill(PlayerDatas.Instance.baseData.Job);
                        var _skillCfg = Config.Instance.Get<SkillConfig>(_skillId);
                        m_Descs[0].text = Language.Get(m_Treasure.id == 104 ? "TreasureNewXpSkill" : "TreasureNewSkill", _skillCfg.SkillName);
                        m_Descs[0].color = m_Treasure.id == 104 ? UIHelper.GetUIColor(TextColType.NavyYellow) : UIHelper.s_LightYellow;
                        m_Descs[0].gameObject.SetActive(true);
                        m_Icon.SetSprite(_skillCfg.IconName);
                        m_Icon.SetNativeSize();
                        break;
                    case TreasureStageUnlock.Func:
                        var _funcCfg = Config.Instance.Get<FuncOpenLVConfig>(m_TreasureStage.func);
                        m_Descs[0].text = Language.Get("TreasureNewFunc", _funcCfg.Remark);
                        m_Descs[0].color = UIHelper.s_LightYellow;
                        m_Descs[0].gameObject.SetActive(true);
                        m_Icon.SetSprite(_funcCfg.Icon);
                        m_Icon.SetNativeSize();
                        break;
                    case TreasureStageUnlock.Item:
                        m_Descs[0].gameObject.SetActive(true);
                        m_Descs[0].color = UIHelper.s_LightYellow;
                        var itemConfig = Config.Instance.Get<ItemConfig>(m_TreasureStage.item.id);
                        m_Icon.SetSprite(itemConfig.IconKey);
                        m_Descs[0].text = itemConfig.ItemName;
                        m_Icon.SetNativeSize();
                        break;
                    case TreasureStageUnlock.Treasure:
                        m_Descs[0].gameObject.SetActive(true);
                        m_Descs[0].color = UIHelper.s_LightYellow;
                        var treasureConfig = Config.Instance.Get<TreasureConfig>(m_TreasureStage.treasure);
                        m_Icon.SetSprite(treasureConfig.Icon);
                        m_Descs[0].text = treasureConfig.Name;
                        m_Icon.rectTransform.sizeDelta = new Vector2(86, 86);
                        break;
                    case TreasureStageUnlock.TreasureSoul:
                        m_Descs[0].gameObject.SetActive(true);
                        m_Descs[0].color = UIHelper.s_LightYellow;
                        var treasureSoulConfig = Config.Instance.Get<TreasurePrivilegeConfig>(m_TreasureStage.treasureSoul);
                        m_Icon.SetSprite(treasureSoulConfig.Icon);
                        m_Descs[0].text = treasureSoulConfig.Name;
                        m_Icon.SetNativeSize();
                        var sizeDelta = m_Icon.rectTransform.sizeDelta;
                        m_Icon.rectTransform.sizeDelta = new Vector2(86, (sizeDelta.y / sizeDelta.x) * 86);
                        break;
                }
            }
        }

        private void OnLineStepComplete()
        {
            m_CanvasGroup.alpha = m_Treasure.stage < m_TreasureStage.stage ? 0.6f : 1;
        }

        public void PlayLineSfx(int _state, bool _check = false)
        {
            var _index = m_Treasure.treasureStages.FindIndex((x) =>
            {
                return x.stage == m_TreasureStage.stage + 1;
            });
            if (_index == -1)
            {
                m_LineSfx.StopImediatly();
                return;
            }
            lineState = _check ? _state : 0;
            timer = 0;
            switch (_state)
            {
                case 2:
                    m_LineSfx.effect = TreasureAnimation.LINESFX;
                    m_LineSfx.Play();
                    lineAnimator.Play(TreasureAnimation.LINE_STATE_2, 0, 0);
                    duration = GetClipInfo(TreasureAnimation.LINE_STATE_2).length;
                    break;
                case 3:
                    if (lineAnimator == null)
                    {
                        m_LineSfx.effect = TreasureAnimation.LINESFX;
                        m_LineSfx.Play();
                    }
                    lineAnimator.Play(TreasureAnimation.LINE_STATE_3, 0, 0);
                    duration = GetClipInfo(TreasureAnimation.LINE_STATE_3).length;
                    break;
                case 4:
                    if (lineAnimator == null)
                    {
                        m_LineSfx.effect = TreasureAnimation.LINESFX;
                        m_LineSfx.Play();
                    }
                    lineAnimator.Play(TreasureAnimation.LINE_STATE_4, 0, 0);
                    duration = GetClipInfo(TreasureAnimation.LINE_STATE_4).length;
                    break;
            }
            var _config = ScriptableObjectLoader.LoadSoTreasureMeridian(m_Treasure.id);
            var _angle = VectorUtility.VectorAngle(_config[stageIndex + 1].position, _config[stageIndex].position);
            m_LineSfx.transform.localEulerAngles = Vector3.zero.SetZ(_angle);
            lineAnimator.transform.localScale = Vector3.one.SetY(Vector2.Distance(_config[stageIndex + 1].position
                , _config[stageIndex].position) / TreasureAnimation.LINE_NORMAL_LENGTH * TreasureAnimation.LINE_NORMAL_SCALE);
        }

        private void LateUpdate()
        {
            if (lineState != 0)
            {
                timer += Time.deltaTime;
                if (timer >= duration)
                {
                    switch (lineState)
                    {
                        case 2:
                            CheckNextStage();
                            break;
                        case 3:
                            PlayLineSfx(4);
                            lineState = 0;
                            break;
                    }
                    timer = 0;
                }
            }
        }

        private void CheckNextStage()
        {
            if (m_Treasure.stage <= m_TreasureStage.stage)
            {
                PlayLineSfx(3, true);
            }
            else
            {
                lineState = 0;
            }
        }

        private AnimationClip GetClipInfo(string _name)
        {
            var _clips = lineAnimator.runtimeAnimatorController.animationClips;
            for (int i = 0; i < _clips.Length; i++)
            {
                if (_clips[i].name == _name)
                {
                    return _clips[i];
                }
            }
            return null;
        }

        public void StopSfx()
        {
            m_LineSfx.StopImediatly();
            m_SelectSfx.StopImediatly();
        }

        public void RequestSfx()
        {
            if (m_Treasure == null || m_TreasureStage == null)
            {
                return;
            }
            var _stage = model.GetTreasureStageShow(m_Treasure.id);
            PlayLineSfx(m_Treasure.stage < m_TreasureStage.stage || _stage == m_TreasureStage.stage ? 4 : 2);
            RequestStateSfx();
        }

        public void RequestStateSfx()
        {
            m_CanvasGroup.alpha = m_Treasure.stage < m_TreasureStage.stage ? 0.6f : 1;
            var config = ScriptableObjectLoader.LoadSoTreasureMeridian(m_Treasure.id);
            if(m_Treasure.stage < m_TreasureStage.stage)
            {
                m_Bottom.transform.localScale = config[stageIndex].scale * Vector3.one;
            }
            m_SelectSfx.StopImediatly();
            if (m_Treasure.stage + 1 == m_TreasureStage.stage
                && model.GetTreasureStageShow(m_Treasure.id) == -1)
            {
                m_SelectSfx.transform.localScale = Vector3.one;
                m_SelectSfx.effect = TreasureStage.selectedSfxId;
                m_SelectSfx.Play();
            }
            else
            {
                m_SelectSfx.transform.localScale = Vector3.one;
            }
        }

        public void StartSoulTween()
        {
            var tweener = m_Descs[0].transform.DOScale(Vector3.one * 3, 0.4f);
            tweener.OnStepComplete(() =>
            {
                m_Descs[0].transform.DOScale(Vector3.one, 0.4f);
            });
        }
    }
}