using System;
using UnityEngine;

namespace UltimateWater
{
	public static class ColliderExtensions
	{
		public static float ComputeVolume(this Collider that)
		{
			BoxCollider boxCollider = that as BoxCollider;
			if (boxCollider != null)
			{
				return boxCollider.ComputeVolume();
			}
			SphereCollider sphereCollider = that as SphereCollider;
			if (sphereCollider != null)
			{
				return sphereCollider.ComputeVolume();
			}
			MeshCollider meshCollider = that as MeshCollider;
			if (meshCollider != null)
			{
				return meshCollider.ComputeVolume();
			}
			CapsuleCollider capsuleCollider = that as CapsuleCollider;
			if (capsuleCollider != null)
			{
				return capsuleCollider.ComputeVolume();
			}
			throw new NotImplementedException("UltimateWater: Unknown collider type.");
		}

		public static float ComputeVolume(this BoxCollider that)
		{
			Vector3 size = that.size;
			Vector3 lossyScale = that.transform.lossyScale;
			return size.x * lossyScale.x * size.y * lossyScale.y * size.z * lossyScale.z;
		}

		public static float ComputeVolume(this SphereCollider that)
		{
			float radius = that.radius;
			Vector3 lossyScale = that.transform.lossyScale;
			return 4.1887903f * radius * radius * radius * lossyScale.x * lossyScale.y * lossyScale.z;
		}

		public static float ComputeVolume(this MeshCollider that)
		{
			float num = 0f;
			Mesh sharedMesh = that.sharedMesh;
			Vector3[] vertices = sharedMesh.vertices;
			int[] triangles = sharedMesh.triangles;
			int num2 = triangles.Length;
			Vector3 vector = that.transform.InverseTransformPoint(that.bounds.center);
			int num3 = 0;
			while (num3 < num2)
			{
				Vector3 p = vertices[triangles[num3++]] - vector;
				Vector3 p2 = vertices[triangles[num3++]] - vector;
				Vector3 p3 = vertices[triangles[num3++]] - vector;
				num += SignedVolumeOfTriangle(p, p2, p3);
			}
			Vector3 lossyScale = that.transform.lossyScale;
			return Mathf.Abs(num) * lossyScale.x * lossyScale.y * lossyScale.z;
		}

		public static float ComputeVolume(this CapsuleCollider that)
		{
			float radius = that.radius;
			float num = 4.1887903f * radius * radius * radius;
			float num2 = MathF.PI * radius * radius * that.height;
			Vector3 lossyScale = that.transform.lossyScale;
			return (num2 + num) * lossyScale.x * lossyScale.y * lossyScale.z;
		}

		public static float SignedVolumeOfTriangle(Vector3 p1, Vector3 p2, Vector3 p3)
		{
			float num = p3.x * p2.y * p1.z;
			float num2 = p2.x * p3.y * p1.z;
			float num3 = p3.x * p1.y * p2.z;
			float num4 = p1.x * p3.y * p2.z;
			float num5 = p2.x * p1.y * p3.z;
			float num6 = p1.x * p2.y * p3.z;
			return 1f / 6f * (0f - num + num2 + num3 - num4 - num5 + num6);
		}

		public static float ComputeArea(this Collider that)
		{
			MeshCollider meshCollider = that as MeshCollider;
			if (meshCollider != null)
			{
				return meshCollider.ComputeArea();
			}
			BoxCollider boxCollider = that as BoxCollider;
			if (boxCollider != null)
			{
				return boxCollider.ComputeArea();
			}
			SphereCollider sphereCollider = that as SphereCollider;
			if (sphereCollider != null)
			{
				return sphereCollider.ComputeArea();
			}
			CapsuleCollider capsuleCollider = that as CapsuleCollider;
			if (capsuleCollider != null)
			{
				return capsuleCollider.ComputeArea();
			}
			throw new NotImplementedException("UltimateWater: Unknown collider type.");
		}

		public static float ComputeArea(this MeshCollider that)
		{
			float num = 0f;
			Mesh sharedMesh = that.sharedMesh;
			Vector3[] vertices = sharedMesh.vertices;
			int[] triangles = sharedMesh.triangles;
			int num2 = triangles.Length;
			Vector3 lossyScale = that.transform.lossyScale;
			int num3 = 0;
			while (num3 < num2)
			{
				Vector3 vector = vertices[triangles[num3++]];
				Vector3 lhs = vertices[triangles[num3++]] - vector;
				Vector3 rhs = vertices[triangles[num3++]] - vector;
				lhs.Scale(lossyScale);
				rhs.Scale(lossyScale);
				num += Vector3.Cross(lhs, rhs).magnitude;
			}
			return num * 0.5f;
		}

		public static float ComputeArea(this BoxCollider that)
		{
			Vector3 size = that.size;
			size.Scale(that.transform.lossyScale);
			return 2f * (size.x * size.y + size.y * size.z + size.x * size.z);
		}

		public static float ComputeArea(this SphereCollider that)
		{
			float magnitude = that.transform.lossyScale.magnitude;
			float num = that.radius * magnitude;
			return MathF.PI * 4f * num * num;
		}

		public static float ComputeArea(this CapsuleCollider that)
		{
			Vector3 lossyScale = that.transform.lossyScale;
			float num = that.radius * lossyScale.magnitude;
			float height = that.height;
			return MathF.PI * 2f * num * (2f * num + that.direction switch
			{
				0 => height * lossyScale.x, 
				1 => height * lossyScale.y, 
				2 => height * lossyScale.z, 
				_ => throw new InvalidOperationException(), 
			});
		}

		public static Vector3 RandomPoint(this Collider that)
		{
			MeshCollider meshCollider = that as MeshCollider;
			if (meshCollider != null)
			{
				return meshCollider.RandomPoint();
			}
			BoxCollider boxCollider = that as BoxCollider;
			if (boxCollider != null)
			{
				return boxCollider.RandomPoint();
			}
			CapsuleCollider capsuleCollider = that as CapsuleCollider;
			if (capsuleCollider != null)
			{
				return capsuleCollider.RandomPoint();
			}
			SphereCollider sphereCollider = that as SphereCollider;
			if (sphereCollider != null)
			{
				return sphereCollider.RandomPoint();
			}
			throw new NotImplementedException("UltimateWater: Unknown collider type.");
		}

		public static Vector3 RandomPoint(this MeshCollider that)
		{
			Bounds bounds = that.sharedMesh.bounds;
			Vector3 min = bounds.min;
			Vector3 vector = bounds.max - min;
			Vector3 vector2 = default(Vector3);
			for (int i = 0; i < 40; i++)
			{
				vector2.x = min.x + UnityEngine.Random.value * vector.x;
				vector2.y = min.y + UnityEngine.Random.value * vector.y;
				vector2.z = min.z + UnityEngine.Random.value * vector.z;
				if (that.IsPointInside(that.transform.TransformPoint(vector2)))
				{
					break;
				}
			}
			return vector2;
		}

		public static Vector3 RandomPoint(this BoxCollider that)
		{
			Vector3 center = that.center;
			Vector3 vector = that.size * 0.5f;
			float x = center.x + UnityEngine.Random.Range(0f - vector.x, vector.x);
			float y = center.y + UnityEngine.Random.Range(0f - vector.y, vector.y);
			float z = center.z + UnityEngine.Random.Range(0f - vector.z, vector.z);
			return new Vector3(x, y, z);
		}

		public static Vector3 RandomPoint(this CapsuleCollider that)
		{
			float radius = that.radius;
			float height = that.height;
			float num = MathF.PI * radius * radius * height;
			float num2 = 4.1887903f * radius * radius * radius;
			Vector3 result;
			if (UnityEngine.Random.Range(0f, num + num2) < num)
			{
				result = RandomPointInCircle(radius);
				result.z = result.y;
				result.y = UnityEngine.Random.Range((0f - height) * 0.5f, height * 0.5f);
			}
			else
			{
				result = RandomPointInSphere(radius);
				if (result.y < 0f)
				{
					result.y -= height * 0.5f;
				}
				else
				{
					result.y += height * 0.5f;
				}
			}
			switch (that.direction)
			{
			case 0:
			{
				float y2 = result.y;
				result.y = result.x;
				result.x = y2;
				break;
			}
			case 2:
			{
				float y = result.y;
				result.y = result.z;
				result.z = y;
				break;
			}
			}
			return result;
		}

		public static Vector3 RandomPoint(this SphereCollider that)
		{
			return RandomPointInSphere(that.radius);
		}

		public static Vector3 RandomPointInSphere(float radius)
		{
			float f = Mathf.Asin(UnityEngine.Random.Range(-1f, 1f));
			float f2 = MathF.PI * 2f * UnityEngine.Random.Range(0f, 1f);
			float num = 3f * Mathf.Pow(UnityEngine.Random.Range(0f, 1f), 1f / 3f);
			float num2 = Mathf.Sin(f);
			return new Vector3(num * num2 * Mathf.Cos(f2), num * num2 * Mathf.Sin(f2), num * Mathf.Cos(f));
		}

		public static Vector2 RandomPointInCircle(float radius)
		{
			float f = MathF.PI * 2f * UnityEngine.Random.Range(0f, 1f);
			float num = UnityEngine.Random.Range(0f, 1f) + UnityEngine.Random.Range(0f, 1f);
			float num2 = ((num > 1f) ? (2f - num) : num) * radius;
			return new Vector2(num2 * Mathf.Cos(f), num2 * Mathf.Sin(f));
		}

		public static void GetLocalMinMax(Collider collider, out Vector3 min, out Vector3 max)
		{
			MeshCollider meshCollider = collider as MeshCollider;
			if (meshCollider != null)
			{
				Bounds bounds = meshCollider.sharedMesh.bounds;
				min = bounds.min;
				max = bounds.max;
				return;
			}
			BoxCollider boxCollider = collider as BoxCollider;
			if (boxCollider != null)
			{
				BoxCollider boxCollider2 = boxCollider;
				min = boxCollider2.center - boxCollider2.size * 0.5f;
				max = boxCollider2.center + boxCollider2.size * 0.5f;
				return;
			}
			SphereCollider sphereCollider = collider as SphereCollider;
			if (sphereCollider != null)
			{
				Vector3 center = sphereCollider.center;
				float num = sphereCollider.radius * 0.5f;
				min = new Vector3(center.x - num, center.y - num, center.z - num);
				max = new Vector3(center.x + num, center.y + num, center.z + num);
				return;
			}
			CapsuleCollider capsuleCollider = collider as CapsuleCollider;
			if (capsuleCollider != null)
			{
				Vector3 center2 = capsuleCollider.center;
				float num2 = capsuleCollider.radius * 0.5f;
				float num3 = capsuleCollider.height * 0.5f + num2;
				switch (capsuleCollider.direction)
				{
				case 0:
					min = new Vector3(center2.x - num3, center2.y - num2, center2.z - num2);
					max = new Vector3(center2.x + num3, center2.y + num2, center2.z + num2);
					break;
				case 1:
					min = new Vector3(center2.x - num2, center2.y - num3, center2.z - num2);
					max = new Vector3(center2.x + num2, center2.y + num3, center2.z + num2);
					break;
				case 2:
					min = new Vector3(center2.x - num2, center2.y - num2, center2.z - num3);
					max = new Vector3(center2.x + num2, center2.y + num2, center2.z + num3);
					break;
				default:
					throw new InvalidOperationException();
				}
				return;
			}
			throw new InvalidOperationException();
		}

		public static bool IsPointInside(this Collider convex, Vector3 point)
		{
			Bounds bounds = convex.bounds;
			if (!bounds.Contains(point))
			{
				return false;
			}
			Vector3 direction = bounds.center - point;
			float magnitude = direction.magnitude;
			if (magnitude < 1E-05f)
			{
				return true;
			}
			RaycastHit hitInfo;
			return !convex.Raycast(new Ray(point, direction), out hitInfo, magnitude);
		}
	}
}