@tool
@icon("res://addons/godot-xr-tools/editor/icons/function.svg")
class_name XRToolsFunctionTeleport
extends Node3D


## XR Tools Function Teleport Script
##
## This script provides teleport functionality.
##
## Add this scene as a sub scene of your [XRController3D] node to implement
## a teleport function on that controller.


# Default teleport collision mask of all
const DEFAULT_MASK := 0b1111_1111_1111_1111_1111_1111_1111_1111

# Default material
# gdlint:ignore = load-constant-name
const _DefaultMaterial := preload("res://addons/godot-xr-tools/materials/capsule.tres")


## If true, teleporting is enabled
@export var enabled : bool = true: set = set_enabled

## Teleport button action
@export var teleport_button_action : String = "trigger_click"

## Teleport rotation action
@export var rotation_action : String = "primary"

# Teleport Path Group
@export_group("Visuals")

## Teleport allowed color property
@export var can_teleport_color : Color = Color(0.0, 1.0, 0.0, 1.0)

## Teleport denied color property
@export var cant_teleport_color : Color = Color(1.0, 0.0, 0.0, 1.0)

## Teleport no-collision color property
@export var no_collision_color : Color = Color(45.0 / 255.0, 80.0 / 255.0, 220.0 / 255.0, 1.0)

## Teleport-arc strength
@export var strength : float = 5.0

## Teleport texture
@export var arc_texture : Texture2D \
	= preload("res://addons/godot-xr-tools/images/teleport_arrow.png") \
	: set = set_arc_texture

## Target texture
@export var target_texture : Texture2D \
	= preload("res://addons/godot-xr-tools/images/teleport_target.png") \
	: set = set_target_texture

# Player Group
@export_group("Player")

## Player height property
@export var player_height : float = 1.8: set = set_player_height

## Player radius property
@export var player_radius : float = 0.4: set = set_player_radius

## Player scene
@export var player_scene : PackedScene: set = set_player_scene

# Target Group
@export_group("Collision")

## Maximum floor slope
@export var max_slope : float = 20.0

## Collision mask
@export_flags_3d_physics var collision_mask : int = 1023

## Valid teleport layer mask
@export_flags_3d_physics var valid_teleport_mask : int = DEFAULT_MASK


## Player capsule material (ignored for custom player scenes)
var player_material : StandardMaterial3D = _DefaultMaterial :  set = set_player_material


var is_on_floor : bool = true
var is_teleporting : bool = false
var can_teleport : bool = true
var teleport_rotation : float = 0.0;
var floor_normal : Vector3 = Vector3.UP
var last_target_transform : Transform3D = Transform3D()
var collision_shape : Shape3D
var step_size : float = 0.5


# Custom player scene
var player : Node3D


# World scale
@onready var ws : float = XRServer.world_scale

## Capsule shown when not using a custom player mesh
@onready var capsule : MeshInstance3D = $Target/Player_figure/Capsule

## [XRToolsPlayerBody] node.
@onready var player_body := XRToolsPlayerBody.find_instance(self)

## [XRController3D] node.
@onready var controller := XRHelpers.get_xr_controller(self)


# Add support for is_xr_class on XRTools classes
func is_xr_class(name : String) -> bool:
	return name == "XRToolsFunctionTeleport"


# Called when the node enters the scene tree for the first time.
func _ready():
	# Do not initialise if in the editor
	if Engine.is_editor_hint():
		return

	# It's inactive when we start
	$Teleport.visible = false
	$Target.visible = false

	# Scale to our world scale
	$Teleport.mesh.size = Vector2(0.05 * ws, 1.0)
	$Target.mesh.size = Vector2(ws, ws)
	$Target/Player_figure.scale = Vector3(ws, ws, ws)

	# get our capsule shape
	collision_shape = CapsuleShape3D.new()

	# Apply properties
	_update_arc_texture()
	_update_target_texture()
	_update_player_scene()
	_update_player_height()
	_update_player_radius()
	_update_player_material()


func _physics_process(delta):
	# Do not process physics if in the editor
	if Engine.is_editor_hint():
		return

	# Skip if required nodes are missing
	if !player_body or !controller:
		return

	# if we're not enabled no point in doing mode
	if !enabled:
		# reset these
		is_teleporting = false;
		$Teleport.visible = false
		$Target.visible = false

		# and stop this from running until we enable again
		set_physics_process(false)
		return

	# check if our world scale has changed..
	var new_ws := XRServer.world_scale
	if ws != new_ws:
		ws = new_ws
		$Teleport.mesh.size = Vector2(0.05 * ws, 1.0)
		$Target.mesh.size = Vector2(ws, ws)
		$Target/Player_figure.scale = Vector3(ws, ws, ws)

	if controller and controller.get_is_active() and \
			controller.is_button_pressed(teleport_button_action):
		if !is_teleporting:
			is_teleporting = true
			$Teleport.visible = true
			$Target.visible = true
			teleport_rotation = 0.0

		# get our physics engine state
		var state := get_world_3d().direct_space_state
		var query := PhysicsShapeQueryParameters3D.new()

		# init stuff about our query that doesn't change
		query.collision_mask = collision_mask
		query.margin = collision_shape.margin
		query.shape_rid = collision_shape.get_rid()

		# make a transform for offsetting our shape, it's always
		# lying on its side by default...
		var shape_transform := Transform3D(
				Basis(),
				Vector3(0.0, player_height / 2.0, 0.0))

		# update location
		var teleport_global_transform : Transform3D = $Teleport.global_transform
		var target_global_origin := teleport_global_transform.origin
		var up := player_body.up_player
		var down := -up.normalized() / ws

		############################################################
		# New teleport logic
		# We're going to use test move in steps to find out where we hit something...
		# This can be optimised loads by determining the lenght based on the angle
		# between sections extending the length when we're in a flat part of the arch
		# Where we do get a collission we may want to fine tune the collision
		var cast_length := 0.0
		var fine_tune := 1.0
		var hit_something := false
		var max_slope_cos := cos(deg_to_rad(max_slope))
		for i in range(1,26):
			var new_cast_length := cast_length + (step_size / fine_tune)
			var global_target := Vector3(0.0, 0.0, -new_cast_length)

			# our quadratic values
			var t := global_target.z / strength
			var t2 := t * t

			# target to world space
			global_target = teleport_global_transform * global_target

			# adjust for gravity
			global_target += down * t2

			# test our new location for collisions
			query.transform = Transform3D(
				player_body.global_transform.basis,
				global_target) * shape_transform
			var cast_result := state.collide_shape(query, 10)
			if cast_result.is_empty():
				# we didn't collide with anything so check our next section...
				cast_length = new_cast_length
				target_global_origin = global_target
			elif (fine_tune <= 16.0):
				# try again with a small step size
				fine_tune *= 2.0
			else:
				# if we don't collide make sure we keep using our current origin point
				var collided_at := target_global_origin

				# check for collision
				var step_delta := global_target - target_global_origin
				if up.dot(step_delta) > 0:
					# if we're moving up, we hit the ceiling of something, we
					# don't really care what
					is_on_floor = false
				else:
					# now we cast a ray downwards to see if we're on a surface
					var ray_query := PhysicsRayQueryParameters3D.new()
					ray_query.from = target_global_origin + (up * 0.5 * player_height)
					ray_query.to = target_global_origin - (up * 1.1 * player_height)
					ray_query.collision_mask = collision_mask

					var intersects := state.intersect_ray(ray_query)
					if intersects.is_empty():
						is_on_floor = false
					else:
						# did we collide with a floor or a wall?
						floor_normal = intersects["normal"]
						var dot := up.dot(floor_normal)

						if dot > max_slope_cos:
							is_on_floor = true
						else:
							is_on_floor = false

						# Update our collision point if it's moved enough, this
						# solves a little bit of jittering
						var diff : Vector3 = collided_at - intersects["position"]

						if diff.length() > 0.1:
							collided_at = intersects["position"]

						# Fail if the hit target isn't in our valid mask
						var collider_mask : int = intersects["collider"].collision_layer
						if not valid_teleport_mask & collider_mask:
							is_on_floor = false

				# we are colliding, find our if we're colliding on a wall or
				# floor, one we can do, the other nope...
				cast_length += (collided_at - target_global_origin).length()
				target_global_origin = collided_at
				hit_something = true
				break

		# and just update our shader
		$Teleport.get_surface_override_material(0).set_shader_parameter("scale_t", 1.0 / strength)
		$Teleport.get_surface_override_material(0).set_shader_parameter("down", down)
		$Teleport.get_surface_override_material(0).set_shader_parameter("length", cast_length)
		if hit_something:
			var color := can_teleport_color
			var normal := up
			if is_on_floor:
				# if we're on the floor we'll reorientate our target to match.
				normal = floor_normal
				can_teleport = true
			else:
				can_teleport = false
				color = cant_teleport_color

			# check our axis to see if we need to rotate
			teleport_rotation += (delta * controller.get_vector2(rotation_action).x * -4.0)

			# update target and colour
			var target_basis := Basis()
			target_basis.y = normal
			target_basis.x = teleport_global_transform.basis.x.slide(normal).normalized()
			target_basis.z = target_basis.x.cross(target_basis.y)

			target_basis = target_basis.rotated(normal, teleport_rotation)
			last_target_transform.basis = target_basis
			last_target_transform.origin = target_global_origin + up * 0.001
			$Target.global_transform = last_target_transform

			$Teleport.get_surface_override_material(0).set_shader_parameter("mix_color", color)
			$Target.get_surface_override_material(0).albedo_color = color
			$Target.visible = can_teleport
		else:
			can_teleport = false
			$Target.visible = false
			$Teleport.get_surface_override_material(0).set_shader_parameter("mix_color", no_collision_color)
	elif is_teleporting:
		if can_teleport:

			# Make our target using the players up vector
			var new_transform := last_target_transform
			new_transform.basis.y = player_body.up_player
			new_transform.basis.x = new_transform.basis.y.cross(new_transform.basis.z).normalized()
			new_transform.basis.z = new_transform.basis.x.cross(new_transform.basis.y).normalized()

			# Teleport the player
			player_body.teleport(new_transform)

		# and disable
		is_teleporting = false;
		$Teleport.visible = false
		$Target.visible = false


# This method verifies the teleport has a valid configuration.
func _get_configuration_warnings() -> PackedStringArray:
	var warnings := PackedStringArray()

	# Verify we can find the XRToolsPlayerBody
	if !XRToolsPlayerBody.find_instance(self):
		warnings.append("This node must be within a branch of an XRToolsPlayerBody node")

	# Verify we can find the XRController3D
	if !XRHelpers.get_xr_controller(self):
		warnings.append("This node must be within a branch of an XRController3D node")

	# Return warnings
	return warnings


# Provide custom property information
func _get_property_list() -> Array[Dictionary]:
	return [
		{
			"name" : "Player",
			"type" : TYPE_NIL,
			"usage" : PROPERTY_USAGE_GROUP
		},
		{
			"name" : "player_material",
			"class_name" : "StandardMaterial3D",
			"type" : TYPE_OBJECT,
			"usage" : PROPERTY_USAGE_NO_EDITOR if player_scene else PROPERTY_USAGE_DEFAULT,
			"hint" : PROPERTY_HINT_RESOURCE_TYPE,
			"hint_string" : "StandardMaterial3D"
		}
	]


# Allow revert of custom properties
func _property_can_revert(property : StringName) -> bool:
	return property == "player_material"


# Provide revert values for custom properties
func _property_get_revert(property : StringName): # Variant
	if property == "player_material":
		return _DefaultMaterial


# Set enabled property
func set_enabled(new_value : bool) -> void:
	enabled = new_value
	if enabled:
		# make sure our physics process is on
		set_physics_process(true)
	else:
		# we turn this off in physics process just in case we want to do some cleanup
		pass


# Set the arc texture
func set_arc_texture(p_arc_texture : Texture2D) -> void:
	arc_texture = p_arc_texture
	if is_inside_tree():
		_update_arc_texture()


# Set the target texture
func set_target_texture(p_target_texture : Texture2D) -> void:
	target_texture = p_target_texture
	if is_inside_tree():
		_update_target_texture()


# Set player height property
func set_player_height(p_height : float) -> void:
	player_height = p_height
	if is_inside_tree():
		_update_player_height()


# Set player radius property
func set_player_radius(p_radius : float) -> void:
	player_radius = p_radius
	if is_inside_tree():
		_update_player_radius()


# Set the player scene
func set_player_scene(p_player_scene : PackedScene) -> void:
	player_scene = p_player_scene
	notify_property_list_changed()
	if is_inside_tree():
		_update_player_scene()


# Set the player material
func set_player_material(p_player_material : StandardMaterial3D) -> void:
	player_material = p_player_material
	if is_inside_tree():
		_update_player_material()


# Update arc texture
func _update_arc_texture():
	var material : ShaderMaterial = $Teleport.get_surface_override_material(0)
	if material and arc_texture:
		material.set_shader_parameter("arrow_texture", arc_texture)


# Update target texture
func _update_target_texture():
	var material : StandardMaterial3D = $Target.get_surface_override_material(0)
	if material and target_texture:
		material.albedo_texture = target_texture


# Player height update handler
func _update_player_height() -> void:
	if collision_shape:
		collision_shape.height = player_height - (2.0 * player_radius)

	if capsule:
		capsule.mesh.height = player_height
		capsule.position = Vector3(0.0, player_height/2.0, 0.0)


# Player radius update handler
func _update_player_radius():
	if collision_shape:
		collision_shape.height = player_height
		collision_shape.radius = player_radius

	if capsule:
		capsule.mesh.height = player_height
		capsule.mesh.radius = player_radius


# Update the player scene
func _update_player_scene() -> void:
	# Free the current player
	if player:
		player.queue_free()
		player = null

	# If specified, instantiate a new player
	if player_scene:
		player = player_scene.instantiate()
		$Target/Player_figure.add_child(player)

	# Show the capsule mesh only if we have no player
	capsule.visible = player == null


# Update player material
func _update_player_material():
	if player_material:
		capsule.set_surface_override_material(0, player_material)
