using System;
using System.Collections.Generic;
using FlaxEngine;
using System.Diagnostics;
using System.Threading.Tasks;
using FlaxEngine.Assertions;
using Console = Cabrito.Console;
using Object = FlaxEngine.Object;

namespace Game
{
	public struct TraceInfo
	{
		public RayCastHit[] hitInfos;
		public bool startSolid;

		// closest hit
		public float fraction;
		public Vector3 endPosition;
		public Vector3 hitNormal;
		public Vector3 hitPosition;

		// furthest hit
		//public float maxFraction;
		//public Vector3 maxHitNormal;
		//public Vector3 maxEndPosition;
	}

	public class PlayerMovement : Script
	{
		[Limit(0, 9000), Tooltip("Base Movement speed")]
		public float MoveSpeed { get; set; } = 320;

		private float viewPitch;
		private float viewYaw;
		private float viewRoll;

		private InputEvent onExit = new InputEvent("Exit");

		private const float collisionMargin = 0.031f * 1.666f;
		private const float slopeNormal = 0.7f;

		Actor rootActor;
		private RigidBody rigidBody;

		public override void OnAwake()
		{
			base.OnAwake();

			onExit.Triggered += () =>
			{
				if (Console.IsSafeToQuit)
					Engine.RequestExit();
			};

			rootActor = Actor.GetChild(0);

			rigidBody = Actor.As<RigidBody>();
			//rigidBody.CollisionEnter += OnCollisionEnter;
			//rigidBody.TriggerEnter += OnTriggerEnter;
			//rigidBody.TriggerExit += OnTriggerExit;
		}

		private List<PhysicsColliderActor> touchingActors = new List<PhysicsColliderActor>();

		private void OnTriggerEnter(PhysicsColliderActor colliderActor)
		{
			//if (colliderActor.AttachedRigidBody == null)
			//    return;
			touchingActors.Add(colliderActor);
			Console.Print("trogger: ");
		}

		private void OnTriggerExit(PhysicsColliderActor colliderActor)
		{
			//if (colliderActor.AttachedRigidBody == null)
			//    return;

			touchingActors.Remove(colliderActor);
			Console.Print("untrogger: ");
		}

		private void OnCollisionEnter(Collision collision)
		{
			//Console.Print("collision: ");
		}

		public override void OnDestroy()
		{
			base.OnDestroy();

			onExit.Dispose();
		}

		public override void OnStart()
		{
			var initialEulerAngles = Actor.Orientation.EulerAngles;
			viewPitch = initialEulerAngles.X;
			viewYaw = initialEulerAngles.Y;
			viewRoll = initialEulerAngles.Z;
		}

		/// <summary>
		/// Sweeps the player rigidbody in world and returns geometry which was hit during the trace.
		/// </summary>
		/// <param name="start">Start position</param>
		/// <param name="end">End position</param>
		/// <returns></returns>
		private TraceInfo TracePlayer(Vector3 start, Vector3 end)
		{
			TraceInfo traceInfo = new TraceInfo();

			Vector3 delta = end - start;
			float maxDistance = delta.Length;
			Vector3 direction = delta.Normalized;

			bool collided = false;
			var capsuleCollider = Actor.GetChild<CapsuleCollider>();
			var boxCollider = Actor.GetChild<BoxCollider>();
			var meshCollider = Actor.GetChild<MeshCollider>();
			PhysicsColliderActor colliderActor = null;
			if (capsuleCollider && capsuleCollider.IsActive)
			{
				colliderActor = capsuleCollider;
				collided = Physics.CapsuleCastAll(start,
					capsuleCollider.Radius, capsuleCollider.Height,
					direction, out traceInfo.hitInfos, capsuleCollider.Orientation, maxDistance,
					uint.MaxValue,
					false);
			}
			else if (meshCollider && meshCollider.IsActive)
			{
				colliderActor = meshCollider;
				collided = Physics.ConvexCastAll(start,
					meshCollider.CollisionData, meshCollider.Scale,
					direction, out traceInfo.hitInfos, meshCollider.Orientation, maxDistance,
					uint.MaxValue,
					false);
			}
			else if (boxCollider && boxCollider.IsActive)
			{
				colliderActor = boxCollider;
				collided = Physics.BoxCastAll(start,
					boxCollider.OrientedBox.Extents,
					direction, out traceInfo.hitInfos, boxCollider.Orientation, maxDistance, uint.MaxValue,
					false);
			}

			if (collided)
			{
				List<RayCastHit> hitInfosFiltered = new List<RayCastHit>();
				RayCastHit closest = new RayCastHit();
				closest.Distance = float.MaxValue;
				foreach (var hitInfo in traceInfo.hitInfos)
				{
					if (hitInfo.Collider == colliderActor)
						continue;

					hitInfosFiltered.Add(hitInfo);

					if (hitInfo.Distance < closest.Distance && hitInfo.Distance != 0.0f)
						closest = hitInfo;
				}

				if (hitInfosFiltered.Count == 0)
					collided = false; // self-collision?
				else //if (closest.Distance > 0f)
				{
					if (closest.Distance == float.MaxValue)
					{
						foreach (var hitInfo in hitInfosFiltered)
						{
							if (hitInfo.Distance < closest.Distance)
								closest = hitInfo;
						}
					}

					traceInfo.hitInfos = hitInfosFiltered.ToArray();

					traceInfo.fraction = closest.Distance / maxDistance;
					traceInfo.hitNormal = closest.Normal;
					traceInfo.hitPosition = closest.Point;
					traceInfo.endPosition = start + (delta * traceInfo.fraction);

					if (traceInfo.fraction == 0f && maxDistance > 0f)
						traceInfo.startSolid = true;
				}
				/*else
				{
				    traceInfo.startSolid = true;
				    traceInfo.fraction = 0f;
				}*/
			}

			if (!collided)
			{
				traceInfo.hitInfos = new RayCastHit[0];
				traceInfo.fraction = 1f;
				traceInfo.endPosition = end;
			}

			return traceInfo;
		}

		public override void OnDebugDraw()
		{
			base.OnDebugDraw();

			var capsuleCollider = Actor.GetChild<CapsuleCollider>();
			var boxCollider = Actor.GetChild<BoxCollider>();
			var meshCollider = Actor.GetChild<MeshCollider>();
			if (capsuleCollider && capsuleCollider.IsActive)
			{
				Quaternion rotation = capsuleCollider.LocalOrientation * Quaternion.Euler(0f, 90f, 0f);
				DebugDraw.DrawWireTube(capsuleCollider.Position, rotation, capsuleCollider.Radius,
					capsuleCollider.Height, Color.GreenYellow * 0.8f);
			}
			else if (meshCollider && meshCollider.IsActive)
			{
				//Quaternion rotation = meshCollider.LocalOrientation * Quaternion.Euler(0f, 90f, 0f);
				DebugDraw.DrawWireCylinder(meshCollider.Position, meshCollider.Orientation, capsuleCollider.Radius,
					capsuleCollider.Height + capsuleCollider.Radius * 2, Color.GreenYellow * 0.8f);
				//DebugDraw.DrawWireTube(meshCollider.Position, rotation, meshCollider.Radius, meshCollider.Height, Color.GreenYellow * 0.8f);
			}
			else if (boxCollider && boxCollider.IsActive)
			{
				DebugDraw.DrawWireBox(boxCollider.OrientedBox.GetBoundingBox(), Color.GreenYellow * 0.8f);
			}
		}

		private SlideMoveHit StepSlideMove(ref Vector3 position, ref Vector3 velocity, bool onGround)
		{
			if (velocity.IsZero)
				return SlideMoveHit.Nothing;

			Vector3 originalPosition = position;
			Vector3 originalVelocity = velocity;

			SlideMoveHit slideMoveHit = SlideMove(ref position, ref velocity);
			if (slideMoveHit == SlideMoveHit.Nothing)
			{
				// TODO: step down here
				return slideMoveHit;
			}

			// hit something, try to step up
			if (onGround)
			{
				Vector3 stepDelta = -Physics.Gravity.Normalized * stepSize;

				Vector3 slidePosition = position;
				Vector3 slideVelocity = velocity;
				position = originalPosition;
				velocity = originalVelocity;

				// step up
				Vector3 stepUp = position + stepDelta;
				TraceInfo traceUp = TracePlayer(position, stepUp);
				if (traceUp.fraction > 0f)
					position = traceUp.endPosition;

				// try moving from step up position
				SlideMoveHit slideMoveStepHit = SlideMove(ref position, ref velocity);

				// step down
				Vector3 stepDown = position - stepDelta;
				TraceInfo traceDown = TracePlayer(position, stepDown);
				if (traceDown.fraction < 1f && -Vector3.Dot(Physics.Gravity.Normalized, traceDown.hitNormal) < slopeNormal)
				{
					// can't step down, slide move like normally
					Console.Print("no stepping 1, frac: " + traceDown.fraction + ", dot: " +
					              (-Vector3.Dot(Physics.Gravity.Normalized, traceDown.hitNormal)) +
					              ", norm: " + traceDown.hitNormal);
					position = slidePosition;
					velocity = slideVelocity;
					return slideMoveHit;
				}
				else if (traceDown.fraction > 0f)
					position = traceDown.endPosition;

				// add some margin from the ground in order to avoid getting stuck
				if (traceDown.fraction < 1f)
					position.Y += collisionMargin;

				// ??
				var d1 = -Vector3.Dot(Physics.Gravity.Normalized, position);
				var d2 = -Vector3.Dot(Physics.Gravity.Normalized, originalPosition);
				if (d1 < d2)
				{
					Console.Print("no stepping 2, " + d1 + " < " + d2);
					position = slidePosition;
					velocity = slideVelocity;
					return slideMoveHit;
				}

				Vector3 slidePosition2 = slidePosition; //down
				Vector3 stepPosition2 = position; //up

				// FIXME, negate gravity
				slidePosition2.Y = 0f;
				stepPosition2.Y = 0f;

				// take the slide movement results if furthest away from original position
				//if ((stepPosition2 - originalPosition).Length < (slidePosition2 - originalPosition).Length)
				if ((slidePosition2 - originalPosition).Length >= (stepPosition2 - originalPosition).Length)
				{
					Console.Print("no stepping 3");
					position = slidePosition;
					velocity = slideVelocity;
					return slideMoveHit;
				}

				slideMoveHit = slideMoveStepHit;
			}

			return slideMoveHit;
		}

		[Flags]
		enum SlideMoveHit
		{
			Nothing = 0,
			Step = 1,
			Floor = 2,
			Other = 4,
		}

		private SlideMoveHit SlideMove(ref Vector3 position, ref Vector3 velocity)
		{
			if (velocity.IsZero)
				return SlideMoveHit.Nothing;

			Vector3 originalPosition = position;
			Vector3 originalVelocity = velocity;
			SlideMoveHit slideMoveHit = SlideMoveHit.Nothing;

			float timeleft = Time.DeltaTime;

			List<Vector3> hitNormals = new List<Vector3>();

			for (int bump = 0; bump < 4; bump++)
			{
				Vector3 startPos = position;
				Vector3 endPos = position + (velocity * timeleft);

				TraceInfo trace = TracePlayer(startPos, endPos);
				// TODO: handle portals here

				float fraction = trace.fraction;
				Vector3 hitNormal = trace.hitNormal;

				if (trace.startSolid)
				{
					velocity = Vector3.Zero;
					break;
				}

				if (fraction > 0f)
				{
					position = trace.endPosition;
					hitNormals.Clear(); // this is present in some forks, not in Q3
				}

				if (fraction >= 1f)
					break;

				timeleft *= 1.0f - fraction;

				if (trace.hitNormal.Y > slopeNormal)
					slideMoveHit |= SlideMoveHit.Floor;
				else if (Math.Abs(trace.hitNormal.Y) < 0.0001f)
					slideMoveHit |= SlideMoveHit.Step;
				else
					slideMoveHit |= SlideMoveHit.Other;

				// this doesn't seem to do anything, we never have any hitNormals stored here
				bool hitPreviousNormal = false;
				foreach (Vector3 normal in hitNormals)
				{
					if (Vector3.Dot(hitNormal, normal) > 0.99)
					{
						// nudge away from the same wall we hit earlier and try again
						velocity += hitNormal;
						hitPreviousNormal = true;
						break;
					}
				}

				if (hitPreviousNormal)
					continue;

				hitNormals.Add(hitNormal);
				if (hitNormals.Count != 1)
					Console.Print("hitNormals: " + hitNormals.Count);

				int plane;
				Vector3 normalMargin = Vector3.Zero;
				for (plane = 0; plane < hitNormals.Count; plane++)
				{
					Vector3 normal = hitNormals[plane];

					// clip velocity
					velocity -= normal * Vector3.Dot(velocity, normal);
					//velocity = Vector3.ProjectOnPlane(velocity, normal);

					//traceOffset = normal * 1f;
					normalMargin += normal;
					//position += normal * 0.031f;

					int plane2;
					for (plane2 = 0; plane2 < hitNormals.Count; plane2++)
					{
						if (plane == plane2)
							continue;

						if (Vector3.Dot(velocity, hitNormals[plane2]) < 0f)
							break;
					}

					if (plane2 == hitNormals.Count)
						break;
				}

				// push off slightly away from the walls to not get stuck
				position += normalMargin.Normalized * collisionMargin;

				if (plane == hitNormals.Count)
				{
					if (hitNormals.Count == 2)
					{
						Vector3 dir = Vector3.Cross(hitNormals[0], hitNormals[1]);
						//dir.Normalize();
						float dist = Vector3.Dot(dir, velocity);
						velocity = dist * dir;
					}
					else
					{
						velocity = Vector3.Zero;
						break;
					}
				}
				else
				{
					// nudge very slightly away from the wall to avoid getting stuck
					//position += trace.hitNormal * 0.01f;
					//velocity += trace.hitNormal * 0.01f;
				}

				// prevents bouncing against the wall
				if ( /*velocity.Length > 0f && */Vector3.Dot(velocity, originalVelocity) <= 0f)
				{
					velocity = Vector3.Zero;
					break;
				}
			}

			return slideMoveHit;
		}

		public override void OnUpdate()
		{
			float xAxis = InputManager.GetAxisRaw("Mouse X");
			float yAxis = InputManager.GetAxisRaw("Mouse Y");
			if (xAxis != 0.0f || yAxis != 0.0f)
			{
				var camera = rootActor.GetChild<Camera>();

				viewPitch += yAxis;
				viewYaw += xAxis;

				viewPitch = Mathf.Clamp(viewPitch, -90.0f, 90.0f);

				// root orientation must be set first
				rootActor.Orientation = Quaternion.Euler(0, viewYaw, 0);
				camera.Orientation = Quaternion.Euler(viewPitch, viewYaw, viewRoll);
			}
		}

		[ReadOnly] public bool onGround = false;

		private const float friction = 4f;
		private const float stopspeed = 100f;
		private const float accelerationGround = 10f;
		private const float jumpVelocity = 270f;

		private const float maxAirSpeed = 320f;
		private const float maxAirStrafeSpeed = 30f; //Q2+
		private const float airAcceleration = 0.4f * 0f; //Q2+
		private const float airStopAcceleration = 2.5f * 0f; //Q2+
		private const float airStrafeAcceleration = 70f * 0f; //CPM?
		private const float strafeAcceleration = 10f; //QW
		private const float airControl = 0f; //CPM
		private const float stepSize = 16f;
		//private bool physicsInteractions = false;

		private bool jumped = false;

		private Vector3 safePosition;

		[ReadOnly]
		public float CurrentVelocity
		{
			get { return currentVelocity.Length; }
			set { }
		}

		[ReadOnly]
		public float UPS
		{
			get
			{
				Vector3 horizontalSpeed = currentVelocity;
				horizontalSpeed.Y = 0f;
				return horizontalSpeed.Length;
			}
			set { }
		}

		private Vector3 currentVelocity;

		public override void OnFixedUpdate()
		{
			Transform rootTrans = rootActor.Transform;

			Vector3 inputDirection =
				new Vector3(InputManager.GetAxis("Horizontal"), 0.0f, InputManager.GetAxis("Vertical"));
			Vector3 moveDirection = rootTrans.TransformDirection(inputDirection);

			Vector3 position = rigidBody.Position;
			Vector3 velocity = currentVelocity; //rigidBody.LinearVelocity;

			Vector3 wishVelocity = Vector3.Zero;
			if (!inputDirection.IsZero)
				wishVelocity = moveDirection.Normalized * MoveSpeed;

			// categorize position
			onGround = true;
			Vector3 groundDelta = Physics.Gravity.Normalized * (collisionMargin * 2);
			TraceInfo traceGround = TracePlayer(position, position + groundDelta);

			if (!traceGround.startSolid && traceGround.fraction < 1f &&
			    -Vector3.Dot(Physics.Gravity.Normalized, traceGround.hitNormal) < slopeNormal)
			{
				// slope
				// clip velocity
				Vector3 bounce = groundDelta;
				//Vector3 velocityProjected = Vector3.ProjectOnPlane(velocity, normal);
				float backoff = Vector3.Dot(bounce, traceGround.hitNormal) * 2f;
				bounce -= traceGround.hitNormal * backoff;
				//velocity = velocityProjected;

				Vector3 point = (position + groundDelta) +
				                (1f - traceGround.fraction) * bounce;

				// retrace
				traceGround = TracePlayer(position, position + point);
			}

			if (!traceGround.startSolid && (traceGround.fraction >= 1f ||
			                                -Vector3.Dot(Physics.Gravity.Normalized, traceGround.hitNormal) < slopeNormal))
			{
				// falling or sliding down a slope
				onGround = false;
			}
			else
			{
				onGround = !traceGround.startSolid;
			}

			// TODO: snap to ground here

			// jump
			if (onGround)
			{
				if (!jumped && InputManager.GetAction("Jump"))
				{
					// reset velocity from gravity
					if (-Vector3.Dot(Physics.Gravity.Normalized, velocity) < 0 &&
					    Vector3.Dot(velocity, traceGround.hitNormal) < -0.1)
					{
						velocity = Vector3.ProjectOnPlane(velocity, traceGround.hitNormal);
					}

					velocity += Vector3.Up * jumpVelocity;
					onGround = false;

					Guid jumpguid;
					FlaxEngine.Json.JsonSerializer.ParseID("1ef4565844a4b36cdfda54b51f338c77", out jumpguid);
					AudioClip jumpAsset = AudioClip.Find<AudioClip>(ref jumpguid);
					if (jumpAsset != null && jumpAsset.IsLoaded)
					{
						var audioSource = new AudioSource();
						audioSource.Clip = jumpAsset;
						audioSource.Position = rootActor.Position; //new Vector3(-350, 176, 61);//rootActor.Position;
						audioSource.Parent = Actor.Parent;


						audioSource.Play();
						Destroy(audioSource, jumpAsset.Length);
						Console.Print("jumping sound!");
					}
					else if (jumpAsset == null)
						Console.Print("jumpAsset not found");
					else
						Console.Print("jumpAsset not loaded");
				}
				else if (jumped) // jump released
					jumped = false;
			}

			// ground friction
			if (onGround)
			{
				float currentSpeed = velocity.Length;

				float control = currentSpeed < stopspeed ? stopspeed : currentSpeed;
				var drop = control * friction * Time.DeltaTime;

				float newspeed = currentSpeed - drop;
				if (newspeed < 0)
					newspeed = 0;

				if (currentSpeed < 0.0001f)
					velocity *= 0;
				else
					velocity *= newspeed / currentSpeed;
			}

			if (onGround) // ground acceleration
			{
				ApplyAcceleration(ref velocity, wishVelocity.Normalized, wishVelocity.Length, float.MaxValue,
					accelerationGround);
			}
			else // air acceleration
			{
				var wishspeed = wishVelocity.Length;
				if (wishspeed > maxAirSpeed)
					wishspeed = maxAirSpeed;

				if (strafeAcceleration != 0f)
					ApplyAcceleration(ref velocity, wishVelocity.Normalized, wishspeed, maxAirStrafeSpeed,
						strafeAcceleration);
			}

			if (!onGround)
				velocity += Physics.Gravity * Time.DeltaTime;

			safePosition = rigidBody.Position;
			currentVelocity = velocity;
			if (!rigidBody.IsKinematic)
				rigidBody.LinearVelocity = velocity;
			else
			{
				StepSlideMove(ref position, ref velocity, onGround);

				rigidBody.Position = position;
				currentVelocity = velocity;
				//rigidBody.LinearVelocity = velocity;
			}
		}

		void ApplyAcceleration(ref Vector3 velocity, Vector3 wishDir, float wishspeed, float maxWishspeed,
			float acceleration)
		{
			float wishspeedOrig = wishspeed;
			if (wishspeed > maxWishspeed)
				wishspeed = maxWishspeed;

			float currentSpeed = Vector3.Dot(velocity, wishDir);
			float addSpeed = wishspeed - currentSpeed;
			if (addSpeed <= 0f)
				return;

			float accelSpeed = acceleration * wishspeedOrig * Time.DeltaTime;
			if (accelSpeed > addSpeed)
				accelSpeed = addSpeed;

			velocity += accelSpeed * wishDir;
		}
	}
}