extends Node2D

const GRID_WIDTH: int = 10
const GRID_HEIGHT: int = 10
const ITEM_SIZE: int = 2
const GRID_SIZE: int = GRID_WIDTH * GRID_HEIGHT
const EMPTY_SPACE: int = 0

var inventory: PackedInt32Array = PackedInt32Array()

func _ready() -> void:
	initialize_worst_case_inventory()
	print_grid()

func initialize_worst_case_inventory() -> void:
	inventory.resize(GRID_SIZE)
	inventory.fill(1)

	var empty_start: int = (GRID_HEIGHT - ITEM_SIZE) * GRID_WIDTH + (GRID_WIDTH - ITEM_SIZE)
	for i in range(ITEM_SIZE):
		for j in range(ITEM_SIZE):
			inventory[empty_start + j + i * GRID_WIDTH] = EMPTY_SPACE

func benchmark_find_space(iterations: int) -> float:
	var start_time: float = Time.get_ticks_usec()

	for _i in range(iterations):
		find_next_available_space()

	var end_time: float = Time.get_ticks_usec()
	var elapsed_time: float = (end_time - start_time) / 1_000_000.0
	print("GDScript: Find space benchmark (%d iterations) took %.6f seconds" % [iterations, elapsed_time])
	return elapsed_time

func find_next_available_space() -> Vector2i:
	var max_index: int = GRID_SIZE - ITEM_SIZE * GRID_WIDTH - ITEM_SIZE + 1
	var row_offset: int = GRID_WIDTH - ITEM_SIZE + 1

	var i: int = 0
	while i < max_index:
		if inventory[i] == EMPTY_SPACE:
			var is_available: bool = true
			for y in range(ITEM_SIZE):
				for x in range(ITEM_SIZE):
					if inventory[i + x + y * GRID_WIDTH] != EMPTY_SPACE:
						is_available = false
						break
				if not is_available:
					break
			if is_available:
				return Vector2i(i % GRID_WIDTH, i / GRID_WIDTH)
			i += ITEM_SIZE
		else:
			i += 1
		if i % row_offset == 0:
			i += (ITEM_SIZE - 1) * GRID_WIDTH

	return Vector2i(-1, -1)

func print_grid() -> void:
	print("GDScript Grid:")
	var row: String = ""
	for i in range(GRID_SIZE):
		row += "□ " if inventory[i] == EMPTY_SPACE else "■ "
		if (i + 1) % GRID_WIDTH == 0:
			print(row)
			row = ""
	print("")

func initialize_inventory_for_sorting() -> void:
	inventory.resize(GRID_SIZE)
	inventory.fill(EMPTY_SPACE)

	var items: PackedInt32Array = PackedInt32Array([1, 2, 3, 4, 5])
	var positions: PackedVector2Array = PackedVector2Array([Vector2i(2, 2), Vector2i(5, 1), Vector2i(1, 5), Vector2i(7, 6), Vector2i(4, 8)])

	for i in range(items.size()):
		place_item(items[i], positions[i].x, positions[i].y)

func place_item(item: int, x: int, y: int) -> void:
	var start_index: int = y * GRID_WIDTH + x
	for i in range(ITEM_SIZE):
		for j in range(ITEM_SIZE):
			inventory[start_index + j + i * GRID_WIDTH] = item

func benchmark_sort_inventory(iterations: int) -> float:
	var start_time: float = Time.get_ticks_usec()

	for _i in range(iterations):
		sort_inventory()

	var end_time: float = Time.get_ticks_usec()
	var elapsed_time: float = (end_time - start_time) / 1_000_000.0
	print("GDScript: Sort inventory benchmark (%d iterations) took %.6f seconds" % [iterations, elapsed_time])
	return elapsed_time

func sort_inventory() -> void:
	var items: PackedInt32Array = PackedInt32Array()
	var item_counts: PackedInt32Array = PackedInt32Array()
	item_counts.resize(6)

	for item in inventory:
		item_counts[item] += 1

	for i in range(1, 6):
		if item_counts[i] > 0:
			items.append(i)

	inventory.fill(EMPTY_SPACE)

	for item in items:
		var item_pos: Vector2i = find_next_available_space()
		if item_pos.x != -1 and item_pos.y != -1:
			place_item(item, item_pos.x, item_pos.y)

func print_inventory_for_sorting() -> void:
	print("GDScript Inventory Before Sorting:")
	print_grid()
	sort_inventory()
	print("GDScript Inventory After Sorting:")
	print_grid()