/*
******************************************************************************** 
  *Copyright(C),coolae.net 
  *Author:  chenbin
  *Version:  2.0 
  *Date:  2017-01-09
  *Description:  工具类
  *Others:  
  *History:
*********************************************************************************
*/

using UnityEngine;
using System.Collections;
using System.IO;
using System.Text;
using System.Collections.Generic;
using System.Security.Cryptography;
using XLua;

#if !UNITY_WEBPLAYER
using System.Net.NetworkInformation;
#endif

namespace Coolape
{
    public static class Utl
    {
        public static Vector3 kXAxis = new Vector3(1.0f, 0.0f, 0.0f);
        public static Vector3 kZAxis = new Vector3(0.0f, 0.0f, 1.0f);
        static string cacheUuid = "";

        public static string uuid
        {
            get
            {
                if (string.IsNullOrEmpty(cacheUuid))
                {
                    if (Application.platform == RuntimePlatform.Android)
                    {
                        cacheUuid = SystemInfo.deviceUniqueIdentifier;
                    }
                    else if (Application.platform == RuntimePlatform.IPhonePlayer)
                    {
#if UNITY_IOS || UNITY_IPHONE || UNITY_STANDALONE_OSX
						string jsonStr = KeyChain.BindGetKeyChainUser ();
						Debug.Log("jsonStr===========" + jsonStr);
						if (string.IsNullOrEmpty (jsonStr)) {
							cacheUuid = SystemInfo.deviceUniqueIdentifier;
							KeyChain.BindSetKeyChainUser ("0", cacheUuid);
						} else {
							Hashtable m = JSON.DecodeMap(jsonStr);
							cacheUuid = MapEx.getString(m, "uuid");
							if(string.IsNullOrEmpty(cacheUuid)) {
								cacheUuid = SystemInfo.deviceUniqueIdentifier;
								KeyChain.BindSetKeyChainUser ("0", cacheUuid);
							}
						}
#endif
                    }
                    else
                    {
                        cacheUuid = GetMacAddress();
                    }
                }
                return cacheUuid;
            }
        }

        public static string GetMacAddress()
        {
#if !UNITY_WEBPLAYER
            string macAdress = "";
            NetworkInterface[] nics = NetworkInterface.GetAllNetworkInterfaces();

            foreach (NetworkInterface adapter in nics)
            {
                PhysicalAddress address = adapter.GetPhysicalAddress();
                if (address.ToString() != "")
                {
                    macAdress = address.ToString();
                    return macAdress;
                }
            }
#endif
            return "00";
        }

        public static Hashtable vector2ToMap(Vector2 v2)
        {
            Hashtable r = new Hashtable();
            r["x"] = (double)(v2.x);
            r["y"] = (double)(v2.y);
            return r;
        }

        public static Hashtable vector3ToMap(Vector3 v3)
        {
            Hashtable r = new Hashtable();
            r["x"] = (double)(v3.x);
            r["y"] = (double)(v3.y);
            r["z"] = (double)(v3.z);
            return r;
        }

        public static Hashtable vector4ToMap(Vector4 v4)
        {
            Hashtable r = new Hashtable();
            r["x"] = (double)(v4.x);
            r["y"] = (double)(v4.y);
            r["z"] = (double)(v4.z);
            r["w"] = (double)(v4.w);
            return r;
        }

        public static Vector2 mapToVector2(Hashtable map)
        {
            if (map == null)
            {
                return Vector2.zero;
            }
            return new Vector2(
                (float)(MapEx.getDouble(map, "x")),
                (float)(MapEx.getDouble(map, "y")));
        }

        public static Vector3 mapToVector3(Hashtable map)
        {
            if (map == null)
            {
                return Vector3.zero;
            }
            return new Vector3(
                (float)(MapEx.getDouble(map, "x")),
                (float)(MapEx.getDouble(map, "y")),
                (float)(MapEx.getDouble(map, "z")));
        }

        public static Hashtable colorToMap(Color color)
        {
            Hashtable r = new Hashtable();
            r["r"] = (double)(color.r);
            r["g"] = (double)(color.g);
            r["b"] = (double)(color.b);
            r["a"] = (double)(color.a);
            return r;
        }

        public static Color mapToColor(Hashtable map)
        {
            Color c = new Color(
                          (float)(MapEx.getDouble(map, "r")),
                          (float)(MapEx.getDouble(map, "g")),
                          (float)(MapEx.getDouble(map, "b")),
                          (float)(MapEx.getDouble(map, "a"))
                      );
            return c;
        }

        /// <summary>
        /// Filters the path.过滤路径
        /// </summary>
        /// <returns>
        /// The path.
        /// </returns>
        /// <param name='path'>
        /// Path.
        /// </param>
        public static string filterPath(string path)
        {
            string r = path;
            if (path.IndexOf("Assets/") == 0)
            {
                r = StrEx.Mid(path, 7);
            }
            r = r.Replace("\\", "/");
            r = r.Replace("/upgradeRes4Dev", "/upgradeRes");
            r = r.Replace("/upgradeRes4Publish/", "/upgradeRes/");
            return r;
        }

        /// <summary>
        /// Gets the animation curve.创建动画曲线
        /// </summary>
        /// <returns>
        /// The animation curve.
        /// </returns>
        /// <param name='list'>
        /// List.
        /// </param>
        /// <param name='postWrapMode'>
        /// Post wrap mode.
        /// </param>
        /// <param name='preWrapMode'>
        /// Pre wrap mode.
        /// </param>
        public static AnimationCurve getAnimationCurve(ArrayList list, WrapMode postWrapMode, WrapMode preWrapMode)
        {
            if (list == null || list.Count <= 0)
            {
                return null;
            }
            int len = list.Count;
            Keyframe[] ks = new Keyframe[len];
            for (int i = 0; i < len; i++)
            {
                Hashtable m = (Hashtable)list[i];
                float inTangent = (float)MapEx.getDouble(m, "inTangent");
                float outTangent = (float)MapEx.getDouble(m, "outTangent");
                float time = (float)MapEx.getDouble(m, "time");
                float value = (float)MapEx.getDouble(m, "value");
                ks[i] = new Keyframe(time, value, inTangent, outTangent);
            }
            AnimationCurve curve = new AnimationCurve(ks);
            curve.preWrapMode = preWrapMode;
            curve.postWrapMode = postWrapMode;
            return curve;
        }

        /// <summary>
        /// Rotates the towards.转向目标方向(支持提前量)
        /// </summary>
        /// <param name='dir'>
        /// Dir.
        /// </param>
        public static void rotateTowardsForecast(Transform trsf, Transform target, float forecastDis = 0)
        {
            Vector3 dir = Vector3.zero;
            if (forecastDis > 0)
            {
                dir = target.position + target.forward * forecastDis - trsf.position;
            }
            else
            {
                dir = target.position - trsf.position;
            }
            RotateTowards(trsf, dir);
        }

        /// <summary>
        /// Rotates the towards.转向目标方向(立即)
        /// </summary>
        /// <param name='dir'>
        /// Dir.
        /// </param>
        public static void RotateTowards(Transform trsf, Vector3 from, Vector3 to)
        {
            RotateTowards(trsf, to - from);
        }

        public static void RotateTowards(Transform trsf, Vector3 dir)
        {
            if (dir.magnitude < 0.001f)
            {
                return;
            }
            Quaternion rot = trsf.rotation;
            Quaternion toTarget = Quaternion.LookRotation(dir);
            trsf.rotation = toTarget;
        }

        /// <summary>
        /// Rotates the towards.转向目标方向(有转向过程)
        /// </summary>
        /// <param name='dir'>
        /// Dir.
        /// </param>
        public static void RotateTowards(Transform transform, Vector3 dir, float turningSpeed)
        {
            try
            {
                Quaternion rot = transform.rotation;
                if (dir.magnitude < 0.001f)
                {
                    return;
                }
                Quaternion toTarget = Quaternion.LookRotation(dir);

                rot = Quaternion.Slerp(rot, toTarget, turningSpeed * Time.fixedDeltaTime);
                Vector3 euler = rot.eulerAngles;
                //euler.z = 0;
                //euler.x = 0;
                rot = Quaternion.Euler(euler);

                transform.rotation = rot;
            }
            catch (System.Exception e)
            {
                Debug.Log("name==" + transform.name + "   " + e);
            }
        }

        public static Vector3 getAngle(Transform tr, Vector3 pos2)
        {
            return getAngle(tr.position, pos2);
        }

        public static Vector3 getAngle(Vector3 pos1, Vector3 pos2)
        {
            Vector3 dir = pos2 - pos1;
            return getAngle(dir);
        }

        public static Vector3 getAngle(Vector3 dir)
        {
            if (dir.magnitude < 0.001f)
            {
                return Vector3.zero;
            }
            Quaternion toTarget = Quaternion.LookRotation(dir);

            Vector3 euler = toTarget.eulerAngles;
            return euler;
            //        return Quaternion.Euler(euler).eulerAngles;
        }

        /// <summary>
        /// Sets the body mat edit.重新设置一次shader，在editor模式下加载assetsbundle才需要调用这个方法
        /// </summary>
        /// <param name='tr'>
        /// Tr.
        /// </param>
        public static void setBodyMatEdit(Transform tr)
        {
            setBodyMatEdit(tr, null);
        }

        public static void setBodyMatEdit(Transform tr, Shader defaultShader)
        {
            if (tr == null)
            {
                return;
            }
            string shName = "";
            if (tr.GetComponent<Renderer>() != null && tr.GetComponent<Renderer>().sharedMaterial != null)
            {
                shName = tr.GetComponent<Renderer>().sharedMaterial.shader.name;
                if (defaultShader != null)
                {
                    tr.GetComponent<Renderer>().sharedMaterial.shader = defaultShader;
                }
                else
                {
                    tr.GetComponent<Renderer>().sharedMaterial.shader = Shader.Find(shName);
                }
            }
            SkinnedMeshRenderer smr = tr.GetComponent<SkinnedMeshRenderer>();
            if (smr != null)
            {
                shName = smr.sharedMaterial.shader.name;

                if (defaultShader != null)
                {
                    smr.sharedMaterial.shader = defaultShader;
                }
                else
                {
                    smr.sharedMaterial.shader = Shader.Find(shName);
                }
            }
            MeshRenderer mr = tr.GetComponent<MeshRenderer>();
            if (mr != null)
            {
                shName = mr.sharedMaterial.shader.name;
                if (defaultShader != null)
                {
                    mr.sharedMaterial.shader = defaultShader;
                }
                else
                {
                    mr.sharedMaterial.shader = Shader.Find(shName);
                }
                foreach (Material m in mr.sharedMaterials)
                {
                    shName = m.shader.name;
                    if (defaultShader != null)
                    {
                        m.shader = defaultShader;
                    }
                    else
                    {
                        m.shader = Shader.Find(shName);
                    }
                }
            }
            TrailRenderer tailRender = tr.GetComponent<TrailRenderer>();
            if (tailRender != null)
            {
                shName = tailRender.sharedMaterial.shader.name;
                if (defaultShader != null)
                {
                    tailRender.sharedMaterial.shader = defaultShader;
                }
                else
                {
                    tailRender.sharedMaterial.shader = Shader.Find(shName);
                }
            }
            for (int i = 0; i < tr.childCount; i++)
            {
                setBodyMatEdit(tr.GetChild(i));
            }
        }

        public static float distance(Transform tr1, Transform tr2)
        {
            return Vector3.Distance(tr1.position, tr2.position);
        }

        public static float distance4Loc(Transform tr1, Transform tr2)
        {
            return Vector3.Distance(tr1.localPosition, tr2.localPosition);
        }

        public static float distance(Vector2 v1, Vector2 v2)
        {
            return Vector2.Distance(v1, v2);
        }

        public static float distance(Vector3 v1, Vector3 v2)
        {
            return Vector3.Distance(v1, v2);
        }

        public static string LuaTableToString(LuaTable map)
        {
            if (map == null)
                return "map is null";
            StringBuilder outstr = new StringBuilder();
            LuaTableToString(map, outstr);
            return outstr.ToString();
        }

        public static void LuaTableToString(LuaTable map, StringBuilder outstr, int spacecount = 0)
        {
            //			IEnumerable<object> list = map.GetKeys<object> ();
            //			IEnumerator<object> e = list.GetEnumerator ();
            StringBuilder space = new StringBuilder();
            for (int i = 0; i < spacecount; i++)
            {
                space.Append(" ");
            }
            outstr.Append("\n" + space.ToString()).Append("{");
            foreach (object key in map.GetKeys<object>())
            {
                //				object key = cell.Key;
                object val = map.Get<object>(key);
                if (val == null)
                {
                    continue;
                }
                outstr.Append(space.ToString()).Append(key).Append("(").Append(key.GetType().ToString()).Append(")").Append("=");
                if (val is Hashtable)
                {
                    MapToString((Hashtable)val, outstr, spacecount++);
                }
                else if (val is ArrayList)
                {
                    ArrayListToString((ArrayList)val, outstr, spacecount++);
                }
                else if (val is LuaTable)
                {
                    LuaTableToString((LuaTable)val, outstr, spacecount++);
                }
                else if (val is byte[])
                {
                    outstr.Append(NumEx.bio2Int((byte[])val)).Append("(").Append(val.GetType().ToString()).Append(")").Append("\n");
                }
                else
                {
                    outstr.Append(val).Append("(").Append(val.GetType().ToString()).Append(")").Append("\n");
                }
            }
            outstr.Append("}\n");
            //Debug.Log(outstr.ToString());
        }

        public static string MapToString(Hashtable map)
        {
            if (map == null)
                return "map is null";
            StringBuilder outstr = new StringBuilder();
            MapToString(map, outstr);
            return outstr.ToString();
        }

        public static void MapToString(Hashtable map, StringBuilder outstr, int spacecount = 0)
        {
            //			ICollection keslist = map.Keys;
            //			IEnumerator e = keslist.GetEnumerator();
            StringBuilder space = new StringBuilder();
            for (int i = 0; i < spacecount; i++)
            {
                space.Append(" ");
            }
            outstr.Append("\n" + space.ToString()).Append("{");
            foreach (DictionaryEntry cell in map)
            {
                object key = cell.Key;
                object val = cell.Value;
                if (val == null)
                {
                    continue;
                }
                outstr.Append(space.ToString()).Append(key).Append("(").Append(key.GetType().ToString()).Append(")").Append("=");
                if (val is Hashtable)
                {
                    MapToString((Hashtable)val, outstr, spacecount++);
                }
                else if (val is ArrayList)
                {
                    ArrayListToString((ArrayList)val, outstr, spacecount++);
                }
                else if (val is LuaTable)
                {
                    LuaTableToString((LuaTable)val, outstr, spacecount++);
                }
                else if (val is byte[])
                {
                    outstr.Append(NumEx.bio2Int((byte[])val)).Append("(").Append(val.GetType().ToString()).Append(")").Append("\n");
                }
                else
                {
                    outstr.Append(val).Append("(").Append(val.GetType().ToString()).Append(")").Append("\n");
                }
            }
            outstr.Append("}\n");
            //Debug.Log(outstr.ToString());
        }

        public static string ArrayListToString2(ArrayList list)
        {
            StringBuilder outstr = new StringBuilder();
            ArrayListToString(list, outstr);
            return outstr.ToString();
        }

        public static void ArrayListToString(ArrayList list, StringBuilder outstr, int spacecount = 0)
        {
            StringBuilder space = new StringBuilder();
            for (int i = 0; i < spacecount; i++)
            {
                space.Append(" ");
            }
            outstr.Append("\n" + space.ToString()).Append("[");
            foreach (object item in list)
            {
                if (item == null)
                {
                    continue;
                }
                if (item is Hashtable)
                {
                    MapToString((Hashtable)item, outstr, spacecount++);
                }
                else if (item is ArrayList)
                {
                    ArrayListToString((ArrayList)item, outstr, spacecount++);
                }
                else if (item is byte[])
                {
                    outstr.Append(NumEx.bio2Int((byte[])item)).Append(",");
                }
                else
                {
                    outstr.Append(item).Append(",");
                }
            }
            outstr.Append("]\n");

            //Debug.Log(outstr.ToString());
        }


        /// <summary>
        /// Draws the grid. 画网格
        /// </summary>
        /// <returns>
        /// The grid.
        /// </returns>
        /// <param name='origin'>
        /// Origin.
        /// </param>
        /// <param name='numRows'>
        /// Number rows.
        /// </param>
        /// <param name='numCols'>
        /// Number cols.
        /// </param>
        /// <param name='cellSize'>
        /// Cell size.
        /// </param>
        /// <param name='color'>
        /// Color.
        /// </param>
        public static ArrayList drawGrid(LineRenderer prefab, Vector3 origin, int numRows, int numCols, float cellSize, Color color, Transform gridRoot, float h)
        {
            ArrayList list = new ArrayList();
#if UNITY_EDITOR
            if ((Application.platform == RuntimePlatform.OSXEditor ||
                Application.platform == RuntimePlatform.WindowsEditor) &&
                !Application.isPlaying)
            {
                return list;
            }
#endif

            float width = (numCols * cellSize);
            float height = (numRows * cellSize);

            // Draw the horizontal grid lines
            for (int i = 0; i < numRows + 1; i++)
            {
                Vector3 startPos = origin + i * cellSize * kZAxis;
                startPos.y = h;
                Vector3 endPos = startPos + width * kXAxis;
                endPos.y = h;
                LineRenderer lr = drawLine(prefab, startPos, endPos, color);
                list.Add(lr);
                lr.transform.parent = gridRoot;
            }

            // Draw the vertial grid lines
            for (int i = 0; i < numCols + 1; i++)
            {
                Vector3 startPos = origin + i * cellSize * kXAxis;
                startPos.y = h;
                Vector3 endPos = startPos + height * kZAxis;
                endPos.y = h;
                LineRenderer lr = drawLine(prefab, startPos, endPos, color);
                list.Add(lr);
                lr.transform.parent = gridRoot;
            }
            return list;
        }

        /// <summary>
        /// Draws the line.//画直线
        /// </summary>
        /// <returns>
        /// The line.
        /// </returns>
        /// <param name='startPos'>
        /// Start position.
        /// </param>
        /// <param name='endPos'>
        /// End position.
        /// </param>
        /// <param name='color'>
        /// Color.
        /// </param>
        public static LineRenderer drawLine(LineRenderer prefab, Vector3 startPos, Vector3 endPos, Color color)
        {
            LineRenderer line = Object.Instantiate(prefab) as LineRenderer;
            line.startColor = color;
            line.endColor = color;
            line.SetPosition(0, startPos);
            line.SetPosition(1, endPos);
            line.gameObject.SetActive(true);
            return line;
        }

        /// <summary>
        /// Clones the res. 实例化Resoureces下的资源
        /// </summary>
        /// <returns>
        /// The res.
        /// </returns>
        /// <param name='path'>
        /// Path.
        /// </param>
        public static GameObject cloneRes(string path)
        {
            try
            {
                return Object.Instantiate(Resources.Load(path)) as GameObject;
            }
            catch (System.Exception e)
            {
                Debug.Log(e + "path==" + path);
                return null;
            }
        }

        public static GameObject cloneRes(GameObject prefab)
        {
            try
            {
                return Object.Instantiate(prefab) as GameObject;
            }
            catch (System.Exception e)
            {
                Debug.Log(e);
                return null;
            }
        }

        /// <summary>
        /// Loads the res.跟路径加载资源
        /// </summary>
        /// <returns>
        /// The res.
        /// </returns>
        /// <param name='path'>
        /// Path.
        /// </param>
        public static object loadRes(string path)
        {
            try
            {
                return Resources.Load(path, typeof(object)) as object;
            }
            catch (System.Exception e)
            {
                Debug.Log(e);
                return null;
            }
        }

        /// <summary>
        /// Loads the gobj.从指定路径加载gameObject
        /// </summary>
        /// <returns>
        /// The gobj.
        /// </returns>
        /// <param name='path'>
        /// Path.
        /// </param>
        public static GameObject loadGobj(string path)
        {
            try
            {
                return Resources.Load(path, typeof(GameObject)) as GameObject;
            }
            catch (System.Exception e)
            {
                Debug.Log(e);
                return null;
            }
        }

        public static Vector2 addVector2(Vector2 v1, Vector2 v2)
        {
            return v1 + v2;
        }

        public static Vector3 addVector3(Vector3 v1, Vector3 v2)
        {
            return v1 + v2;
        }

        public static Vector2 cutVector2(Vector2 v1, Vector2 v2)
        {
            return v1 - v2;
        }

        public static Vector3 cutVector3(Vector3 v1, Vector3 v2)
        {
            return v1 - v2;
        }

        public static Transform getChild(Transform root, params object[] args)
        {
            Transform tr = root;
            if (root == null || args == null)
                return null;
            int count = args.Length;
            int i = 0;
            while (true)
            {
                if (i >= count)
                    break;
                if (tr == null)
                {
                    Debug.LogError(args[i]);
                    break;
                }
                tr = tr.Find(args[i].ToString());
                i = i + 1;
            }
            return tr;
        }

        static string SDCardPath = "";

        public static string getSDCard()
        {
            string sd = "";
#if UNITY_ANDROID && !UNITY_EDITOR
			if (string.IsNullOrEmpty(SDCardPath)) {
				AndroidJavaClass ajc = new AndroidJavaClass("com.coolape.u3dPlugin.FilePathUtl");
				SDCardPath = ajc.CallStatic<string>("getSDKPath");
			}
#endif
            sd = SDCardPath;
            return sd;
        }

        public static string chgToSDCard(string path)
        {
#if UNITY_ANDROID && !UNITY_EDITOR
			if (Directory.Exists("/sdcard/")) {
				path = path.Replace(CLPathCfg.persistentDataPath + "/", "/sdcard/");
			}
#endif
            return path;
        }

        ///   <summary>
        ///   给一个字符串进行MD5加密
        ///   </summary>
        ///   <param   name="strText">待加密字符串</param>
        ///   <returns>加密后的字符串</returns>
        public static string MD5Encrypt(string strText)
        {
            byte[] bytes = Encoding.UTF8.GetBytes(strText);    //tbPass为输入密码的文本框
            return MD5Encrypt(bytes);
        }

        public static byte[] getUtf8bytes(string str)
        {
            return Encoding.UTF8.GetBytes(str);    //tbPass为输入密码的文本框
        }

        public static string MD5Encrypt(byte[] bytes)
        {
            MD5 md5 = new MD5CryptoServiceProvider();
            byte[] output = md5.ComputeHash(bytes);
            return System.BitConverter.ToString(output).Replace("-", "").ToLower();  //tbMd5pass为输出加密文本
        }

        public static bool netIsActived()
        {
            bool ret = true;
#if UNITY_ANDROID && !UNITY_EDITOR
			AndroidJavaClass jc = new AndroidJavaClass("com.coolape.u3dPlugin.NetUtl");
        ret =  jc.CallStatic<bool>("isConnectNet");
#endif
            Debug.Log("Net state =" + Application.internetReachability);
            if (Application.internetReachability == NetworkReachability.NotReachable)
            {
                ret = false;
            }
            return ret;
        }

        /// <summary>
        /// Gets the state of the net.
        /// </summary>
        /// <returns>The net state.
        ///     None 无网络
        ///     WiFi
        ///     2G
        ///     3G
        ///     4G
        ///     Unknown
        /// </returns>
        public static string getNetState()
        {
            string ret = "Unkown";
#if UNITY_ANDROID && !UNITY_EDITOR
			AndroidJavaClass jc = new AndroidJavaClass("com.coolape.u3dPlugin.NetUtl");
        ret =  jc.CallStatic<string>("getCurrentNetworkType");
#endif
            return ret;
        }

        public static string urlAddTimes(string url)
        {
            if (url.StartsWith("http://"))
            {
                if (url.Contains("?"))
                {
                    url = PStr.b().a(url).a("&t_sign_flag___=").a(DateEx.nowMS).e();
                }
                else
                {
                    url = PStr.b().a(url).a("?t_sign_flag___=").a(DateEx.nowMS).e();
                }
#if CHL_NONE
                Debug.LogWarning(url);
#endif
            }
            return url;
        }

        /// <summary>
        /// Gets the sing in code android.取得签名值
        /// </summary>
        /// <returns>The sing in code android.</returns>
        public static string getSingInCodeAndroid()
        {
            try
            {
#if UNITY_ANDROID && !UNITY_EDITOR
				AndroidJavaClass jc = new AndroidJavaClass ("com.unity3d.player.UnityPlayer");
				AndroidJavaClass jcPackageManager = new AndroidJavaClass ("android.content.pm.PackageManager");
				AndroidJavaObject jo = jc.GetStatic<AndroidJavaObject> ("currentActivity");
				AndroidJavaObject joPackageManager = jo.Call<AndroidJavaObject> ("getPackageManager");
				string joPackageName = jo.Call<string> ("getPackageName");
				int GET_SIGNATURES = jcPackageManager.GetStatic<int> ("GET_SIGNATURES");
				AndroidJavaObject packageInfo = joPackageManager.Call<AndroidJavaObject> ("getPackageInfo", joPackageName, GET_SIGNATURES);
				AndroidJavaObject[] signs = packageInfo.Get<AndroidJavaObject[]> ("signatures");
				if (signs.Length > 0) {
					AndroidJavaObject sign = signs [0];
					string signStr = sign.Call<string> ("toCharsString");
					if (!string.IsNullOrEmpty (signStr)) {
						return MD5Encrypt (signStr);
					}
				}
//        PackageInfo packageInfo = _self.getPackageManager().getPackageInfo(_self.getPackageName(), PackageManager.GET_SIGNATURES);
//        Signature[] signs = packageInfo.signatures;
//        Signature sign = signs[0];
//        Log.d("CommonTool","sign:    " + sign);
//        return sign.hashCode();

#endif
            }
            catch (System.Exception e)
            {
                Debug.LogError(e);
            }
            return "";
        }

        public static LayerMask getLayer(string layerName)
        {
            string[] list = layerName.Split(',');
            LayerMask ret = 0;
            for (int i = 0; i < list.Length; i++)
            {
                ret |= (1 << LayerMask.NameToLayer(list[i]));
            }
            return ret;
        }

        static RaycastHit hitInfor = new RaycastHit();
        public static RaycastHit getRaycastHitInfor(Camera camera, Vector3 inPos, LayerMask layer)
        {
            if (camera == null)
                return hitInfor;
            Ray ray = camera.ScreenPointToRay(inPos);
            if (Physics.Raycast(ray, out hitInfor, 1000, layer.value))
            {
                return hitInfor;
            }
            else
            {
                return hitInfor;
            }
        }

        static void parseLuafunc(LuaTable luatable, out LuaFunction func, out LuaTable instance)
        {
            if (luatable != null)
            {
                func = luatable.GetInPath<LuaFunction>("func");
                instance = luatable.GetInPath<LuaTable>("instance");
            }
            else
            {
                func = null;
                instance = null;
            }
        }
        public static object[] doCallback(object callback, params object[] args)
        {
            try
            {
                if (callback == null)
                    return null;
                object[] ret = null;
                if (callback is LuaFunction)
                {
                    ret = ((LuaFunction)callback).Call(args);
                }
                else if (callback is LuaTable)
                {
                    LuaFunction func = null;
                    LuaTable instance = null;
                    parseLuafunc(callback as LuaTable, out func, out instance);
                    NewList list = ObjPool.listPool.borrowObject();
                    list.Add(instance);
                    list.AddRange(args);
                    ret = func.Call(list.ToArray(), null);
                    ObjPool.listPool.returnObject(list);
                }
                else if (callback is Callback)
                {
                    ((Callback)callback)(args);
                }
                return ret;
            }
            catch (System.Exception e)
            {
                Debug.LogError(e);
                return null;
            }
        }

        //public static object[] doCallback(object callback)
        //{
        //    try
        //    {
        //        if (callback == null)
        //            return null;
        //        object[] ret = null;
        //        if (callback is LuaTable)
        //        {
        //            LuaFunction func = null;
        //            LuaTable instance = null;
        //            parseLuafunc(callback as LuaTable, out func, out instance);
        //            ret = _doCallback(func, instance);
        //        }
        //        else
        //        {
        //            ret = _doCallback(callback);
        //        }
        //        return ret;
        //    }
        //    catch (System.Exception e)
        //    {
        //        Debug.LogError(e);
        //        return null;
        //    }
        //}
        //public static object[] doCallback(object callback, object paras1)
        //{
        //    try
        //    {
        //        if (callback == null)
        //            return null;
        //        object[] ret = null;
        //        if (callback is LuaTable)
        //        {
        //            LuaFunction func = null;
        //            LuaTable instance = null;
        //            parseLuafunc(callback as LuaTable, out func, out instance);
        //            ret = _doCallback(func, instance, paras1);
        //        }
        //        else
        //        {
        //            ret = _doCallback(callback, paras1);
        //        }
        //        return ret;
        //    }
        //    catch (System.Exception e)
        //    {
        //        Debug.LogError(e);
        //        return null;
        //    }
        //}

        //public static object[] doCallback(object callback, object paras1, object paras2)
        //{
        //    try
        //    {
        //        if (callback == null)
        //            return null;
        //        object[] ret = null;
        //        if (callback is LuaTable)
        //        {
        //            LuaFunction func = null;
        //            LuaTable instance = null;
        //            parseLuafunc(callback as LuaTable, out func, out instance);
        //            ret = _doCallback(func, instance, paras1, paras2);
        //        }
        //        else
        //        {
        //            ret = _doCallback(callback, paras1, paras2);
        //        }
        //        return ret;
        //    }
        //    catch (System.Exception e)
        //    {
        //        Debug.LogError(e);
        //        return null;
        //    }
        //}

        //public static object[] doCallback(object callback, object paras1, object paras2, object paras3)
        //{
        //    try
        //    {
        //        if (callback == null)
        //            return null;
        //        object[] ret = null;
        //        if (callback is LuaTable)
        //        {
        //            LuaFunction func = null;
        //            LuaTable instance = null;
        //            parseLuafunc(callback as LuaTable, out func, out instance);
        //            ret = _doCallback(func, instance, paras1, paras2, paras3);
        //        }
        //        else
        //        {
        //            ret = _doCallback(callback, paras1, paras2, paras3);
        //        }
        //        return ret;
        //    }
        //    catch (System.Exception e)
        //    {
        //        Debug.LogError(e);
        //        return null;
        //    }
        //}

        //public static object[] doCallback(object callback, object paras1, object paras2, object paras3, object paras4)
        //{
        //    try
        //    {
        //        if (callback == null)
        //            return null;
        //        object[] ret = null;
        //        if (callback is LuaTable)
        //        {
        //            LuaFunction func = null;
        //            LuaTable instance = null;
        //            parseLuafunc(callback as LuaTable, out func, out instance);
        //            ret = _doCallback(func, instance, paras1, paras2, paras3, paras4);
        //        }
        //        else
        //        {
        //            ret = _doCallback(callback, paras1, paras2, paras3, paras4);
        //        }
        //        return ret;
        //    }
        //    catch (System.Exception e)
        //    {
        //        Debug.LogError(e);
        //        return null;
        //    }
        //}

        //public static object[] doCallback(object callback, object paras1, object paras2, object paras3, object paras4, object paras5)
        //{
        //    try
        //    {
        //        if (callback == null)
        //            return null;
        //        object[] ret = null;
        //        if (callback is LuaTable)
        //        {
        //            LuaFunction func = null;
        //            LuaTable instance = null;
        //            parseLuafunc(callback as LuaTable, out func, out instance);
        //            ret = _doCallback(func, instance, paras1, paras2, paras3, paras4, paras5);
        //        }
        //        else
        //        {
        //            ret = _doCallback(callback, paras1, paras2, paras3, paras4, paras5);
        //        }
        //        return ret;
        //    }
        //    catch (System.Exception e)
        //    {
        //        Debug.LogError(e);
        //        return null;
        //    }
        //}

        /// <summary>
        /// Files to map.取得文件转成map
        /// </summary>
        /// <returns>
        /// The to map.
        /// </returns>
        /// <param name='path'>
        /// Path.
        /// </param>
        public static Hashtable fileToMap(string path)
        {
            if (!File.Exists(path))
            {
                return null;
            }
            byte[] buffer = File.ReadAllBytes(path);
            if (buffer != null)
            {
                MemoryStream ms = new MemoryStream();
                ms.Write(buffer, 0, buffer.Length);
                ms.Position = 0;
                object obj = B2InputStream.readObject(ms);
                if (obj != null)
                {
                    return (Hashtable)(obj);
                }
            }
            return null;
        }

        public static object fileToObj(string path)
        {
            if (!File.Exists(path))
            {
                return null;
            }
            byte[] buffer = File.ReadAllBytes(path);
            if (buffer != null)
            {
                MemoryStream ms = new MemoryStream();
                ms.Write(buffer, 0, buffer.Length);
                ms.Position = 0;
                object obj = B2InputStream.readObject(ms);
                if (obj != null)
                {
                    return obj;
                }
            }
            return null;
        }

        public static void printe(object msg)
        {
            Debug.LogError(msg);
        }

        public static void printw(object msg)
        {
            Debug.LogWarning(msg);
        }

        public static bool IntersectRay(Bounds bounds, Ray ray)
        {
            if (bounds.Contains(ray.origin))
                return true;
            return bounds.IntersectRay(ray);
        }

        public static bool IntersectRay(Bounds bounds, Ray ray, float minDis, float maxDis)
        {
            if (bounds.Contains(ray.origin))
                return true;
            float dis = 0;
            bool ret = bounds.IntersectRay(ray, out dis);
            if (ret && dis >= minDis && dis <= maxDis)
            {
                ret = true;
            }
            else
            {
                ret = false;
            }
            return ret;
        }


        public class GameObjcetPool : AbstractObjectPool<GameObject>
        {
            public override GameObject createObject(string key)
            {
                return new GameObject();
            }

            public override GameObject resetObject(GameObject t)
            {
                t.SetActive(false);
                return t;
            }
        }

        static GameObjcetPool goPool = new GameObjcetPool();

        public static Vector3 RotateAround(Vector3 currPoint, Vector3 point, Vector3 axis, float angle)
        {
            GameObject go = goPool.borrowObject();
            go.transform.position = currPoint;
            go.transform.RotateAround(point, axis, angle);

            Vector3 v3 = go.transform.position;
            goPool.returnObject(go);
            return v3;
        }

        [LuaCallCSharp]
        [ReflectionUse]
        public static byte[] read4MemoryStream(MemoryStream ms, int offset, int len)
        {
            if (ms == null || len <= 0)
            {
                return null;
            }

            byte[] ret = new byte[len];
            ms.Read(ret, offset, len);
            return ret;
        }

        public static string getSha256(string str)
        {
            //如果str有中文，不同Encoding的sha是不同的！！
            byte[] SHA256Data = Encoding.UTF8.GetBytes(str);

            //SHA256Managed Sha256 = new SHA256Managed();
            byte[] by = SHA256.Create().ComputeHash(SHA256Data);
            //Sha256.Clear();

            //var builder = new StringBuilder();
            //foreach (var t in by) { builder.Append(t.ToString("X2")); }
            //return builder.ToString();
            return System.BitConverter.ToString(by).Replace("-", string.Empty).ToLower(); //64
        }
    }

    /*
	 * 有的Unity对象，在C#为null，在lua为啥不为nil呢？比如一个已经Destroy的GameObject
	 * 其实那C#对象并不为null，是UnityEngine.Object重载的==操作符，
	 * 当一个对象被Destroy，未初始化等情况，obj == null返回true，
	 * 但这C#对象并不为null，可以通过System.Object.ReferenceEquals(null, obj)来验证下。
	 * 对应这种情况，可以为UnityEngine.Object写一个扩展方法：
	 */
    [LuaCallCSharp]
    [ReflectionUse]
    public static class UnityEngineObjectExtention
    {
        public static bool IsNull(this UnityEngine.Object o) // 或者名字叫IsDestroyed等等
        {
            return o == null;
        }
    }

}