#nullable enable
using NaughtyAttributes;
using UnityEngine;
using UnityEngine.InputSystem;

[RequireComponent(typeof(PlayerInput), typeof(Rigidbody2D))]
public class PlayerMovement : MonoBehaviour {
	[SerializeField] [field: Required]
	PlayerStats stats = null!;
	[field: Required]
	Rigidbody2D rb = null!;
	
	Vector2 moveDirection;
	BaseState currentState = new ImmobileMovementState();
	SafeZone? safeZone;

	bool lastJumpButton;

	void Awake() => rb = GetComponent<Rigidbody2D>();

	void Start() => currentState.EnterState(this);

	void Update() {
		if (currentState.UpdateState(this) is {} newState)
			SwitchState(newState);
	}

	void FixedUpdate() {
		if (currentState.FixedUpdateState(this) is {} newState)
			SwitchState(newState);
	}

	void OnDrawGizmos() => currentState.OnDrawGizmos(this);

	public void OnMove(InputAction.CallbackContext ctx) {
		moveDirection = ctx.ReadValue<Vector2>();
		if (moveDirection.sqrMagnitude > 1.0f)
			moveDirection.Normalize();
	}

	public void OnJump(InputAction.CallbackContext ctx) {
		//feels pretty redundant ^^'
		bool newValue = ctx.ReadValueAsButton();
		bool wasJustPressed = !lastJumpButton && newValue;
		lastJumpButton = newValue;

		if (!wasJustPressed)
			return;
		
		if (safeZone == null)
			return;

		if (safeZone.IsInSafeZone) {
			if (moveDirection.magnitude >= safeZone.Stats.MinJumpJoystickValue)
				SwitchState(new ExitSafeZoneMovementState(safeZone, moveDirection));
		} else //TODO if (AngleBetween(moveDirection, toSafeZone) < 90)
			SwitchState(new EnterSafeZoneMovementState(safeZone));
	}

	void SwitchState(BaseState newState) {
		currentState.LeaveState(this);
		currentState = newState;
		newState.EnterState(this);
	}

	void OnTriggerEnter2D(Collider2D other) {
		if (other.GetComponent<SafeZone>() is {} triggeredSafeZone)
			safeZone = triggeredSafeZone;
	}

	//Probably should remove, mostly for ImmobileState's draw gizmos
	void OnTriggerStay2D(Collider2D other) {
		if (other.GetComponent<SafeZone>() is {} triggeredSafeZone)
			safeZone = triggeredSafeZone;
	}

	void OnTriggerExit2D(Collider2D other) {
		if (other.GetComponent<SafeZone>() is {})
			safeZone = null;
	}

	void SetRigidbodyEnabled(bool enabled) {
		rb.velocity = Vector2.zero;
		rb.angularVelocity = 0f;
		rb.isKinematic = !enabled;
	}

	class BaseState {
		public virtual void EnterState(PlayerMovement playerMovement) {}

		public virtual void LeaveState(PlayerMovement playerMovement) {}

		public virtual BaseState? UpdateState(PlayerMovement playerMovement) => null;

		public virtual BaseState? FixedUpdateState(PlayerMovement playerMovement) => null;
		
		public virtual void OnDrawGizmos(PlayerMovement playerMovement) {}
	}

	class NormalMovementState : BaseState {
		public override BaseState? FixedUpdateState(PlayerMovement playerMovement) {
			playerMovement.rb.velocity = (Vector3)playerMovement.moveDirection * playerMovement.stats.movementSpeed;
			
			return null;
		}
	}

	class JumpingMovementState : BaseState {
		readonly float duration;
		readonly Vector3 target;

		Vector3 startPosition;
		float startTime;

		public JumpingMovementState(float duration, Vector3 target) {
			this.duration = duration;
			this.target = target;
		}

		public override void EnterState(PlayerMovement playerMovement) {
			startPosition = playerMovement.transform.position;
			startTime = Time.time;
		}

		public override BaseState? FixedUpdateState(PlayerMovement playerMovement) {
			float currentTime = Time.time - startTime;
			if (currentTime >= duration)
				return Transition();
			
			playerMovement.rb.MovePosition(Vector3.Lerp(
				startPosition,
				target,
				ModifyLerpTime(currentTime / duration)
			));

			return null;
		}

		protected virtual BaseState Transition() => new NormalMovementState();
		protected virtual float ModifyLerpTime(float t) => t;
	}

	class EnterSafeZoneMovementState : JumpingMovementState {
		readonly SafeZone safeZone;
		public EnterSafeZoneMovementState(SafeZone safeZone) : base(safeZone.Stats.JumpDuration, safeZone.transform.position) {
			this.safeZone = safeZone;
		}

		public override void EnterState(PlayerMovement playerMovement) {
			base.EnterState(playerMovement);
			
			safeZone.EnterSafeZone();
			playerMovement.SetRigidbodyEnabled(false);
		}
		
		protected override BaseState Transition() => new ImmobileMovementState();

		protected override float ModifyLerpTime(float t) => safeZone.Stats.JumpSpeedCurve.Evaluate(t);
	}

	class ExitSafeZoneMovementState : JumpingMovementState {
		readonly SafeZone safeZone;
		public ExitSafeZoneMovementState(SafeZone safeZone, Vector2 direction) : base(safeZone.Stats.JumpDuration, safeZone.GetOutsidePosition(direction)) {
			this.safeZone = safeZone;
		}

		public override void LeaveState(PlayerMovement playerMovement) {
			base.EnterState(playerMovement);
			
			safeZone.ExitSafeZone();
			playerMovement.SetRigidbodyEnabled(true);
		}

		protected override float ModifyLerpTime(float t) => safeZone.Stats.JumpSpeedCurve.Evaluate(t);
	}

	class ImmobileMovementState : BaseState {
		public override void EnterState(PlayerMovement playerMovement) {
			base.EnterState(playerMovement);
			
			if (!playerMovement.rb.isKinematic)
				Debug.LogWarning("Rigidbody should probably be kinematic when immobile (when in safe zone).");
		}
#if UNITY_EDITOR
		public override void OnDrawGizmos(PlayerMovement playerMovement) {
			if (playerMovement.safeZone is null)
				return;

			Vector3 dropPosition = playerMovement.safeZone.GetOutsidePosition(playerMovement.moveDirection);
			bool canJump = playerMovement.moveDirection.magnitude >= playerMovement.safeZone.Stats.MinJumpJoystickValue;
			Gizmos.color = canJump ? Color.green : Color.red;
			Gizmos.DrawLine(playerMovement.transform.position, dropPosition);
			if (canJump)
				Gizmos.DrawSphere(dropPosition, .5f);
			else
				Gizmos.DrawWireSphere(dropPosition, .5f);
		}
#endif
	}
}