import "system/player_input.modifier.api" for API, Modifier, APIGet, APISet, Wire, Fields, State, Op
import "luxe: io" for IO
import "luxe: assets" for Strings
import "luxe: input" for Input
import "luxe: world" for Entity, World, Transform
import "luxe: math" for Math
import "luxe.project/asset" for Asset
import "luxe: system/physics/character3D.modifier" for Character3D
import "luxe: system/physics/physics3D.modifier" for Physics3D

#block = data
class Data {
  var acceleration: Num = 1.0
  var decelleration: Num = 0.5
  var speed_run: Num = 25.0
  var speed_walk: Num = 15.0
  var ground_check_dist: Num = 0
  var jump_impulse: Num = 20
  var jump_grace_time: Num = 0.1

  #hidden
  var input_target: Float3 = [0, 0, 0]

  #hidden
  var target_speed: Num = 0

  #hidden
  var time_since_grounded: Num = 0

  #hidden
  var is_grounded: Bool = false

  #hidden
  var movement_active: Bool = true
}

#api
#display = "Player Input"
#desc = "**A new modifier**. You should update this description" 
#icon = "luxe: image/modifier/modifier.svg"
class PlayerInput is API {
  //add public facing API here
}

#system
#phase(on, tick)
class System is Modifier {
	EPSILON { 0.001 }

	//required atm
	construct new(world: World) { super(world) }

	init(world: World) {
		Log.print("init `%(This)` in world `%(world)`")

		_camera = Entity.get_named(world, "app.camera")
		_world = world
	}

	#hidden
	attach(player: Entity, data: Data) {
		if (!Character3D.has(player)) return
		Character3D.set.speed(player, data.speed_walk)
		data.target_speed = data.speed_walk
	}
 
	#hidden
	tick(delta: Num) {
		each {|player: Entity, data: Data|
			if (!Character3D.has(player)) return

			// Update grounded state
			var now_grounded = check_grounded(player, data)

			if (data.is_grounded && !now_grounded && data.time_since_grounded < data.jump_grace_time) {
				data.time_since_grounded = data.time_since_grounded + delta

				if (data.time_since_grounded >= data.jump_grace_time) {
					data.is_grounded = false
				}
			}
			
			if (!data.is_grounded && now_grounded && Character3D.get.velocity(player).y <= 0) {
				data.is_grounded = true
			}

			// Get player's movement input
			var fore = Input.event_active("up", "game") ? -1 : 0
			var back = Input.event_active("down", "game") ? 1 : 0
			var left = Input.event_active("left", "game") ? -1 : 0
			var right = Input.event_active("right", "game") ? 1 : 0

			// Turn this into a Float3 of (Left/Right, 0, Forward/Backward) that is relative to the player's facing direction
			data.input_target = Math.normalized(Math.mult(Transform.local_dir_to_world(_camera, right + left, 0, fore + back), [1, 0, 1]))
			data.input_target = move_toward_vec(Character3D.get.input(player), data.input_target, data, delta * 6)

			if (data.is_grounded) Character3D.set.speed(player, Input.event_active("run", "game") ? data.speed_run : data.speed_walk)

			if (Input.event_began("jump", "game") && data.is_grounded) {
				data.time_since_grounded = 0
				data.input_target = Math.add(data.input_target, [0, data.jump_impulse / Character3D.get.speed(player), 0])
				data.is_grounded = false

				Transform.translate(player, 0, data.ground_check_dist + this.EPSILON, 0)
			} else {
				data.input_target = [data.input_target.x, 0, data.input_target.z]
			}
			
			Character3D.set.input(player, data.input_target)
		}
	}

	check_grounded(player: Entity, data: Data): Bool {
		var height = Character3D.get.height(player) * 0.5
		return Physics3D.cast_ray_closest(_world, Transform.get_pos_world(player), [0,-1,0], height + data.ground_check_dist) != null
	}

	move_toward_num(from: Num, to: Num, data: Data, delta: Num) {
		if (from < to) {
			return Math.min(Math.lerp(from, to, delta * data.acceleration), to)
		} else if (from > to) {
			return Math.max(Math.lerp(from, to, delta * data.decelleration), to)
		}
	}

	move_toward_vec(from: Float3, to: Float3, data: Data, delta: Num) {
		var pos_delta: Float3 = Math.sub(to, from)
		var pos_len: Num = Math.length(pos_delta)
		var speed = Math.length(from) < Math.length(to) ? delta * data.acceleration : delta * data.decelleration
		return pos_len <= delta || pos_len < this.EPSILON ? to : Math.add(from, Math.scale(Math.div(pos_delta, pos_len), speed))
	}

}