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

namespace Snxxz.UI
{
    public class RealmProgressBehaviour : MonoBehaviour
    {
        [SerializeField] RealmStageBehaviour[] m_RealmStages;
        [SerializeField] SmoothSlider m_ItemSlider;
        [SerializeField] Text m_RealmPoint;
        [SerializeField] Text m_OpenRemind;
        [SerializeField] RectTransform m_ContainerPoint;
        [SerializeField] float[] m_StageLeftRatio;
        [SerializeField] float[] m_StageRightRatio;

        [SerializeField] RectTransform m_ContainerRemind;
        [SerializeField] PropertyBehaviour m_SpecialProperty;
        [SerializeField] Text m_HurtRemind;

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

        float leftRatio = 0;
        float rightRatio = 0;

        public void Display()
        {
            leftRatio = 0;
            rightRatio = 0;
            DisplayStages();
            DisplayProgress();
        }

        void DisplayStages()
        {
            var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
            int start = 0;int end = 0;
            model.TryGetRealmStage(realmLevel, out start, out end);
            var leftIndex = 0;
            var rightIndex = 0;
            var index = 0;

            m_ContainerRemind.gameObject.SetActive(false);

            for (int i = start; i <= realmLevel; i++)
            {
                m_RealmStages[index].transform.localPosition = GetStagePosition(true, leftIndex);
                m_RealmStages[index].gameObject.SetActive(true);
                m_RealmStages[index].Display(i, false, true, leftIndex);
                leftRatio = m_StageLeftRatio[leftIndex];
                leftIndex++;
                index++;
            }
            end = end == model.realmMaxLevel ? end : (end + 1);
            for (int i = end; i > realmLevel; i--)
            {
                m_RealmStages[index].transform.localPosition = GetStagePosition(false, rightIndex);
                m_RealmStages[index].gameObject.SetActive(true);
                m_RealmStages[index].Display(i, i == end, false, rightIndex);
                DisplayRemind(i);
                rightRatio = m_StageRightRatio[rightIndex];
                rightIndex++;
                index++;
            }
            for (int i = index; i < m_RealmStages.Length; i++)
            {
                m_RealmStages[i].gameObject.SetActive(false);
            }
        }

        public void DisplayProgress(bool anim = false)
        {
            var deltaRatio = rightRatio - leftRatio;
            var realmPoint = PlayerDatas.Instance.extersion.realmPoint;
            var config = Config.Instance.Get<RealmConfig>(PlayerDatas.Instance.baseData.realmLevel);
            var progress = leftRatio + deltaRatio * (Mathf.Min((float)realmPoint / config.NeedPoint, 1));
            m_ItemSlider.delay = anim ? 0.2f : 0f;
            m_ItemSlider.value = progress;

            m_RealmPoint.transform.localPosition = m_RealmPoint.transform.localPosition.SetX(m_ContainerPoint.rect.width * (leftRatio + deltaRatio * 0.5f));
            m_RealmPoint.text = StringUtility.Contact(UIHelper.GetTextColorByItemColor(realmPoint >= config.NeedPoint ? TextColType.Green : TextColType.Red,
                realmPoint.ToString()), "/", config.NeedPoint);

            m_OpenRemind.text = realmPoint < config.NeedPoint ? Language.Get("RealmCollecting", config.NeedPoint - realmPoint) : string.Empty;
            m_OpenRemind.transform.localPosition = m_OpenRemind.transform.localPosition.SetX(m_ContainerPoint.rect.width * (leftRatio + deltaRatio * 0.5f));
        }

        public void DisplayRemind(int _realmLv)
        {
            var config = Config.Instance.Get<RealmConfig>(_realmLv);
            if (config.specialProperty != 0)
            {
                m_ContainerRemind.gameObject.SetActive(true);
                var index = 0;
                for (int i = 0; i < config.AddAttrType.Length; i++)
                {
                    if (config.AddAttrType[i] == config.specialProperty)
                    {
                        index = i;
                        break;
                    }
                }
                m_SpecialProperty.DisplayColon(config.specialProperty, config.AddAttrNum[index]);
                m_HurtRemind.text = UIHelper.ReplaceNewLine(Language.Get("RealmSuppressHurt", UIHelper.GetRealmName(config.Lv), (float)model.realmSuppressHurt / 100));
            }
        }

        Vector3 GetStagePosition(bool left, int index)
        {
            if (left && index >= m_StageLeftRatio.Length)
            {
                return Vector3.zero;
            }
            if (!left && index >= m_StageRightRatio.Length)
            {
                return Vector3.zero;
            }
            var ratio = left ? m_StageLeftRatio[index] : m_StageRightRatio[index];
            Vector3 localpos = Vector3.zero.SetX(m_ContainerPoint.rect.width * ratio);
            return localpos;
        }

#if UNITY_EDITOR
        private void LateUpdate()
        {
            for (int i = 0; i < m_RealmStages.Length; i++)
            {
                if (m_RealmStages[i].gameObject.activeSelf)
                {
                    m_RealmStages[i].transform.localPosition = GetStagePosition(m_RealmStages[i].left, m_RealmStages[i].index);
                }
            }
        }
#endif 
    }
}