using System;
using System.Collections;
using System.Collections.Generic;
#if UNITY_EDITOR
using UnityEditor;
#endif
using UnityEngine;
using DG.Tweening;
using XLua;

namespace XGame
{
    [LuaCallCSharp]
    public static partial class Utility
    {
        private static readonly List<Transform> mTempList = new List<Transform>();

        public static void DestroyUnityObject(UnityEngine.Object unityObject)
        {
            if (unityObject != null)
            {
                UnityEngine.Object.Destroy(unityObject);
            }
        }

        public static void DestroyUnityObjectImmediate(UnityEngine.Object unityObject)
        {
            if (unityObject != null)
            {
                UnityEngine.Object.DestroyImmediate(unityObject);
            }
        }

        public static GameObject CreateGameObject(GameObject parent, string name)
        {
            GameObject go = new GameObject(name);
            if (parent != null)
            {
                go.transform.parent = parent.transform;
            }
            NormalizeTransform(go.transform);
            return go;
        }

        public static GameObject NewGameObeject(string name)
        {
            return new GameObject(name);
        }

        //gameobject ops
        //create a child gameobject under the parent ,then normilize its transform
        public static GameObject CreateChildGameObject(GameObject parent, string name)
        {
            GameObject go = new GameObject(name);
            if (parent != null)
            {
                go.transform.parent = parent.transform;
            }
            NormalizeTransform(go.transform);
            return go;
        }

        public static bool DestroyChildren(Transform transform)
        {
            if (transform == null || transform.childCount == 0)
            {
                return false;
            }

            List<Transform> childTransformList = new List<Transform>();
            foreach (Transform child in transform)
            {
                childTransformList.Add(child);
            }

            for (int i = 0; i < childTransformList.Count; i++)
            {
                childTransformList[i].parent = null;
                DestroyUnityObject(childTransformList[i].gameObject);
            }
            childTransformList.Clear();
            return true;
        }

        //normalize an transform
        public static void NormalizeTransform(Transform transform)
        {
            transform.localPosition = Vector3.zero;
            transform.localRotation = Quaternion.identity;
            transform.localScale = Vector3.one;
        }

        public static T FindObjectInScene<T>() where T : UnityEngine.Object
        {
            T component = UnityEngine.Object.FindObjectOfType<T>() as T;

            return component;
        }

        public static bool IsActive(this GameObject gameObject)
        {
            if (gameObject == null)
            {
                return false;
            }

            if (gameObject.activeSelf)
            {
                return gameObject.transform.localScale == Vector3.one;
            }

            return false;
        }

        public static void SetActiveByScale(this Component component, bool active)
        {
            if (null == component) { return; }
            component.transform.localScale = active ? Vector3.one : Vector3.zero;
        }

        public static void SetActiveByScale(this GameObject component, bool active)
        {
            if (null == component) { return; }
            component.transform.localScale = active ? Vector3.one : Vector3.zero;
        }

        public static void SetActiveEx(this Transform t, bool active)
        {
            if (null == t) { return; }
            t.gameObject.SetActiveEx(active);
        }
        public static void SetActiveEx(this Component component, bool active)
        {
            if (null == component) { return; }
            if (component.gameObject.activeSelf != active)
            {
                component.gameObject.SetActive(active);
            }
        }

        public static bool SetActiveEx(this GameObject gameObject, bool active)
        {
            if (gameObject == null)
            {
                return false;
            }

            if (gameObject.activeSelf != active)
            {
                gameObject.SetActive(active);
            }

            return true;
        }

        /// <summary>
        /// 通过缩放大小 隐藏
        /// </summary>
        /// <param name="gameObject"></param>
        /// <param name="active"></param>
        /// <returns></returns>
        public static bool SetActiveExTwo(this GameObject gameObject, bool active)
        {
            if (gameObject == null)
            {
                return false;
            }

            //强制active
            if (gameObject.activeSelf == false)
            {
                gameObject.SetActive(true);
            }

            if (active)
            {
                gameObject.transform.localScale = Vector3.one;
            }
            else
            {
                gameObject.transform.localScale = Vector3.zero;
            }

            return true;
        }

        public static bool SetActiveExTwo(this Component comp, bool active)
        {
            if (comp == null)
            {
                return false;
            }
            SetActiveExTwo(comp.gameObject, active);
            return true;
        }


        public static bool SetActive3(this Transform t, bool active)
        {
            return SetActive3(t.gameObject, active);
        }
        /// <summary>
        /// 通过把位置挪出屏幕外 隐藏
        /// </summary>
        /// <param name="gameObject"></param>
        /// <param name="active"></param>
        /// <returns></returns>
        public static bool SetActive3(this GameObject gameObject, bool active)
        {
            if (gameObject == null)
            {
                return false;
            }
            //gameObject.SetActiveEx(active);
            //CanvasGroup g = gameObject.GetComponent<CanvasGroup>();
            //if (g == null)
            //{
            //    g = gameObject.AddComponent<CanvasGroup>();
            //}
            //g.alpha = active ? 1 : 0;
            //g.interactable = active;
            //g.blocksRaycasts = active;

            //Canvas[] canvases = gameObject.GetComponentsInChildren<Canvas>();
            //int toLayer = LayerMask.NameToLayer(active ? "UI" : "InVisible");
            //for (int i = 0; i < canvases.Length; i++)
            //{
            //    canvases[i].gameObject.layer = toLayer;
            //}
            //MeshRenderer[] mrs = gameObject.GetComponentsInChildren<MeshRenderer>();
            //for (int i = 0; i < mrs.Length; i++)
            //{
            //    mrs[i].enabled = active;
            //}
            //UiEffect[] effects = gameObject.GetComponentsInChildren<UiEffect>();
            //for (int i = 0; i < effects.Length; i++)
            //{
            //    effects[i].gameObject.layer = toLayer;
            //}
            //gameObject.SetActiveEx(active);
            Vector3 pos = gameObject.transform.localPosition;
            gameObject.transform.localPosition = new Vector3(pos.x, pos.y, active ? 0 : 99999);
            return true;
        }
        

        /// <summary>
        /// 是否隐藏了
        /// </summary>
        /// <param name="gameObject"></param>
        /// <returns></returns>
        public static bool IsHide(this GameObject gameObject)
        {
            return !gameObject.activeSelf || gameObject.transform.localScale == Vector3.zero || gameObject.transform.localPosition.z >= 99999;
        }
        public static bool IsHide(this Transform t)
        {
            return !t.gameObject.activeSelf || t.localScale == Vector3.zero || t.localPosition.z >= 99999;
        }

        public static GameObject[] GetChildren(this GameObject gameObject)
        {
            List<GameObject> children = new List<GameObject>();
            foreach (Transform child in gameObject.transform)
            {
                children.Add(child.gameObject);
            }

            return children.ToArray();
        }

        public static GameObject FindGameObject(this GameObject go, string name)
        {
            return !go ? null : go.transform.FindGameObject(name);
        }

        public static GameObject FindGameObject(this Transform tf, string name)
        {
            Transform targetTransform = tf.FindTransform(name);
            return targetTransform ? targetTransform.gameObject : null;
        }

        public static Transform FindTransform(this GameObject go, string name)
        {
            return !go ? null : go.transform.FindTransform(name);
        }

        public static Transform FindTransform(this Transform tf, string name)
        {
            if (!tf)
            {
                return null;
            }

            if (string.IsNullOrEmpty(name))
            {
                return null;
            }

            mTempList.Clear();
            mTempList.Add(tf);
            int index = 0;
            while (mTempList.Count > index)
            {
                Transform transform = mTempList[index++];
                for (int i = 0; i < transform.childCount; ++i)
                {
                    Transform childTransform = transform.GetChild(i);
                    if (childTransform.name == name)
                    {
                        return childTransform;
                    }

                    mTempList.Add(childTransform);
                }
            }

            return null;
        }

        public static T FindComponent<T>(this GameObject go, string name) where T : Component
        {
            if (go == null)
            {
                return null;
            }

            return go.transform.FindComponent<T>(name);
        }

        public static T FindComponent<T>(this Transform tf, string name) where T : Component
        {
            if (tf == null)
            {
                return null;
            }

            Transform target = tf.FindTransform(name);
            if (target == null)
            {
                return null;
            }

            return target.GetComponent<T>();
        }

        public static Component GetOrAddComponent(this GameObject GO, string typeName)
        {
            if (string.IsNullOrEmpty(typeName))
            {
                Debug.LogError("GetOrAddComponent typeName is null");
                return null;
            }

            Type componentType = Utility.GetTypeByTypeName(typeName);
            if (componentType == null)
            {
                Debug.LogError($"GetOrAddComponent componentType is null, typeName:{typeName}");
                return null;
            }

            Component result = null;
            if (!GO) return result;

            result = GO.GetComponent(componentType);

            if (!result)
            {
                result = GO.AddComponent(componentType);
            }

            return result;
        }

        public static T GetOrAddComponent<T>(this GameObject GO) where T : UnityEngine.Component
        {
            T result = null;
            if (!GO) return result;

            result = GO.GetComponent<T>();

            if (!result)
            {
                result = GO.AddComponent<T>();
            }

            return result;
        }

        
        public static GameObject[] GetAllChildrenGameObjects(this GameObject go)
        {
            Transform[] allTrans = go.GetComponentsInChildren<Transform>();
            List<GameObject> allGOs = new List<GameObject>();
            for (int i = 0; i < allTrans.Length; ++i)
            {
                allGOs.Add(allTrans[i].gameObject);
            }

            return allGOs.ToArray();
        }

        public static Transform FindSocketTransform(GameObject go, string socketName)
        {
            if (string.IsNullOrEmpty(socketName))
            {
                return null;
            }

            Transform socketTrans = null;
            Transform[] childrenTrans = go.transform.GetComponentsInChildren<Transform>(true);
            int count = childrenTrans != null ? childrenTrans.Length : 0;
            for (int i = 0; i < count; i++)
            {
                if (childrenTrans[i] != null && childrenTrans[i].name == socketName)
                {
                    socketTrans = childrenTrans[i];
                    break;
                }
            }

            return socketTrans;
        }

        public static void SetPosition(this GameObject go, float x, float y, float z)
        {
            if (go == null)
            {
                Debug.LogError("Utility SetPosition go is null");
                return;
            }

            go.transform.position = new Vector3(x, y, z);
        }

        public static void SetPosition(this Transform trans, float x, float y, float z)
        {
            if (trans == null)
            {
                Debug.LogError("Utility SetPosition trans is null");
                return;
            }

            trans.position = new Vector3(x, y, z);
        }

        public static void SetLocalPosition(this GameObject go, float x, float y, float z)
        {
            if (go == null)
            {
                Debug.LogError("Utility SetLocalPosition go is null");
                return;
            }

            go.transform.localPosition = new Vector3(x, y, z);
        }

        public static void SetLocalPosition(this Transform trans, float x, float y, float z)
        {
            if (trans == null)
            {
                Debug.LogError("Utility SetLocalPosition trans is null");
                return;
            }

            trans.localPosition = new Vector3(x, y, z);
        }

        public static void SetRotation(this GameObject go, float x, float y, float z, float w)
        {
            if (go == null)
            {
                Debug.LogError("Utility SetRotation go is null");
                return;
            }

            go.transform.rotation = new Quaternion(x, y, z, w);
        }

        public static void SetRotation(this Transform trans, float x, float y, float z, float w)
        {
            if (trans == null)
            {
                Debug.LogError("Utility SetRotation trans is null");
                return;
            }

            trans.rotation = new Quaternion(x, y, z, w);
        }

        public static void SetLocalRotation(this GameObject go, float x, float y, float z, float w)
        {
            if (go == null)
            {
                Debug.LogError("Utility SetLocalRotation go is null");
                return;
            }

            go.transform.localRotation = new Quaternion(x, y, z, w);
        }

        public static void SetLocalRotation(this Transform trans, float x, float y, float z, float w)
        {
            if (trans == null)
            {
                Debug.LogError("Utility SetLocalRotation trans is null");
                return;
            }

            trans.localRotation = new Quaternion(x, y, z, w);
        }

        public static void SetLocalEulerAngles(this GameObject go, float x, float y, float z)
        {
            if (go == null)
            {
                Debug.LogError("Utility SetLocalEulerAngles go is null");
                return;
            }

            go.transform.localEulerAngles = new Vector3(x, y, z);
        }

        public static void SetLocalEulerAngles(this Transform trans, float x, float y, float z)
        {
            if (trans == null)
            {
                Debug.LogError("Utility SetLocalEulerAngles trans is null");
                return;
            }

            trans.localEulerAngles = new Vector3(x, y, z);
        }

        public static void SetLocalScale(this GameObject go, float x, float y, float z)
        {
            if (go == null)
            {
                Debug.LogError("Utility SetLocalScale go is null");
                return;
            }

            go.transform.localScale = new Vector3(x, y, z);
        }

        public static void SetLocalScale(this Transform trans, float x, float y, float z)
        {
            if (trans == null)
            {
                Debug.LogError("Utility SetLocalScale trans is null");
                return;
            }

            trans.localScale = new Vector3(x, y, z);
        }

        public static void SetLocalScale(this Transform trans, float scale)
        {
            if (trans == null)
            {
                Debug.LogError("Utility SetLocalScale trans is null");
                return;
            }

            trans.localScale = new Vector3(scale, scale, scale);
        }

        public static DG.Tweening.Core.TweenerCore<Vector3, Vector3, DG.Tweening.Plugins.Options.VectorOptions> DOLocalMove(this Transform trans,float x,float y,float z,float duration,bool snapping = false)
        {
            return trans.DOLocalMove(new Vector3(x, y, z), duration, snapping);
        }
        #region 属性获得 减少引用传递

        public static float GetPosition(this Transform t, out float y, out float z)
        {
            Vector3 position = t.position;
            y = position.y;
            z = position.z;
            return t.position.x;
        }
        public static float GetPosition(this GameObject t, out float y, out float z)
        {
            return t.transform.GetPosition(out y,out z);
        }

        public static float GetLocalPosition(this Transform t, out float y, out float z)
        {
            Vector3 position = t.localPosition;
            y = position.y;
            z = position.z;
            return position.x;
        }
        public static float GetLocalPosition(this GameObject t, out float y, out float z)
        {
            return t.transform.GetLocalPosition(out y, out z);
        }

        public static void GetLocalScale(this Transform t, out float x, out float y, out float z)
        {
            x = t.localScale.x;
            y = t.localScale.y;
            z = t.localScale.z;
        }
        public static void GetLocalScale(this GameObject t, out float x, out float y, out float z)
        {
            t.transform.GetLocalScale(out x,out y, out z);
        }


        public static void GetRotation(this Transform t, out float x, out float y, out float z, out float w)
        {
            x = t.rotation.x;
            y = t.rotation.y;
            z = t.rotation.z;
            w = t.rotation.w;
        }
        public static void GetRotation(this GameObject o, out float x, out float y, out float z, out float w)
        {
            o.transform.GetRotation(out x, out y, out z, out w);
        }

        public static void GetLocalRotation(this Transform t, out float x, out float y, out float z, out float w)
        {
            x = t.localRotation.x;
            y = t.localRotation.y;
            z = t.localRotation.z;
            w = t.localRotation.w;
        }
        public static void GetLocalRotation(this GameObject o, out float x, out float y, out float z, out float w)
        {
            o.transform.GetLocalRotation(out x, out y, out z, out w);
        }

        public static void GetEulerAngle(this Transform t, out float x, out float y, out float z)
        {
            x = t.eulerAngles.x;
            y = t.eulerAngles.y;
            z = t.eulerAngles.z;
        }
        public static void GetEulerAngle(this GameObject o, out float x, out float y, out float z)
        {
            o.transform.GetEulerAngle(out x, out y, out z);
        }

        public static void GetLocalEulerAngle(this Transform t, out float x, out float y, out float z)
        {
            x = t.localEulerAngles.x;
            y = t.localEulerAngles.y;
            z = t.localEulerAngles.z;
        }
        public static void GetLocalEulerAngle(this GameObject o, out float x, out float y, out float z)
        {
            o.transform.GetLocalEulerAngle(out x, out y, out z);
        }

        public static void GetAnchoredPosition(this RectTransform t, out float x, out float y)
        {
            x = t.anchoredPosition.x;
            y = t.anchoredPosition.y;
        }

        public static bool IsActive(this Transform t)
        {
            return t.gameObject.IsActive();
        }
        #endregion


        public static bool Exist(this UnityEngine.Object obj)
        {
            return obj;
        }

        public static bool IsUnityObject(object unityObject)
        {
            if (unityObject != null)
            {
                if (unityObject is UnityEngine.Object)
                {
                    return true;
                }
            }

            return false;
        }

        public static Component GetComponent(this Component component, string asm, string typeName)
        {
            var gen_ret = component.GetComponent(typeName);
            if (gen_ret != null)
                return gen_ret;
            System.Type componentType = Utility.GetTypeByTypeName(typeName);
            if (componentType == null)
            {
#if ENV_INTRANET
                Debug.LogWarning($"GetType('{typeName}')  Failed!!  componentName:{component.name}");
#endif
                return null;
            }
            gen_ret = component.GetComponent(componentType);
            if (gen_ret == null)
            {
#if ENV_INTRANET
                Debug.LogWarning($"{component.name}.GetComponent({typeName})  Failed!!");
#endif
            }
            return gen_ret;
        }

        public static Component GetComponent(this GameObject gameObject, string asm, string typeName)
        {
            var gen_ret = gameObject.GetComponent(typeName);
            if (gen_ret != null)
                return gen_ret;

            System.Type componentType = Utility.GetTypeByTypeName(typeName);
            if (componentType == null)
            {
#if ENV_INTRANET
                Debug.LogWarning($"GetType('{typeName}')  Failed!!  objectName:{gameObject.name}");
#endif
                return null;
            }
            gen_ret = gameObject.GetComponent(componentType);
            if (gen_ret == null)
            {
#if ENV_INTRANET
                Debug.LogWarning($"Go.GetComponent({typeName})  Failed!!");
#endif
            }
            return gen_ret;
        }

        //防止代码剪裁
        //private static void PreventCodeClipping(GameObject obj)
        //{
        //    Empty4Raycast a = obj.GetComponent<Empty4Raycast>();
        //}
    }
}