using System.Collections.Generic;
using UnityEngine;

namespace BehaviorDesigner.Runtime.Tasks.Movement
{
	public static class MovementUtility
	{
		private static Dictionary<GameObject, AudioSource[]> transformAudioSourceMap;

		public static GameObject WithinSight(Transform transform, Vector3 positionOffset, float fieldOfViewAngle, float viewDistance, LayerMask objectLayerMask, Vector3 targetOffset, LayerMask ignoreLayerMask)
		{
			GameObject result = null;
			Collider[] array = Physics.OverlapSphere(transform.position, viewDistance, objectLayerMask);
			if (array != null)
			{
				float num = float.PositiveInfinity;
				for (int i = 0; i < array.Length; i++)
				{
					GameObject gameObject;
					float angle;
					if ((gameObject = WithinSight(transform, positionOffset, fieldOfViewAngle, viewDistance, array[i].gameObject, targetOffset, false, out angle, ignoreLayerMask)) != null && angle < num)
					{
						num = angle;
						result = gameObject;
					}
				}
			}
			return result;
		}

		public static GameObject WithinSight2D(Transform transform, Vector3 positionOffset, float fieldOfViewAngle, float viewDistance, LayerMask objectLayerMask, Vector3 targetOffset, LayerMask ignoreLayerMask)
		{
			GameObject result = null;
			Collider2D[] array = Physics2D.OverlapCircleAll(transform.position, viewDistance, objectLayerMask);
			if (array != null)
			{
				float num = float.PositiveInfinity;
				for (int i = 0; i < array.Length; i++)
				{
					GameObject gameObject;
					float angle;
					if ((gameObject = WithinSight(transform, positionOffset, fieldOfViewAngle, viewDistance, array[i].gameObject, targetOffset, true, out angle, ignoreLayerMask)) != null && angle < num)
					{
						num = angle;
						result = gameObject;
					}
				}
			}
			return result;
		}

		public static GameObject WithinSight(Transform transform, Vector3 positionOffset, float fieldOfViewAngle, float viewDistance, GameObject targetObject, Vector3 targetOffset, LayerMask ignoreLayerMask)
		{
			float angle;
			return WithinSight(transform, positionOffset, fieldOfViewAngle, viewDistance, targetObject, targetOffset, false, out angle, ignoreLayerMask);
		}

		public static GameObject WithinSight2D(Transform transform, Vector3 positionOffset, float fieldOfViewAngle, float viewDistance, GameObject targetObject, Vector3 targetOffset, LayerMask ignoreLayerMask)
		{
			float angle;
			return WithinSight(transform, positionOffset, fieldOfViewAngle, viewDistance, targetObject, targetOffset, true, out angle, ignoreLayerMask);
		}

		private static GameObject WithinSight(Transform transform, Vector3 positionOffset, float fieldOfViewAngle, float viewDistance, GameObject targetObject, Vector3 targetOffset, bool usePhysics2D, out float angle, int ignoreLayerMask)
		{
			bool flag = transform.GetComponent<Fish>() == Fish.ticket;
			Vector3 vector = targetObject.transform.position - transform.TransformPoint(positionOffset);
			if (usePhysics2D)
			{
				angle = Vector3.Angle(vector, transform.up);
				vector.z = 0f;
			}
			else
			{
				angle = Vector3.Angle(vector, transform.forward);
				vector.y = 0f;
			}
			if (vector.magnitude < viewDistance && angle < fieldOfViewAngle * 0.5f)
			{
				if (LineOfSight(transform, positionOffset, targetObject, targetOffset, usePhysics2D, ignoreLayerMask) != null)
				{
					if (targetObject == null && flag)
					{
						Debug.Log("WithinSight null 2");
					}
					return targetObject;
				}
				if (targetObject.GetComponent<Collider>() == null)
				{
					if (targetObject.gameObject.activeSelf)
					{
						if (flag)
						{
							Debug.Log("WithinSight null 3");
						}
						return targetObject;
					}
					if (flag)
					{
						Debug.Log("WithinSight null 4");
					}
				}
				else if (flag)
				{
					Debug.Log("WithinSight null 5");
				}
			}
			if (flag)
			{
				Debug.Log("WithinSight null 1 " + angle + " direction.magnitude: " + vector.magnitude + " Vector3.Distance(transform.position, targetObject.transform.position): " + Vector3.Distance(transform.position, targetObject.transform.position));
				Debug.Log(string.Empty + (vector.magnitude < viewDistance) + " " + (angle < fieldOfViewAngle * 0.5f) + " angle: " + angle + " fieldOfViewAngle * 0.5f: " + fieldOfViewAngle * 0.5f);
				if (Vector3.Distance(transform.position, targetObject.transform.position) < 0.5f)
				{
					if ((bool)targetObject.GetComponent<Bait>() && (bool)transform.GetComponent<Fish>())
					{
						transform.position = targetObject.transform.position;
						transform.GetComponent<Fish>().withinSightBug = true;
					}
					Debug.LogError("LineOfSight hack");
					return targetObject;
				}
			}
			return null;
		}

		public static GameObject LineOfSight(Transform transform, Vector3 positionOffset, GameObject targetObject, Vector3 targetOffset, bool usePhysics2D, int ignoreLayerMask)
		{
			bool flag = transform.GetComponent<Fish>() == Fish.ticket;
			RaycastHit hitInfo;
			if (usePhysics2D)
			{
				RaycastHit2D raycastHit2D;
				if ((bool)(raycastHit2D = Physics2D.Linecast(transform.TransformPoint(positionOffset), targetObject.transform.TransformPoint(targetOffset), ~ignoreLayerMask)) && raycastHit2D.transform.Equals(targetObject))
				{
					return targetObject;
				}
			}
			else if (Physics.Linecast(transform.TransformPoint(positionOffset), targetObject.transform.TransformPoint(targetOffset), out hitInfo, ~ignoreLayerMask))
			{
				if (hitInfo.transform.Equals(targetObject.transform) || targetObject.transform.IsChildOf(hitInfo.transform))
				{
					return targetObject;
				}
				if ((bool)hitInfo.transform)
				{
					if (flag)
					{
						Debug.Log("LineOfSight " + hitInfo.transform.name);
					}
				}
				else if (flag)
				{
					Debug.Log("LineOfSight null");
				}
			}
			return null;
		}

		public static GameObject WithinHearingRange(Transform transform, Vector3 positionOffset, float audibilityThreshold, float hearingRadius, LayerMask objectLayerMask)
		{
			GameObject result = null;
			Collider[] array = Physics.OverlapSphere(transform.TransformPoint(positionOffset), hearingRadius, objectLayerMask);
			if (array != null)
			{
				float num = 0f;
				for (int i = 0; i < array.Length; i++)
				{
					float audibility = 0f;
					GameObject gameObject;
					if ((gameObject = WithinHearingRange(transform, positionOffset, audibilityThreshold, array[i].gameObject, ref audibility)) != null && audibility > num)
					{
						num = audibility;
						result = gameObject;
					}
				}
			}
			return result;
		}

		public static GameObject WithinHearingRange2D(Transform transform, Vector3 positionOffset, float audibilityThreshold, float hearingRadius, LayerMask objectLayerMask)
		{
			GameObject result = null;
			Collider2D[] array = Physics2D.OverlapCircleAll(transform.TransformPoint(positionOffset), hearingRadius, objectLayerMask);
			if (array != null)
			{
				float num = 0f;
				for (int i = 0; i < array.Length; i++)
				{
					float audibility = 0f;
					GameObject gameObject;
					if ((gameObject = WithinHearingRange(transform, positionOffset, audibilityThreshold, array[i].gameObject, ref audibility)) != null && audibility > num)
					{
						num = audibility;
						result = gameObject;
					}
				}
			}
			return result;
		}

		public static GameObject WithinHearingRange(Transform transform, Vector3 positionOffset, float audibilityThreshold, GameObject targetObject)
		{
			float audibility = 0f;
			return WithinHearingRange(transform, positionOffset, audibilityThreshold, targetObject, ref audibility);
		}

		private static GameObject WithinHearingRange(Transform transform, Vector3 positionOffset, float audibilityThreshold, GameObject targetObject, ref float audibility)
		{
			AudioSource[] audioSources;
			if ((audioSources = GetAudioSources(targetObject)) != null)
			{
				for (int i = 0; i < audioSources.Length; i++)
				{
					if (audioSources[i].isPlaying)
					{
						float num = Vector3.Distance(transform.position, targetObject.transform.position);
						if (audioSources[i].rolloffMode == AudioRolloffMode.Logarithmic)
						{
							audibility = audioSources[i].volume / Mathf.Max(audioSources[i].minDistance, num - audioSources[i].minDistance);
						}
						else
						{
							audibility = audioSources[i].volume * Mathf.Clamp01((num - audioSources[i].minDistance) / (audioSources[i].maxDistance - audioSources[i].minDistance));
						}
						if (audibility > audibilityThreshold)
						{
							return targetObject;
						}
					}
				}
			}
			return null;
		}

		public static void DrawLineOfSight(Transform transform, Vector3 positionOffset, float fieldOfViewAngle, float viewDistance, bool usePhysics2D)
		{
		}

		private static AudioSource[] GetAudioSources(GameObject target)
		{
			if (transformAudioSourceMap == null)
			{
				transformAudioSourceMap = new Dictionary<GameObject, AudioSource[]>();
			}
			AudioSource[] value;
			if (transformAudioSourceMap.TryGetValue(target, out value))
			{
				return value;
			}
			value = target.GetComponentsInChildren<AudioSource>();
			transformAudioSourceMap.Add(target, value);
			return value;
		}
	}
}