extends Node3D

const TIME_MAX := 3000 # msec
const GYROSCOPE_MAX_DIFF := 0.5
const OFFSET_CAMERA_MAX := 0.12
const OFFSET_STEP_CHANGE := 0.01
const RAY_LENGTH := 1000

@export var object_first: PackedScene = load("res://scenes/levels/parts/ObjectListFirst.tscn")
@export var object_std: PackedScene = load("res://scenes/levels/parts/ObjectListStandard.tscn")
@export var object_last: PackedScene = load("res://scenes/levels/parts/ObjectListLast.tscn")

var gyroscope_value_old := Vector3(0, 0, 0)
var meshes: Dictionary[String, SceneEntry] = {}
var from = null
var to = null
var victory_condition: String = "0"
var victory_progress: String = "0"
var last_button: Node = null

func _ready() -> void:
	_load_meshes()
	_load_back_button()
	_load_prepare_victory_condition()
	_load_hud_menu()
	_load_ambient_sound()

func _load_meshes() -> void:
	for scene in Global.database.scenes_for_level(Global.current_scene_int):
		meshes[scene.key] = scene
		create_dissolve_mesh(scene.key)

func _load_back_button() -> void:
	$Quit/TextureButton.pressed.connect(Event._on_main_scene_pressed)

func _load_prepare_victory_condition() -> void:
	var level := Global.database.level_by_index(Global.current_scene_int)
	if level == null:
		return
	victory_condition = level.object_to_find()
	victory_progress = level.object_finding()

func _load_hud_menu() -> void:
	var counter := 0
	var label_counter: String = ""
	for key in meshes:
		var scene: SceneEntry = meshes[key]
		_create_button_info(scene, counter, label_counter)
		label_counter = scene.label_counter
		counter += 1

func _load_ambient_sound() -> void:
	if Setting.get_setting_ambient_sound():
		$AmbientSound.play()
		$AmbientSound.stream_paused = false

func _create_button_info(scene: SceneEntry, counter: int, label_counter: String) -> void:
	var button := _search_button_to_use(counter)
	var label_name := scene.label

	if label_counter != "" and label_counter == scene.label_counter:
		label_name = last_button.get_node("Label").text + " " + str(scene.counter)
		_configure_button_object(last_button, scene, label_name)
		_create_animation_warning(_get_node_animated().get_node("Label"), label_name)
	else:
		$ListObjects/ListContainer.add_child(button)
		_configure_button_object(button, scene, label_name)
		_create_animation_slide(_get_node_animated(), label_name)

	last_button = button

func _get_node_animated() -> Node:
	return $ListObjects/ListContainer.get_child($ListObjects/ListContainer.get_child_count() - 1)

func _search_button_to_use(counter: int) -> Node:
	if counter == 0:
		return object_first.instantiate()
	elif counter == meshes.size() - 1:
		return object_last.instantiate()
	return object_std.instantiate()

func _configure_button_object(button: Node, scene: SceneEntry, label: String) -> void:
	button.get_node("Label").set_text(label)
	button.set_meta("animation", label)
	button.set_meta("name", scene.label)
	button.set_meta("counter", scene.counter)
	button.set_meta("counted", 0)

func _create_animation_slide(node: Node, p_name: String) -> void:
	_add_animation_to_player(p_name, GameAnimation.level_hud_slide(node))

func _create_animation_warning(node: Node, p_name: String) -> void:
	_add_animation_to_player(p_name, GameAnimation.level_hud_warning(node))

func _add_animation_to_player(p_name: String, anim: Animation) -> void:
	var player: AnimationPlayer = $ListObjects/AnimationPlayer
	var lib := player.get_animation_library("")
	if lib == null:
		lib = AnimationLibrary.new()
		player.add_animation_library("", lib)
	lib.add_animation(p_name, anim)

func _process(_delta: float) -> void:
	_check_dissolve_mesh()
	_check_change_angle_camera()
	_check_victory_condition()

func create_dissolve_mesh(key: String) -> void:
	var mesh := _node_to_mesh(key)
	if mesh == null:
		return
	var material := mesh.get_active_material(0)
	if material == null:
		return
	material.set_shader_parameter("dissolve_amount", 0.0)

func _check_dissolve_mesh() -> void:
	# Event dissolve in object searched by gamer
	for key in meshes:
		var scene: SceneEntry = meshes[key]
		if not scene.lock or scene.dissolved:
			continue
		var mesh := _node_to_mesh(key)
		if mesh == null:
			continue
		if scene.dissolve_tick_reference == 0:
			scene.dissolve_tick_reference = Time.get_ticks_msec()
			_node_object_list(key)
			GameAnimation.start_dissolve(mesh, mesh.get_active_material(0))
		if Time.get_ticks_msec() < scene.dissolve_tick_reference + TIME_MAX:
			scene.dissolve_value += 0.01
		else:
			_clean_mesh(key)

func _clean_mesh(key: String) -> void:
	var level := Global.database.level_by_index(Global.current_scene_int)
	if level != null:
		victory_progress = level.object_finding()
	var mesh := _node_to_mesh(key)
	if mesh != null:
		mesh.call_deferred("free")
	meshes[key].dissolved = true

func _check_change_angle_camera() -> void:
	var camera: Camera3D = $"MainCamera"
	var gyroscope := Input.get_gyroscope()

	if camera.h_offset >= -OFFSET_CAMERA_MAX:
		if _action_pressed("ui_left") or _action_gyroscope("left", gyroscope):
			$"Main Camera3D".h_offset -= OFFSET_STEP_CHANGE

	if camera.h_offset <= OFFSET_CAMERA_MAX:
		if _action_pressed("ui_right") or _action_gyroscope("right", gyroscope):
			$"Main Camera3D".h_offset += OFFSET_STEP_CHANGE

	if camera.v_offset >= -OFFSET_CAMERA_MAX:
		if _action_pressed("ui_down") or _action_gyroscope("down", gyroscope):
			$"Main Camera3D".v_offset -= OFFSET_STEP_CHANGE

	if camera.v_offset <= OFFSET_CAMERA_MAX:
		if _action_pressed("ui_up") or _action_gyroscope("up", gyroscope):
			$"Main Camera3D".v_offset += OFFSET_STEP_CHANGE

	gyroscope_value_old = gyroscope

func _action_pressed(action: String) -> bool:
	return Input.is_action_pressed(action)

func _action_gyroscope(action: String, gyroscope: Vector3) -> bool:
	if not Setting.get_setting_gyrosocpe():
		return false
	var expression := Expression.new()
	expression.parse("_gyroscope_changed_" + action + "(gyroscope)", ["gyroscope"])
	return bool(expression.execute([gyroscope], self))

func _gyroscope_changed_left(gyroscope: Vector3) -> bool:
	return (gyroscope.abs().y - gyroscope_value_old.abs().y) > GYROSCOPE_MAX_DIFF and \
			gyroscope.y < gyroscope_value_old.y

func _gyroscope_changed_right(gyroscope: Vector3) -> bool:
	return (gyroscope.abs().y - gyroscope_value_old.abs().y) > GYROSCOPE_MAX_DIFF and \
			gyroscope.y > gyroscope_value_old.y

func _gyroscope_changed_down(gyroscope: Vector3) -> bool:
	return (gyroscope.abs().z - gyroscope_value_old.abs().z) > GYROSCOPE_MAX_DIFF and \
			gyroscope.z > gyroscope_value_old.z or \
		   (gyroscope.abs().x - gyroscope_value_old.abs().x) > GYROSCOPE_MAX_DIFF and \
			gyroscope.x > gyroscope_value_old.x

func _gyroscope_changed_up(gyroscope: Vector3) -> bool:
	return (gyroscope.abs().z - gyroscope_value_old.abs().z) > GYROSCOPE_MAX_DIFF and \
			gyroscope.z < gyroscope_value_old.z or \
		   (gyroscope.abs().x - gyroscope_value_old.abs().x) > GYROSCOPE_MAX_DIFF and \
			gyroscope.x < gyroscope_value_old.x

func _start_dissolve(key: String) -> void:
	if not meshes.has(key):
		return
	var scene: SceneEntry = meshes[key]
	if scene.lock:
		return
	scene.lock = true
	Global.database.save()
	$ObjectFind.stream = scene.audio_sound()
	$ObjectFind.play()

func _check_victory_condition() -> void:
	if victory_condition == victory_progress:
		Global.goto_scene("res://scenes/UI/ending/Ending.tscn")

func _node_to_mesh(key: String) -> MeshInstance3D:
	if not meshes.has(key):
		return null
	return get_node_or_null(meshes[key].mesh_path()) as MeshInstance3D

func _node_object_list(key: String) -> void:
	var animation_played: String = ""
	for child in $ListObjects/ListContainer.get_children():
		if not child.has_meta("name"):
			continue
		if child.get_meta("name") != meshes[key].label:
			continue
		child.set_meta("counted", child.get_meta("counted") + 1)
		if child.get_meta("counter") == child.get_meta("counted"):
			animation_played = child.get_meta("name")
		else:
			var diff: int = child.get_meta("counter") - child.get_meta("counted")
			var txt: String = child.get_meta("name")
			if diff != 1:
				txt = txt + " " + str(diff)
			animation_played = child.get_meta("animation")
			child.get_node("Label").set_text(txt)
		$ListObjects/AnimationPlayer.queue(animation_played)

func _input(event: InputEvent) -> void:
	if event is InputEventMouseButton or event is InputEventScreenTouch:
		var camera: Camera3D = $"MainCamera"
		from = camera.project_ray_origin(event.position)
		to = from + camera.project_ray_normal(event.position) * RAY_LENGTH

func _physics_process(_delta: float) -> void:
	var space_state := get_world_3d().direct_space_state
	if from != null and to != null:
		_check_collider(space_state)

func _check_collider(space_state: PhysicsDirectSpaceState3D) -> void:
	var query := PhysicsRayQueryParameters3D.create(from, to)
	query.collision_mask = 1
	query.collide_with_bodies = false
	query.collide_with_areas = true
	var result := space_state.intersect_ray(query)
	from = null
	to = null
	if result.has("collider"):
		var node: Node = result["collider"].get_parent()
		if node != null:
			_start_dissolve(node.name)