using System.Collections.Generic;
using UnityEngine;

namespace YKMoon
{
    public static partial class YKTransformUtility
    {
        public static Transform FindChildWithName(this Transform parent, string name)
        {
            var que = QueuePool<Transform>.Get();
            que.Enqueue(parent);
            while(que.Count > 0) {
                var top = que.Dequeue();
                for(int i = 0; i < top.childCount; i++) {
                    var child = top.GetChild(i);
                    if(string.Equals(child.name, name)) {
                        QueuePool<Transform>.Release(que);
                        return child;
                    }
                    que.Enqueue(child);
                }
            }
            QueuePool<Transform>.Release(que);
            return null;
        }

        public static List<Transform> FindChildrenWithName(this Transform parent, string name)
        {
            List<Transform> children = ListPool<Transform>.Get();
            var que = QueuePool<Transform>.Get();
            que.Enqueue(parent);
            while(que.Count > 0) {
                var top = que.Dequeue();
                for(int i = 0; i < top.childCount; i++) {
                    var child = top.GetChild(i);
                    if(string.Equals(child.name, name)) {
                        children.Add(child);
                    }
                    que.Enqueue(child);
                }
            }
            QueuePool<Transform>.Release(que);
            return children;
        }

        public static void SetLayerRecursively(this GameObject obj, int layer)
        {
            var que = QueuePool<Transform>.Get();
            que.Enqueue(obj.transform);
            while(que.Count > 0) {
                var top = que.Dequeue();
                top.gameObject.layer = layer;
                for(int i = 0; i < top.childCount; i++) {
                    var child = top.GetChild(i);
                    que.Enqueue(child);
                }
            }
            QueuePool<Transform>.Release(que);
        }

        public static T FindComponentWithName<T>(this Transform parent, string name) where T : Component
        {
            Transform child = FindChildWithName(parent, name);
            if(child == null) {
                return null;
            } else {
                return child.GetComponent<T>();
            }
        }

        public static void AddChild(GameObject parent, GameObject child)
        {
            AddChild(parent.transform, child.transform);
        }

        public static void AddChild(GameObject parent, GameObject child, Vector3 localPos, Vector3 localScale)
        {
            AddChild(parent.transform, child.transform, localPos, localScale);
        }

        public static void AddChild(this Transform parent, Transform child)
        {
            AddChild(parent, child, Vector3.zero, Vector3.one);
        }

        public static void AddChild(this Transform parent, Transform child, Vector3 localPos, Vector3 localScale)
        {
            child.SetParent(parent);
            child.localPosition = localPos;
            child.localScale = localScale;
        }
        public static void ClearChild(this Transform parent)
        {
            var childs = QueuePool<Transform>.Get();
            for(int i = 0; i < parent.childCount; i++) {
                childs.Enqueue(parent.GetChild(i));
            }
            while(childs.Count > 0) {
                GameObject.DestroyImmediate(childs.Dequeue());
            }
            QueuePool<Transform>.Release(childs);
        }
        public static T GetOrAddComponent<T>(this GameObject go) where T : Component
        {
            T result = go.GetComponent<T>();
            if(result == null) {
                result = go.AddComponent<T>();
            }
            return result;
        }
        public static string GetChildPath(GameObject root, GameObject child)
        {
            string path = "";
            var top = child.transform;
            var end = root.transform;
            while(top != end) {
                if(string.IsNullOrEmpty(path)) {
                    path = top.name;
                } else {
                    path = top.name + "/" + path;
                }
                top = top.parent;
                if(top == null) {
                    //没找到//
                    return "";
                }
            }
            return path;
        }


        private static List<Component> m_ComponentCache = new List<Component>();
        /// <summary>
        /// Grabs a component without allocating memory uselessly
        /// </summary>
        /// <param name="this"></param>
        /// <param name="componentType"></param>
        /// <returns></returns>
        public static Component GetComponentNoAlloc(this GameObject @this, System.Type componentType)
        {
            @this.GetComponents(componentType, m_ComponentCache);
            Component component = m_ComponentCache.Count > 0 ? m_ComponentCache[0] : null;
            m_ComponentCache.Clear();
            return component;
        }
        /// <summary>
        /// Grabs a component without allocating memory uselessly
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="this"></param>
        /// <returns></returns>
        public static T GetComponentNoAlloc<T>(this GameObject @this) where T : Component
        {
            @this.GetComponents(typeof(T), m_ComponentCache);
            Component component = m_ComponentCache.Count > 0 ? m_ComponentCache[0] : null;
            m_ComponentCache.Clear();
            return component as T;
        }
    }
}