#if MODULE_ENTITIES
using Unity.Entities;
using Unity.Mathematics;

namespace Pathfinding.ECS {
	/// <summary>
	/// Policy for how often to recalculate an agent's path.
	///
	/// See: <see cref="FollowerEntity.autoRepath"/>
	///
	/// This is the unmanaged equivalent of <see cref="Pathfinding.AutoRepathPolicy"/>.
	/// </summary>
	[System.Serializable]
	public struct AutoRepathPolicy : IComponentData {
		/// <summary>
		/// How sensitive the agent should be to changes in its destination for Mode.Dynamic.
		/// A higher value means the destination has to move less for the path to be recalculated.
		///
		/// See: <see cref="AutoRepathPolicy.Mode"/>
		/// </summary>
		public const float Sensitivity = 10.0f;

		/// <summary>
		/// Policy to use when recalculating paths.
		///
		/// See: <see cref="Pathfinding.AutoRepathPolicy.Mode"/> for more details.
		/// </summary>
		public Pathfinding.AutoRepathPolicy.Mode mode;

		/// <summary>Number of seconds between each automatic path recalculation for Mode.EveryNSeconds, and the maximum interval for Mode.Dynamic</summary>
		public float period;

		float3 lastDestination;
		float lastRepathTime;

		public static AutoRepathPolicy Default => new AutoRepathPolicy {
			mode = Pathfinding.AutoRepathPolicy.Mode.Dynamic,
			period = 2,
			lastDestination = float.PositiveInfinity,
			lastRepathTime = float.NegativeInfinity
		};

		public AutoRepathPolicy (Pathfinding.AutoRepathPolicy policy) {
			mode = policy.mode;
			period = policy.mode == Pathfinding.AutoRepathPolicy.Mode.Dynamic ? policy.maximumPeriod : policy.period;
			lastDestination = float.PositiveInfinity;
			lastRepathTime = float.NegativeInfinity;
		}

		/// <summary>
		/// True if the path should be recalculated according to the policy
		///
		/// The above parameters are relevant only if <see cref="mode"/> is <see cref="Mode.Dynamic"/>.
		/// </summary>
		/// <param name="position">The current position of the agent.</param>
		/// <param name="radius">The radius of the agent. You may pass 0.0 if the agent doesn't have a radius.</param>
		/// <param name="destination">The goal of the agent right now</param>
		/// <param name="time">The current time in seconds</param>
		public bool ShouldRecalculatePath (float3 position, float radius, float3 destination, float time) {
			if (mode == Pathfinding.AutoRepathPolicy.Mode.Never || float.IsPositiveInfinity(destination.x)) return false;

			float timeSinceLast = time - lastRepathTime;
			if (mode == Pathfinding.AutoRepathPolicy.Mode.EveryNSeconds) {
				return timeSinceLast >= period;
			} else {
				// cost = change in destination / max(distance to destination, radius)
				float squaredCost = math.lengthsq(destination - lastDestination) / math.max(math.lengthsq(position - lastDestination), radius*radius);
				float fraction = squaredCost * (Sensitivity*Sensitivity);
				if (float.IsNaN(fraction)) {
					// The agent's radius is zero, and the destination is precisely at the agent's position, which is also the destination of the last calculated path
					// This is a special case. It happens sometimes for the AILerp component when it reaches its
					// destination, as the AILerp component has no radius.
					// In this case we just use the maximum period.
					fraction = 0;
				}

				return timeSinceLast >= period*(1 - math.sqrt(fraction));
			}
		}

		public void Reset () {
			lastDestination = float.PositiveInfinity;
			lastRepathTime = float.NegativeInfinity;
		}

		/// <summary>Must be called when a path request has been scheduled</summary>
		public void DidRecalculatePath (float3 destination, float time) {
			lastRepathTime = time;
			lastDestination = destination;
			// Randomize the repath time slightly so that all agents don't request a path at the same time
			// in the future. This is useful when there are a lot of agents instantiated at exactly the same time.
			const float JITTER_AMOUNT = 0.3f;
			lastRepathTime -= (UnityEngine.Random.value - 0.5f) * JITTER_AMOUNT * period;
		}
	}
}
#endif