using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
using UnityEngine.Gonbest.MagicCube;

namespace Thousandto.Core.Base
{
    /// <summary>
    /// Unity的工具函数集合
    /// </summary>
    [ExecuteInEditMode]
    public class UnityUtils
    {
        public static TransformData GetTransformData(Transform trans)
        {
            return new TransformData(trans.position, trans.rotation, trans.localScale);
        }

        public static GameObject ResetTransform(GameObject go)
        {
            Reset(go.transform);
            return go;
        }

        public static void CopyTransform(Transform from, Transform to)
        {
            to.parent = from.parent;
            to.localPosition = from.localPosition;
            to.localRotation = from.localRotation;
            to.localScale = from.localScale;
        }

        public static void CopyTransformSRT(Transform from, Transform to)
        {
            to.position = from.position;
            to.rotation = from.rotation;
            to.localScale = from.localScale;
        }

        public static Transform Reset(Transform trans)
        {
            trans.localScale = Vector3.one;
            trans.localRotation = Quaternion.identity;
            trans.localPosition = Vector3.zero;
            return trans;
        }

        public static Transform RequireChildTransform(Transform parent, string childName)
        {
            var ret = parent.Find(childName);
            if (ret == null)
            {
                var go = new GameObject(childName);
                go.transform.parent = parent;
                ret = go.transform;
            }
            return ret;
        }

        public static T RequireComponent<T>(GameObject go) where T : Component
        {
            T ret = go.GetComponent<T>();
            if (ret == null)
            {
                ret = go.AddComponent<T>();
            }
            return ret;
        }

        public static T RequireComponent<T>(GameObject go, out bool isNew) where T : Component
        {
            T ret = go.GetComponent<T>();
            if (ret == null)
            {
                isNew = true;
                ret = go.AddComponent<T>();
            }
            else
            {
                isNew = false;
            }
            return ret;
        }

        public static Transform GetChildByName(Transform parentTran, string childName)
        {
            for (int i = 0; i < parentTran.childCount; i++)
            {
                Transform childTran = parentTran.GetChild(i);
                if (childTran.name.Contains(childName))
                {
                    return childTran;
                }
            }
            return null;
        }

        public static Transform FindParent(Transform current, Transform targetParent)
        {
            while (current != null && current != targetParent)
            {
                current = current.parent;
            }
            return current;
        }

        public static GameObject AddChild(GameObject parent)
        {
            GameObject go = new GameObject();
            if (parent != null)
            {
                Transform t = go.transform;
                SetLayer(go.transform, parent.layer,true);
                t.parent = parent.transform;
                t.localPosition = Vector3.zero;
                t.localRotation = Quaternion.identity;
                t.localScale = Vector3.one;
            }
            return go;
        }

        public static bool CheckChild(Transform parent, Transform child)
        {
            return null != FindParent(child.parent, parent);
        }

        public static string GetTransPath(Transform trans)
        {
            var sb = StringUtils.NewStringBuilder;
            sb.Append(trans.name);
            var p = trans.parent;
            while (p != null)
            {
                sb.Insert(0, '/');
                sb.Insert(0, p.name);
                p = p.parent;
            }
            return sb.ToString();
        }

        public static string GetTransPathFrom(Transform trans, Transform from)
        {
            var sb = StringUtils.NewStringBuilder;
            sb.Append(trans.name);
            var p = trans.parent;
            while (p != null)
            {
                if (p == from)
                {
                    break;
                }
                sb.Insert(0, '/');
                sb.Insert(0, p.name);
                p = p.parent;
            }
            return sb.ToString();
        }

        public static int GetHierarchyDepthFrom(Transform trans, Transform from)
        {
            int count = 0;
            var p = trans.parent;
            while (p != null)
            {
                if (p == from)
                {
                    return count;
                }
                ++count;
                p = p.parent;
            }
            return -1;
        }

        public static Transform Find(string path)
        {
            Transform cur = null;
            var seg = path.Split('\\', '/');
            if (seg.Length > 0)
            {
                var go = GameObject.Find(seg[0]);
                if (go != null)
                {
                    cur = go.transform;
                    for (int i = 1; i < seg.Length && cur != null; ++i)
                    {
                        var t = cur;
                        cur = null;
                        for (int j = 0; j < t.childCount; ++j)
                        {
                            var c = t.GetChild(j);
                            if (c.name == seg[i])
                            {
                                cur = c;
                                break;
                            }
                        }
                    }
                }
            }
            return cur;
        }

        static List<Component> _GetComponentsInChildren(Transform trans, Type t, int depth, ref List<Component> ret)
        {
            var c = trans.GetComponents(t);
            for (int i = 0; i < c.Length; ++i)
            {
                ret.Add(c[i]);
            }
            if (c == null && depth > 0)
            {
                for (int i = 0; i < trans.childCount; ++i)
                {
                    _GetComponentsInChildren(trans.GetChild(i), t, depth - 1, ref ret);
                }
            }
            return ret;
        }

        static Component _GetComponentInChildren(Transform trans, Type t, int depth)
        {
            var c = trans.GetComponent(t);
            if (c == null && depth > 0)
            {
                for (int i = 0; i < trans.childCount; ++i)
                {
                    var child = trans.GetChild(i);
                    c = child.GetComponent(t) ?? _GetComponentInChildren(child, t, depth - 1);
                    if (c != null)
                    {
                        break;
                    }
                }
            }
            return c;
        }

        public static T[] GetComponentsInChildren<T>(Transform trans, int depth = int.MaxValue) where T : Component
        {
            if (depth < 0)
            {
                depth = int.MaxValue;
            }
            List<Component> _ret = new List<Component>();
            _GetComponentsInChildren(trans, typeof(T), depth, ref _ret);
            var ret = new T[_ret.Count];
            for (int i = 0; i < _ret.Count; ++i)
            {
                ret[i] = _ret[i] as T;
            }
            return ret;
        }

        public static T GetComponentInChildren<T>(Transform trans, int depth = int.MaxValue) where T : Component
        {
            if (depth < 0)
            {
                depth = int.MaxValue;
            }
            var ret = _GetComponentInChildren(trans, typeof(T), depth);
            return ret as T;
        }

        static T _GetComponentInChildren_IgnoreActiveStatus<T>(Transform trans) where T : Component
        {
            var r = trans.GetComponent<T>();
            if (r == null)
            {
                for (int i = 0; i < trans.childCount && r == null; ++i)
                {
                    r = _GetComponentInChildren_IgnoreActiveStatus<T>(trans.GetChild(i));
                }
            }
            return r;
        }

        public static T GetComponentInChildren_IgnoreActiveStatus<T>(Transform trans) where T : Component
        {
            if (trans == null)
            {
                return null;
            }
            var r = trans.GetComponent<T>();
            if (r == null)
            {
                for (int i = 0; i < trans.childCount && r == null; ++i)
                {
                    r = _GetComponentInChildren_IgnoreActiveStatus<T>(trans.GetChild(i));
                }
            }
            return r;
        }

        /// return parent which its name contains string specified
        public static Transform GetParentTransform(Transform trans, string parentName)
        {
            if (trans != null)
            {
                while (!trans.name.Contains(parentName))
                {
                    trans = trans.parent;
                }
                return trans;
            }
            return null;
        }

        public static int GetLayerMask(params String[] layers)
        {
            int mask = 0;
            for (int i = 0; i < layers.Length; ++i)
            {
                mask |= (1 << LayerMask.NameToLayer(layers[i]));
            }
            return mask;
        }

        public static void SetLayer(Transform trans, int layer, bool recursive = false)
        {
            if (trans == null)
            {
                return;
            }
            trans.gameObject.layer = layer;
            if (recursive)
            {
                var list = trans.GetComponentsInChildren<Transform>(true);
                for (int i = 0; i < list.Length; i++)
                {
                    list[i].gameObject.layer = layer;
                }               
            }
        }

        public static void FindAllChildContainsString(Transform parent, string contains, List<Transform> result)
        {
            if (result == null || parent.childCount == 0)
            {
                return;
            }
            else
            {
                string containsLower = contains.ToLower();
                for (int i = 0; i < parent.childCount; i++)
                {
                    var child = parent.GetChild(i);
                    if (child.name.ToLower().Contains(containsLower) && child.gameObject.activeInHierarchy == true)
                    {
                        result.Add(child);
                    }
                    else
                    {
                        FindAllChildContainsString(child, containsLower, result);
                    }
                }
            }
        }

        public static Transform FindChildContainsString(Transform parent, string contains)
        {
            Transform result = null;
            string containsLower = contains.ToLower();
            if (parent.childCount == 0)
            {
                result = null;
            }
            else
            {
                for (int i = 0; i < parent.childCount; i++)
                {
                    var child = parent.GetChild(i);
                    if (child.name.ToLower().Contains(containsLower) && child.gameObject.activeInHierarchy == true)
                    {
                        result = child;
                    }
                    else
                    {
                        result = FindChildContainsString(child, containsLower);
                    }
                    if (result != null)
                    {
                        break;
                    }
                }
            }
            return result;
        }

        public static Transform FindChildContainsStringWithBoxCollider(Transform parent, string contains)
        {
            string containLower = contains.ToLower();
            Transform result = null;
            if (parent.childCount == 0)
            {
                result = null;
            }
            else
            {
                for (int i = 0; i < parent.childCount; i++)
                {
                    var child = parent.GetChild(i);
                    if (child.name.ToLower().Contains(containLower) && child.gameObject.activeInHierarchy == true && child.GetComponent<BoxCollider>() != null)
                    {
                        result = child;
                    }
                    else
                    {
                        result = FindChildContainsStringWithBoxCollider(child, containLower);
                    }
                    if (result != null)
                    {
                        break;
                    }
                }
            }
            return result;
        }

        public static T GetNearestComponentFromParents<T>(GameObject child) where T : Component
        {
            if (child != null)
            {
                Transform obj = child.transform;
                while (obj.parent != null)
                {
                    var component = obj.GetComponent<T>();
                    if (component != null)
                    {
                        return component;
                    }
                    obj = obj.transform.parent;
                }
            }
            return null;
        }

        public static List<T> GetAllComponentsFromParents<T>(GameObject child) where T : Component
        {
            if (child != null)
            {
                var result = new List<T>();
                Transform obj = child.transform;
                while (obj.parent != null)
                {
                    var com = obj.GetComponent<T>();
                    if (com != null)
                    {
                        result.Add(com);
                    }
                    obj = obj.transform.parent;
                }
                return result;
            }
            return null;
        }

        /// <summary>
        /// 移除某组件
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="go"></param>
        public static void RemoveComponet<T>(GameObject go)
             where T : Component
        {
            var cl = go.GetComponent<T>();
            if (cl != null)
            {
                // remove audio listener if only
#if UNITY_EDITOR
                GameObject.DestroyImmediate(cl);
#else
                GameObject.Destroy(cl);
#endif
            }
        }

        /// <summary>
        /// 点是否在一个指定的区域内
        /// </summary>
        /// <param name="point">点的坐标</param>
        /// <param name="field">范围坐标。顺序是左下，左上， 右上，右下</param>
        /// <returns></returns>
        public static bool IsPointInField2D(Vector3 point, Vector3[] field)
        {
            float minX = field[0].x;
            float maxX = field[3].x;
            float minY = field[0].y;
            float maxY = field[1].y;
            return (minX <= point.x) && (maxX >= point.x) && (minY <= point.y) && (maxY >= point.y);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static bool IsFieldAInFieldB2D(Vector3[] a, Vector3[] b)
        {
            for (int i = 0; i < a.Length; i++)
            {
                if (!IsPointInField2D(a[i], b))
                {
                    return false;
                }
            }
            return true;
        }

        public static List<int> DecimalNumDecompse(int num)
        {
            int b = 1;
            int index = 0;
            List<int> result = new List<int>();
            while (num != 0)
            {
                int temp = num & b;
                if (temp == 1)
                {
                    result.Add(index);
                }
                num = num >> 1;
                index++;
            }

            for (int i = 0; i < result.Count; i++)
            {
                result[i] = (int)Math.Pow(2, result[i]);
            }
            return result;
        }

        public static void SetGameObjectActive(Transform tran, bool isActive)
        {
            if (tran != null)
            {
                tran.gameObject.SetActive(isActive);
            }
        }

        //获取在最外层时的大小
        public static Vector3 GetWorldScale(Transform tran)
        {
            if (tran == null) return Vector3.one;

            Vector3 scale = tran.localScale;
            while (tran.parent != null)
            {
                tran = tran.parent;
                scale = Vector3.Scale(scale, tran.localScale);
            }
            return scale;
        }

        //查找当前场景中的根节点
        public static GameObject FindSceneRoot(string name)
        {
            var scene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
            if (!string.IsNullOrEmpty(scene.name))
            {
                var roots = scene.GetRootGameObjects();
                for (int i = 0; i < roots.Length; i++)
                {
                    if (string.Equals(roots[i].name.Trim(), name, StringComparison.CurrentCultureIgnoreCase))
                    {
                        return roots[i];
                    }
                }
            }            
            return null;
        }

        //复制摄像机的属性
        public static void CopyCameraProperty(Camera source, Camera target, int excludeLayer = 0)
        {
            if (source != null && target != null)
            {
                target.CopyFrom(source);
                target.cullingMask = source.cullingMask & (~(1 << excludeLayer));
                target.transform.position = source.transform.position;
                target.transform.rotation = source.transform.rotation;
                target.Render();
            }
        }

        //更新摄像机的工作模式
        public static void UpdateCameraModes(Camera src, Camera dest)
        {
            if (dest == null)
            {
                return;
            }
            // set water camera to clear the same way as current camera
            dest.clearFlags = src.clearFlags;
            dest.backgroundColor = src.backgroundColor;
            /*
            if (src.clearFlags == CameraClearFlags.Skybox)
            {
                Skybox sky = src.GetComponent<Skybox>();
                Skybox mysky = dest.GetComponent<Skybox>();
                if (!sky || !sky.material)
                {
                    mysky.enabled = false;
                }
                else
                {
                    mysky.enabled = true;
                    mysky.material = sky.material;
                }
            } */
            // update other values to match current camera.
            // even if we are supplying custom camera&projection matrices,
            // some of values are used elsewhere (e.g. skybox uses far plane)
            dest.farClipPlane = src.farClipPlane;
            dest.nearClipPlane = src.nearClipPlane;
            dest.orthographic = src.orthographic;
            dest.fieldOfView = src.fieldOfView;
            dest.aspect = src.aspect;
            dest.orthographicSize = src.orthographicSize;
        }

        /// <summary>
        /// 获取某个MonoBehaviour
        /// </summary>
        /// <param name="go"></param>
        /// <param name="name"></param>
        /// <param name="ignoreCase"></param>
        /// <returns></returns>
        public static MonoBehaviour GetMonoBehaviour(GameObject go,string name,bool ignoreCase = false)
        {
            var allComps = go.GetComponents<MonoBehaviour>();
            for (int i = 0; i < allComps.Length; i++)
            {
                if (allComps[i] != null)
                {
                    var t = allComps[i].GetType();
                    if (string.Compare(t.Name,name,ignoreCase)==0)
                    {
                        return allComps[i];
                    }
                }
            }
            return null;
        }
    }
}