extends Node

@export var cols : int
@export var cell_size : Vector2i
@export var left_top_of_board : Marker2D
@export var init_card_anchos : Array[Marker2D]

@export var board_area : ReferenceRect

signal dragging_card

var has_mouse: bool = false
var dragged_card : Card

var hovered_cell : Vector2 = Global.invalid_cell_index
var board_info : Array = []

func _ready() -> void:
	init_game()
	dragging_card.connect(_on_dragging_card)
	#board_area.mouse_entered.connect(_on_mouse_enter_board)
	#board_area.mouse_exited.connect(_on_mouse_exit_board)

func init_game() -> void:
	board_info = create_cells()
	send_cards()

func create_cells() -> Array:
	var cells_matrix = []
	var init_pos = Vector2(left_top_of_board.global_position.x, left_top_of_board.global_position.y)
	for i in range(0, cols):
		var row = []
		for j in range(0, cols):
			var left_top_pos = Vector2(init_pos.x + i * cell_size.x, init_pos.y + j * cell_size.y)
			var center_pos = Vector2(left_top_pos.x + cell_size.x / 2, left_top_pos.y + cell_size.y / 2)
			var cell = setup_cell_rect(center_pos, cell_size)
			var collision_box = cell.get_node("CollisionBox") as CollisionShape2D 
			var shape = collision_box.shape
			var dict = {
				"global-left-top": Vector2(cell.global_position.x - shape.get_rect().size.x / 2, cell.global_position.y - shape.get_rect().size.y / 2),
				"index": Vector2i(i, j),
				"area": cell,
				"empty": true
			}
			row.append(dict)
		cells_matrix.append(row)
	return cells_matrix

func setup_cell_rect(left_top: Vector2, size: Vector2i) -> Area2D:
	var cell := Area2D.new()
	cell.global_position = left_top
	$BoardCells.add_child(cell)
	
	# 添加 CollisionShape2D 节点
	var collision_shape = CollisionShape2D.new()
	collision_shape.name = "CollisionBox"
	cell.add_child(collision_shape)

	# 设置 CollisionShape2D 为矩形，大小为棋盘格大小
	var shape = RectangleShape2D.new()
	shape.size = size
	collision_shape.shape = shape
	return cell

func _process(_delta: float) -> void:
	pass
	#if has_mouse and dragged_card != null:
		#clamp_card_on_cell(dragged_card)

func _on_dragging_card(card: Card) -> void:
	dragged_card = card

func get_hover_cell_index() -> Vector2i:
	var mouse_global_position = $MouseAnchor.get_global_mouse_position()
	return get_cell_on_pos(mouse_global_position)

func get_cell_on_pos(pos: Vector2) -> Vector2i:
	var relative_pos = Vector2(pos.x - left_top_of_board.global_position.x, pos.y - left_top_of_board.global_position.y)
	var index = Vector2i(int(relative_pos.x) / cell_size.x, int(relative_pos.y) / cell_size.y)
	if index.x < 0 or index.x >= cols or index.y < 0 or index.y >= cols:
		index = Global.invalid_cell_index
	return index

#func _on_mouse_enter_board() -> void:
	##if dragged_card != null:
		##dragged_card.handle_pos = false
	#has_mouse = true
	#print("board enter")
#
#func _on_mouse_exit_board() -> void:
	##if dragged_card != null:
		##dragged_card.handle_pos = true
	#has_mouse = false
	#print("board exit")
	
func clamp_card_on_cell(card: Card) -> void:
	var index = get_hover_cell_index()
	if index != Global.invalid_cell_index:
		var cell_info = board_info[index.x][index.y]
		#var cell_area = cell_info.area
		var pos = cell_info["global-left-top"]
		card.global_position = pos

func send_cards() -> void:
	var card_prefab = load("res://Scenes/Card.tscn")
	for i in range(init_card_anchos.size()):
		var pos = init_card_anchos[i].global_position
		var card_instance = card_prefab.instantiate()
		var card_size = (card_instance as Card).texture_normal.get_size()
		card_instance.global_position = Vector2(pos.x - card_size.x / 2, pos.y - card_size.y / 2)
		var val = randi() % 10
		var cate_num = randi() % 4
		card_instance.setup_card(cate_num, val)
		$Cards.add_child(card_instance)