extends Area3D
class_name InsectTile


var coordinates: HexGrid.CubeCoordinates
var layer: int = 0

@export var is_black: bool = false
@export var resource: TileResource

@onready var hexagon_small = $HexagonSmall

var build_in_progress: bool = false
var move_in_progress: bool = false

var hovered: bool = false

var selected: bool = false

var hover_shader: ShaderMaterial = preload("res://InsectTiles/HoverShader.tres")

const SELECTION_FAILED_MAT: ShaderMaterial = preload("res://InsectTiles/SelectionFailedMat.tres")

var mat: StandardMaterial3D

var tween: Tween

var tweening: bool = false

func _ready() -> void:
	if is_black:
		hexagon_small.set_surface_override_material(0, resource.material_black.duplicate())
	else:
		hexagon_small.set_surface_override_material(0, resource.material_white.duplicate())

	mat = hexagon_small.get_surface_override_material(0)
	
	GameEvents.insect_tile_selection_request_failed.connect(_on_insect_tile_request_failed)
	GameEvents.insect_tile_selection_request_successful.connect(_on_insect_tile_selection_request_sucessful)
	GameEvents.insect_selected.connect(_on_insect_selected)
	GameEvents.insect_placed.connect(_on_insect_placed)
	GameEvents.insect_placement_cancelled.connect(_on_insect_placement_cancelled)
	GameEvents.insect_tile_selected.connect(_on_insect_tile_selected)
	GameEvents.insect_tile_deselected.connect(_on_insect_tile_deselected)
	GameEvents.insect_tile_moved.connect(_on_insect_tile_moved)
		
func _on_insect_tile_moved(tile: InsectTile, to: HexGrid.CubeCoordinates) -> void:
	move_in_progress = false
	selected = false
	
	if tile == self:
		hovered = false
		if not tweening:
			mat.next_pass = null
	
func _on_insect_tile_deselected(tile: InsectTile) -> void:
	move_in_progress = false
	selected = false
	
func _on_insect_tile_selected(tile: InsectTile) -> void:
	move_in_progress = true
	if tile == self:
		selected = true
	
func _on_insect_placed(resource: TileResource, is_black: bool, pos: HexGrid.CubeCoordinates) -> void:
	build_in_progress = false
	
func _on_insect_placement_cancelled() -> void:
	build_in_progress = false
	
func _on_insect_selected(resource: TileResource, is_black: bool) -> void:
	build_in_progress = true

func _on_insect_tile_selection_request_sucessful(tile: InsectTile) -> void:
	if tile != self:
		return
		
	GameEvents.insect_tile_selected.emit(self)

func _tween_shader(value: Color) -> void:
	var shader: ShaderMaterial = mat.next_pass
	shader.set_shader_parameter("albedo", value)
	pass

func _shader_done() -> void:
	tweening = false
	
	if hovered:
		mat.next_pass = hover_shader
	else:
		mat.next_pass = null

func _process(delta):
	if Input.is_action_just_pressed("place_tile"):
		if hovered and not (build_in_progress or move_in_progress):
			# check if is movable, either with direct reference to the map, or by ping-ponging a signal
			# request_selection
			# selection_reguest_successfull
			# selection_request_failed
			
			GameEvents.insect_tile_request_selection.emit(self)
			
func _on_insect_tile_request_failed(tile) -> void:
	move_in_progress = false
	selected = false
	
	if tile != self:
		return
		
	hovered = false
		
	# siomulate a failed selection request
	mat.next_pass = SELECTION_FAILED_MAT
	
	tweening = true
	
	if tween != null:
		tween.kill()
	
	tween = get_tree().create_tween()
	tween.tween_method(_tween_shader, Color.BLACK, Color.DARK_RED, 0.1).set_ease(Tween.EASE_IN_OUT).set_trans(Tween.TRANS_EXPO)
	tween.tween_method(_tween_shader, Color.DARK_RED, Color.BLACK, 0.35).set_ease(Tween.EASE_IN_OUT).set_trans(Tween.TRANS_EXPO)
	tween.tween_callback(_shader_done)
	
	GameEvents.insect_tile_deselected.emit(self)

func _on_mouse_entered():
	if build_in_progress or move_in_progress:
		return
	
	if GameData.is_player_black == is_black:
		if tween == null:
			mat.next_pass = hover_shader
		hovered = true

func _on_mouse_exited():
	if selected:
		return
		
	hovered = false
	if tween == null:
		mat.next_pass = null