extends TextureButton
class_name InsectButton

@onready var hex = $Hex
@onready var tile_count_label = $Hex/TileCountLabel
@onready var insect_icon = $Hex/InsectIcon
var BEE = load("res://Tile/Prefabs/Bee.tres")
@export var insect_resource: TileResource = BEE

const HEX_BLACK = preload("res://InsectTiles/Assets/UI/hex_black.svg")
const HEX_WHITE = preload("res://InsectTiles/Assets/UI/hex_white.svg")

@export var is_black: bool = false

var disable_amount_display: bool = false

var tile_count: int = 1

var selected: bool = false
var hovered: bool = false
var deactivated: bool = false

var is_blacks_turn: bool = false

var should_disable: bool = false

func is_players_turn() -> bool:	
	return is_blacks_turn == is_black or GameData.debug

func update_color(_is_black: bool) -> void:
	is_black = _is_black
	if is_black:
		hex.texture = HEX_BLACK
	else:
		hex.texture = HEX_WHITE
		
	update_tile_count_display()
	insect_icon.texture = insect_resource.ui_texture
		
	if GameData.is_hot_seat:
		return
		
	if is_black != is_blacks_turn and not GameData.debug:
		disabled = true
		return
	
func is_empty() -> bool:
	return tile_count <= 0

func update_tile_count_display() -> void:
	tile_count_label.text = str(tile_count)
	if is_empty():
		disable()

func decrement_tile_count() -> void:
	tile_count -= 1
	update_tile_count_display()

func disable() -> void:
	disabled = true
	deactivated = true
			
	var tween = get_tree().create_tween()
	tween.tween_property(self, "modulate", Color.DIM_GRAY, 0.15)

func enable() -> void:
	disabled = false
	deactivated = false
	
	var tween = get_tree().create_tween()
	tween.tween_property(self, "modulate", Color.WHITE, 0.15)


func _on_placement_cancelled() -> void:
	refresh_state()

func _on_insect_placed(resource: TileResource, _is_black: bool, pos: Vector4i) -> void:
	refresh_state()
	
	if insect_resource == resource and _is_black == is_black:
		decrement_tile_count()

func refresh_state() -> void:
	selected = false
	
	if should_disable:
		disable()
	
	if not is_empty() and not should_disable:
		enable()
		
	if hovered and not is_empty():
		hover()
	else:
		unhover()

# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	update_color(is_black)
	
	if disable_amount_display:
		$Hex/TileCountLabel.visible = false
	
	GameEvents.insect_selected.connect(_on_insect_selected)
	GameEvents.insect_placement_cancelled.connect(_on_placement_cancelled)
	GameEvents.insect_placed.connect(_on_insect_placed)
	GameEvents.insect_tile_selected.connect(_on_insect_tile_selected)
	GameEvents.insect_tile_moved.connect(_on_insect_tile_moved)
	GameEvents.insect_tile_deselected.connect(_on_insect_tile_deselected)
	
	GameEvents.turn_started.connect(_on_turn_started)
	
func _on_turn_started(turn_num: int, map: HexGrid, _is_blacks_turn: bool) -> void:
	is_blacks_turn = _is_blacks_turn
	should_disable = false
	if turn_num >= 7 and not GameData.bees_placed.has(is_black): #has_bee_been_placed:
		if is_black == is_blacks_turn:
			# if not bee has been placed for this player
			# lock all buttons except the bee
			if is_same(BEE, insect_resource):
				# don't lock
				should_disable = false
			else:
				#lock
				should_disable = true
				
	refresh_state()
	
func _on_insect_tile_deselected(tile: InsectTile) -> void:
	refresh_state()

func _on_insect_tile_selected(tile: InsectTile) -> void:
	disable()
	
func _on_insect_tile_moved(tile: InsectTile, to: Vector4i) -> void:
	refresh_state()

func _on_insect_selected(button: InsectButton, _is_black: bool) -> void:
	if button != self:
		disable()
		
func hover() -> void:
	
	#if is_blacks_turn != is_black and not GameData.debug:
	#	return

	var tween = get_tree().create_tween()
	tween.tween_property(hex, "position", Vector2(0, -16), 0.1).set_ease(Tween.EASE_OUT).set_trans(Tween.TRANS_SPRING)

func unhover() -> void:
	#if is_blacks_turn != is_black and not GameData.debug:
	#	return
	
	var tween = get_tree().create_tween()
	tween.tween_property(hex, "position", Vector2(0, 0), 0.25).set_ease(Tween.EASE_OUT).set_trans(Tween.TRANS_SPRING)

func _on_mouse_entered():
	hovered = true
	
	if not deactivated:
		hover()

func _on_mouse_exited():
	hovered = false
	
	if not selected:
		unhover()

func _on_pressed():
	# We can only press under these conditions
	# Check if its the currents player turn (is black)
	# If hotseat: we're done
	# If multiplayer: Check if GameData.is_player_black is correct, this prevents
	# the other player from using this button on their game instance
	
	#GameData.is_hot_seat	
	if is_empty():
		return
		
	if not is_blacks_turn == is_black and not GameData.debug:
		return
		
	if not is_players_turn():
		return
		
	selected = true
		
	GameEvents.insect_selected.emit(self, is_black)
	
	release_focus()

func _input(event):
	if Input.is_action_just_pressed("ui_accept"):
		release_focus()
		return