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

namespace YKMoon
{
    [RequireComponent(typeof(RectTransform))]
    public class UIFXOrderInLayer : YKMono
    {
        [SerializeField]
        public int orderInLayerAdd = 0;

        private Dictionary<Renderer, int> rendererDefaultValueDict = new Dictionary<Renderer, int>();
        private Dictionary<SpriteMask, Vector2Int> maskDefaultValueDict = new Dictionary<SpriteMask, Vector2Int>();
        private int m_OrderInLayer = 0;
        private Canvas mCanvas;
        private int mCanvasLayerOrder = 0;

        private bool isDirty = false;

        private bool isInitialized = false;

        protected override void Awake()
        {
            base.Awake();
            if(!isInitialized) {
                InitRenderer();
            }
        }

        private void OnEnable()
        {
            isDirty = true;
            if(TryUpdateOrder()) {
                isDirty = false;
            }
        }

        private void OnDisable()
        {

        }

        private void OnTransformParentChanged()
        {
            isDirty = true;
            mCanvas = null;
        }

        private void Update()
        {
            if(isDirty) {
                if(TryUpdateOrder()) {
                    isDirty = false;
                }
            }
        }
        private void LateUpdate()
        {
            if(mCanvas != null && mCanvas.sortingOrder != mCanvasLayerOrder) {
                isDirty = true;
            }
        }

        private bool TryUpdateOrder()
        {
            mCanvas = rectTrans.GetComponentInParent<Canvas>();
            if(mCanvas != null) {
                mCanvasLayerOrder = mCanvas.sortingOrder;
                SetOrderInLayerAdded(mCanvas.sortingOrder);
                return true;
            }
            return false;
        }

        public void InitRenderer()
        {
            FindAllRenderer(this.gameObject);
            isInitialized = true;
        }

        private void FindAllRenderer(GameObject go)
        {
            {
                var list = ListPool<Renderer>.Get();
                go.GetComponentsInChildren<Renderer>(true, list);
                for(int i = 0; i < list.Count; i++) {
                    var renderer = list[i];
                    if(!rendererDefaultValueDict.ContainsKey(renderer)) {
                        rendererDefaultValueDict.Add(renderer, renderer.sortingOrder);
                    }
                    if(renderer is SpriteMask) {
                        var spriteMask = renderer as SpriteMask;
                        if(!maskDefaultValueDict.ContainsKey(spriteMask)) {
                            maskDefaultValueDict.Add(spriteMask, new Vector2Int(spriteMask.frontSortingOrder, spriteMask.backSortingLayerID));
                        }
                    }
                }
                list.Clear();
                ListPool<Renderer>.Release(list);
            }
        }
        public void SetOrderInLayerAdded(int added)
        {
            m_OrderInLayer = orderInLayerAdd + added;
            var itor = rendererDefaultValueDict.GetEnumerator();
            while(itor.MoveNext()) {
                var data = itor.Current.Key;
                var defaultOrder = itor.Current.Value;
                if(data != null) {
                    data.sortingOrder = defaultOrder + m_OrderInLayer;
                }
            }
            foreach(var maskPair in maskDefaultValueDict) {
                var mask = maskPair.Key;
                int frontOrder = maskPair.Value.x;
                int backOrder = maskPair.Value.y;
                int defaultOrder = rendererDefaultValueDict[mask];
                mask.frontSortingOrder = m_OrderInLayer + defaultOrder + frontOrder;
                mask.backSortingOrder = m_OrderInLayer + defaultOrder + backOrder;
            }
        }
    }
}