using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public static class PocHelper
{

    public static void SetLayer(Transform t, int layer)
    {
        t.gameObject.layer = layer;
        for (int i = 0; i < t.childCount; i++)
        {
            SetLayer(t.GetChild(i), layer);
        }
    }

    public static void SetObjectCameraMirror(Transform t, bool mirror, int resolutionWidth = 0)
    {
        Camera[] cameras = t.GetComponentsInChildren<Camera>(true);
        for (int i = 0; i < cameras.Length; i++)
        {
            CameraImageMirror cim = cameras[i].gameObject.GetComponent<CameraImageMirror>();
            if (cim == null)
                cim = cameras[i].gameObject.AddComponent<CameraImageMirror>();
            cim.enabled = mirror;
            if (mirror)
                PostEffectHelper.renderTextureWidth = resolutionWidth;
        }
    }

    public static void PlaySound(AudioClip clip, bool repeat = false)
    {

    }

    public static void StopSound(AudioClip clip)
    {

    }

    public static void PlayGoAnim(GameObject go, string animOrStateName)
    {
        go.SetActive(true);

        Animation anim = go.GetComponent<Animation>();
        if (anim != null)
        {
            anim.enabled = true;
            if (string.IsNullOrEmpty(animOrStateName))
            {
                if (anim.playAutomatically)
                {
                    go.SetActive(false);
                    go.SetActive(true);
                }
                else
                    anim.Play();
            }
            else
                anim.Play(animOrStateName);
        }
        else
        {
            Animator animator = go.GetComponent<Animator>();
            if (animator != null)
            {
                animator.enabled = true;
                if (!string.IsNullOrEmpty(animOrStateName))
                    animator.Play(animOrStateName);
            }
        }
    }

    public static void StopGoAnim(GameObject go)
    {
        go.SetActive(true);

        Animation anim = go.GetComponent<Animation>();
        if (anim != null && anim.isPlaying)
            anim.Stop();
        else
        {
            Animator animator = go.GetComponent<Animator>();
            if (animator != null && animator.enabled)
                animator.StopPlayback();
        }
    }

    public static GameObject CreateTransformHolder(GameObject go)
    {
        if (go == null)
            return null;
        GameObject holder = new GameObject("Holder_" + go.name);
        holder.transform.SetParent(go.transform.parent);
        holder.transform.localPosition = Vector3.zero;
        holder.transform.localEulerAngles = Vector3.zero;
        holder.transform.localScale = Vector3.one;
        holder.SetActive(go.activeInHierarchy);
        go.transform.SetParent(holder.transform);
        go.SetActive(true);
        return holder;
    }

    public static Transform CreateTransformHolder(Transform t)
    {
        if (t == null)
            return null;
        return CreateTransformHolder(t.gameObject).transform;
    }

    public static bool IsPlayingAnim(Animator[] animators, bool ignoreRepeatMotion = true)
    {
        if (animators == null || animators.Length == 0)
            return false;

        for(int idx =0; idx < animators.Length;idx++)
        {
            Animator anim = animators[idx];
            if (anim.enabled)
            {
                if (anim.IsInTransition(0))
                    return true;

                AnimatorStateInfo stateInfo = anim.GetCurrentAnimatorStateInfo(0);
                if (ignoreRepeatMotion)
                {
                    if (stateInfo.length > 0 && stateInfo.normalizedTime < 1)
                        return true;
                }
                else
                {
                    if (stateInfo.length > 0 && (stateInfo.normalizedTime < 1 || stateInfo.loop))
                        return true;
                }
            }
        }
        return false;
    }

    public static bool IsPlayingAnim(GameObject go, bool ignoreRepeatMotion = true)
    {
        Animator[] animators = go.GetComponentsInChildren<Animator>();
        for (int i = 0; i < animators.Length; i++)
        {
            if (animators[i].enabled)
            {
                if (animators[i].IsInTransition(0))
                    return true;

                AnimatorStateInfo stateInfo = animators[i].GetCurrentAnimatorStateInfo(0);
                if (ignoreRepeatMotion)
                {
                    if (stateInfo.length > 0 && stateInfo.normalizedTime < 1)
                        return true;
                }
                else
                {
                    if (stateInfo.length > 0 && (stateInfo.normalizedTime < 1 || stateInfo.loop))
                        return true;
                }
            }
        }
        return false;
    }

    public static bool IsInRange(this Vector3 v, Vector3 min, Vector3 max, float compareDeviation)
    {
        return v.x >= min.x - compareDeviation && v.x <= max.x + compareDeviation
            && v.y >= min.y - compareDeviation && v.y <= max.y + compareDeviation
            && v.z >= min.z - compareDeviation && v.z <= max.z + compareDeviation;
    }

	public static bool IsInRange(this Vector3 v, Vector3 min, Vector3 max)
	{
		return v.x >= min.x && v.x <= max.x
			&& v.y >= min.y && v.y <= max.y
			&& v.z >= min.z && v.z <= max.z;
	}

    public static Vector3 ClampPosition(this Vector3 v, Vector3 min, Vector3 max)
    {
        return new Vector3(Mathf.Clamp(v.x, min.x, max.x), Mathf.Clamp(v.y, min.y, max.y), Mathf.Clamp(v.z, min.z, max.z));
    }

	public static Vector3 RandomPosition(Vector3 min, Vector3 max)
	{
		return new Vector3 (Random.Range (min.x, max.x), Random.Range (min.y, max.y), Random.Range (min.z, max.z));
	}

    public static bool DirEqual(this Vector3 v1, Vector3 v2, float compareDeviation = 1e-3f)
    {
        if (Mathf.Abs(v1.x) < Mathf.Abs(v1.y))
        {
            if (Mathf.Abs(v1.y) < Mathf.Abs(v1.z))
            {
                //max z
                if (v1.z.FEqual(0, compareDeviation))
                    return v2.FEqual(Vector3.zero, compareDeviation);
                else
                    return v2.z * v1.z > 0 && v2.FEqual(v1 * (v2.z / v1.z), compareDeviation);
            }
            else
            {
                //max y
                if (v1.y.FEqual(0, compareDeviation))
                    return v2.FEqual(Vector3.zero, compareDeviation);
                else
                    return v2.y * v1.y > 0 && v2.FEqual(v1 * (v2.y / v1.y), compareDeviation);
            }
        }
        else if (Mathf.Abs(v1.x) < Mathf.Abs(v1.z))
        {
            //max z
            if (v1.z.FEqual(0, compareDeviation))
                return v2.FEqual(Vector3.zero, compareDeviation);
            else
                return v2.z * v1.z > 0 && v2.FEqual(v1 * (v2.z / v1.z), compareDeviation);
        }
        else
        {
            //max x
            if (v1.x.FEqual(0, compareDeviation))
                return v2.FEqual(Vector3.zero, compareDeviation);
            else
                return v2.x * v1.x > 0 && v2.FEqual(v1 * (v2.x / v1.x), compareDeviation);
        }
        
    }

    //两直线最短距离，要求d1,d2为标准化向量
    public static float MinSqrDistanceOfLine(Vector3 p1, Vector3 d1, Vector3 p2, Vector3 d2, out float resultT1, out float resultT2)
    {
        Vector3 c = Vector3.Cross(d1, d2);
        float sqrMagnitude = Vector3.SqrMagnitude(c);
        if (sqrMagnitude < 1e-5f)
        {
            //平行/重合
            resultT1 = 0;
            resultT2 = Vector3.Dot(p1 - p2, d2);
            return Vector3.SqrMagnitude(p1 - (p2 + resultT2 * d2));
        }
        else
        {
            resultT1 = Vector3.Dot(Vector3.Cross((p2 - p1), d2), c) / sqrMagnitude;
            resultT2 = Vector3.Dot(Vector3.Cross((p2 - p1), d1), c) / sqrMagnitude;
            return Vector3.SqrMagnitude((p1 + resultT1 * d1) - (p2 + resultT2 * d2));
        }
    }

    public static float SqrDistanceToLine(this Vector3 p, Vector3 p0, Vector3 d, out float t)
    {
        t = Vector3.Dot(p - p0, d);
        return Vector3.SqrMagnitude(p - (p0 + t * d));
    }

    public static bool RayHitCheckCylinder(Ray r, Vector3 p, float radius, float height)
    {
        float sqrRadius = radius * radius;
        float t1, t2;
        float minSqrDistance = MinSqrDistanceOfLine(r.origin, r.direction, p, Vector3.up, out t1, out t2);
        if (minSqrDistance >= sqrRadius)
            return false;
        if (t1 < 0)
        {
            minSqrDistance = r.origin.SqrDistanceToLine(p, Vector3.up, out t2);
            if (minSqrDistance >= sqrRadius)
                return false;
            if (t2 <= 0 || t2 >= height)
                minSqrDistance = Mathf.Min(Vector3.SqrMagnitude(p - r.origin), Vector3.SqrMagnitude(p + Vector3.up * height - r.origin));
            return minSqrDistance < sqrRadius;
        }
        else
        {
            if (t2 <= 0 || t2 >= height)
                minSqrDistance = Mathf.Min(
                    p.SqrDistanceToLine(r.origin, r.direction, out t1),
                    (p + Vector3.up * height).SqrDistanceToLine(r.origin, r.direction, out t1)
                    );
            return minSqrDistance < sqrRadius;
        }
    }

    public static Transform SearchFirstInChildrenByName(this Transform t, string name)
    {
        if (t.name == name)
            return t;

        for (int i = 0; i < t.childCount; i++)
        {
            Transform found = SearchFirstInChildrenByName(t.GetChild(i), name);
            if (found != null)
                return found;
        }

        return null;
    }

    public static void AttachChild(this Transform t, Transform child, string path = null, bool isFullPath = true)
    {
        if (string.IsNullOrEmpty(path))
            child.SetParent(t);
        else
        {
            if (isFullPath)
            {
                Transform attachParent = t.Find(path);
                if (attachParent != null)
                    child.SetParent(attachParent);
            }
            else
            {
                Transform attachParent = t.SearchFirstInChildrenByName(path);
                if (attachParent != null)
                    child.SetParent(attachParent);
            }
        }
    }

    public delegate bool CheckObjectCallback<T>(T element);
    public delegate void DoObjectCallback<T>(T element);
    public delegate T2 ConvertObjectCallback<T1, T2>(T1 element);
    public static int CheckElementCount<T>(this T[] srcArray, CheckObjectCallback<T> cb)
    {
        int cnt = 0;
        for (int i = 0; i < srcArray.Length; i++)
        {
            if (cb(srcArray[i]))
                cnt++;
        }
        return cnt;
    }

    public static bool CheckAll<T>(this T[] srcArray, CheckObjectCallback<T> cb)
    {
        for (int i = 0; i < srcArray.Length; i++)
        {
            if (!cb(srcArray[i]))
                return false;
        }
        return true;
    }

    public static int CheckElementCount<T>(this System.Collections.Generic.List<T> srcList, CheckObjectCallback<T> cb)
    {
        int cnt = 0;
        for (int i = 0; i < srcList.Count; i++)
        {
            if (cb(srcList[i]))
                cnt++;
        }
        return cnt;
    }

    public static bool CheckAll<T>(this System.Collections.Generic.List<T> srcList, CheckObjectCallback<T> cb)
    {
        for (int i = 0; i < srcList.Count; i++)
        {
            if (!cb(srcList[i]))
                return false;
        }
        return true;
    }

    public static System.Collections.Generic.List<T> SelectFromArray<T>(this T[] srcArray, CheckObjectCallback<T> cb)
    {
        System.Collections.Generic.List<T> resultList = new System.Collections.Generic.List<T>();
        for (int i = 0; i < srcArray.Length; i++)
        {
            if (cb(srcArray[i]))
                resultList.Add(srcArray[i]);
        }

        return resultList;
    }

    public static void DoForAll<T>(this T[] srcArray, DoObjectCallback<T> cb)
    {
        for (int i = 0; i < srcArray.Length; i++)
            cb(srcArray[i]);
    }

    public static System.Collections.Generic.List<T> SelectFromList<T>(this System.Collections.Generic.List<T> srcList, CheckObjectCallback<T> cb)
    {
        System.Collections.Generic.List<T> resultList = new System.Collections.Generic.List<T>();
        for (int i = 0; i < srcList.Count; i++)
        {
            if (cb(srcList[i]))
                resultList.Add(srcList[i]);
        }

        return resultList;
    }

    public static void DoForAll<T>(this System.Collections.Generic.List<T> srcList, DoObjectCallback<T> cb)
    {
        for (int i = 0; i < srcList.Count; i++)
            cb(srcList[i]);
    }

    public static T FindFirst<T>(this T[] srcArray, CheckObjectCallback<T> cb)
    {
        for (int i = 0; i < srcArray.Length; i++)
        {
            if (cb(srcArray[i]))
                return srcArray[i];
        }
        return default(T);
    }

    public static int IndexOf<T>(this T[] srcArray, CheckObjectCallback<T> cb)
    {
        for (int i = 0; i < srcArray.Length; i++)
        {
            if (cb(srcArray[i]))
                return i;
        }
        return -1;
    }

    public static T FindFirst<T>(this System.Collections.Generic.List<T> srcList, CheckObjectCallback<T> cb)
    {
        for (int i = 0; i < srcList.Count; i++)
        {
            if (cb(srcList[i]))
                return srcList[i];
        }
        return default(T);
    }

    public static T2[] ConvertArray<T1, T2>(this T1[] srcArray, ConvertObjectCallback<T1, T2> cb)
    {
        T2[] result = new T2[srcArray.Length];
        for (int i = 0; i < srcArray.Length; i++)
            result[i] = cb(srcArray[i]);
        return result;
    }

    public static void RemoveComponentsInChildren<T>(this Transform t) where T : Component
    {
        for (int i = 0; i < t.childCount; i++)
            RemoveComponentsInChildren<T>(t.GetChild(i));

        while (t.GetComponent<T>() != null)
        {
            T com = t.GetComponent<T>();
            GameObject.DestroyImmediate(com);
        }
    }

    public static int MiddleSearch<T>(this System.Collections.Generic.List<T> list, int idx, CheckObjectCallback<T> cb)
    {
        if (idx < list.Count && idx >= 0)
        {
            if (cb(list[idx]))
                return idx;
        }

        int offset = 1;
        while (idx + offset < list.Count || idx - offset >= 0)
        {
            if (idx + offset >= 0 && idx + offset < list.Count && cb(list[idx + offset]))
                return idx + offset;
            if (idx - offset >= 0 && idx - offset < list.Count && cb(list[idx - offset]))
                return idx - offset;
            offset++;
        }

        return -1;
    }

    public static void ResetAnimationToStart(Animation anim)
    {
        if (anim != null && anim.clip != null)
        {
            string name = anim.clip.name;
            anim[name].speed = -1;
            anim.Play(name);
        }
    }

    public static void ReplayResetAnimation(Animation anim)
    {
        if (anim != null && anim.clip != null)
        {
            string name = anim.clip.name;
            anim[name].speed = 1;
            anim.Play(name);
        }
    }

	public static string FormatDescription(string desc, float seconds, float[] values, float rate = 1f, int secondPrecision = 0, int percentPrecision = 1, int valuePrecision = 0)
	{
		string result = desc;

		if (result.Contains("%t"))
			result = result.Replace("%t", seconds.ToString("F" + secondPrecision.ToString()));

		if (result.Contains("%r"))
			result = result.Replace("%r", (rate * 100).ToString("F" + percentPrecision.ToString()));

		int idx = 0;
		while (idx < values.Length)
		{
			float value = values[idx];

			char c = (char)('a' + idx);
			if (result.Contains("%" + c))
				result = result.Replace("%" + c, (value * 0.01f).ToString("F" + percentPrecision.ToString()));

			char C = (char)('A' + idx);
			if (result.Contains("%" + C))
				result = result.Replace("%" + C, value.ToString("F" + valuePrecision.ToString()));

			idx++;
		}

		result = result.Replace("%%", "%");

		return result; 
	}

	public static string FormatUpgradeDescription(string desc, float seconds, float[] values, float rate, float deltaSeconds, float[] deltaValues, float deltaRate, int secondPrecision = 0, int percentPrecision = 1, int valuePrecision = 0)
	{
		string result = desc;

		if (result.Contains ("%t")) {
			if (deltaSeconds < 1e-4f)
				result = result.Replace ("%t", seconds.ToString ("F" + secondPrecision.ToString ()));
			else
				result = result.Replace ("%t", seconds.ToString ("F" + secondPrecision.ToString ()) 
					+ string.Format ("(+{0})", deltaSeconds.ToString ("F" + secondPrecision.ToString ())));
		}

		if (result.Contains ("%r")) {
			if (deltaRate < 1e-4f)	
				result = result.Replace ("%r", (rate * 100).ToString ("F" + percentPrecision.ToString ()));
			else
				result = result.Replace ("%r", (rate * 100).ToString ("F" + percentPrecision.ToString ()) 
					+ string.Format ("(+{0})", (deltaRate * 100).ToString ("F" + percentPrecision.ToString ())));
		}

		int idx = 0;
		while (idx < values.Length)
		{
			float value = values[idx];
			float addValue = deltaValues[idx];

			char c = (char)('a' + idx);
			if (result.Contains ("%" + c)) {
				if (addValue < 1e-4f)
					result = result.Replace ("%" + c, (value * 0.01f).ToString ("F" + percentPrecision.ToString ()));
				else
					result = result.Replace ("%" + c, (value * 0.01f).ToString ("F" + percentPrecision.ToString ())
						+ string.Format ("(+{0}%)", (addValue * 0.01f).ToString ("F" + percentPrecision.ToString ())));
			}

			char C = (char)('A' + idx);
			if (result.Contains ("%" + C)) {
				if (addValue < 1e-4f)
					result = result.Replace ("%" + C, value.ToString ("F" + valuePrecision.ToString ()));
				else
					result = result.Replace ("%" + C, value.ToString ("F" + valuePrecision.ToString ())
						+ string.Format ("(+{0})", addValue.ToString ("F" + valuePrecision.ToString ())));
			}

			idx++;
		}

		result = result.Replace("%%", "%");

		return result; 
	}

    public static string FormatDescription(string desc, float seconds, float[] values, float[] nextValues, float rate = 1f, int secondPrecision = 0, int percentPrecision = 1, int valuePrecision = 0)
    {
        string result = desc;

        if (result.Contains("%t"))
            result = result.Replace("%t", seconds.ToString("F" + secondPrecision.ToString()));

        if (result.Contains("%r"))
            result = result.Replace("%r", (rate * 100).ToString("F" + percentPrecision.ToString()));

        int idx = 0;
        while (idx < values.Length)
        {
            float value = values[idx];
            float nextValue = nextValues[idx];

            char c = (char)('a' + idx);
            if (result.Contains("%" + c))
                result = result.Replace("%" + c, (value * 0.01f).ToString("F" + percentPrecision.ToString()));
            if (result.Contains("%(" + c + "+1)"))
                result = result.Replace("%(" + c + "+1)", (nextValue * 0.01f).ToString("F" + percentPrecision.ToString()));

            char C = (char)('A' + idx);
            if (result.Contains("%" + C))
                result = result.Replace("%" + C, value.ToString("F" + valuePrecision.ToString()));
            if (result.Contains("%(" + C + "+1)"))
                result = result.Replace("%(" + C + "+1)", nextValue.ToString("F" + valuePrecision.ToString()));

            idx++;
        }

        result = result.Replace("%%", "%");

        return result; 
    }

    public static Vector3 ConvertCfgVector3(object obj)
    {
        try
        {
            float[] values = ((List<object>)obj).ConvertAll(a => 
            {
                if (a.GetType() == typeof(System.Single))
                    return (float)a;
                else if (a.GetType() == typeof(System.Int32))
                    return (float)(System.Int32)a;
                else return (float)a;
            }).ToArray();
            return new Vector3(values[0], values[1], values[2]);
        }
        catch
        {
            //Log.E("ConvertCfgVector3:{0}", obj.ToString());
            return Vector3.zero;
        }
    }

    public static Vector2 ConvertCfgVector2(object obj)
    {
        try
        {
            float[] values = ((List<object>)obj).ConvertAll(a =>
            {
                if (a.GetType() == typeof(System.Single))
                    return (float)a;
                else if (a.GetType() == typeof(System.Int32))
                    return (float)(System.Int32)a;
                else return (float)a;
            }).ToArray();
            return new Vector2(values[0], values[1]);
        }
        catch
        {
            //Log.E("ConvertCfgVector2:{0}", obj.ToString());
            return Vector2.zero;
        }
    }

	#if UNITY_EDITOR
	public static void DrawDirCubeGizmos(Vector3 pos, Vector3 size, Vector3 forward, Vector3 up)
	{
		Vector3 right = Vector3.Cross (forward, up);
		Vector3 halfSize = 0.5f * size;
		Vector3 v1 = pos - halfSize.x * right - halfSize.y * up - halfSize.z * forward;
		Vector3 v2 = v1 + size.x * right;
		Vector3 v3 = v2 + size.z * forward;
		Vector3 v4 = v1 + size.z * forward;
		Vector3 v5 = v1 + size.y * up;
		Vector3 v6 = v2 + size.y * up;
		Vector3 v7 = v3 + size.y * up;
		Vector3 v8 = v4 + size.y * up;
		Gizmos.DrawLine (v1, v2);
		Gizmos.DrawLine (v2, v3);
		Gizmos.DrawLine (v3, v4);
		Gizmos.DrawLine (v4, v1);
		Gizmos.DrawLine (v5, v6);
		Gizmos.DrawLine (v6, v7);
		Gizmos.DrawLine (v7, v8);
		Gizmos.DrawLine (v8, v5);
		Gizmos.DrawLine (v1, v5);
		Gizmos.DrawLine (v2, v6);
		Gizmos.DrawLine (v3, v7);
		Gizmos.DrawLine (v4, v8);
	}
	#endif
}