extends Node3D

var gridsize = 32
var astar_grid_room = AStarGrid2D.new()

var load_tile = preload("res://tiles/base_tile/tile.tscn")

var tile_dict = {}

var selection_drag_dict = {}
var selection_dict = {}

var tile_count_x_hist = null
var tile_count_z_hist = null

var build_forbidden = false

func _ready():
	
#	Sets up a simple 2D grid of blank tiles.
	
	for x in range(gridsize):
		for z in range (gridsize):
			var pos = Vector3i(x + 0.5,0 ,z + 0.5)
			
			var tile = load_tile.instantiate()
			tile.set_position(pos)
			tile.type = 0
			
			tile_dict[pos] = tile
			
			add_child(tile)
			

func build_selection(b):
	
	if build_forbidden:
		print("No fucking building aaaaaa")
		return
#	When the build or destroy button is clicked, changes the selected tiles to match the button's request
	
	for i in selection_dict:
		var tile_selected = tile_dict[i]
		tile_selected.build_this_tile(b)
	
	selection_dict.clear()
	
	for i in tile_dict:
		if not selection_dict.has(i):
			var tile_selected = tile_dict[i]
			tile_selected.select_this_tile(false)

func clear_selection():
	
#	When the clear button is clicked, it clears the selected tiles without doing anything.

	for i in tile_dict:
		var tile_selected = tile_dict[i]
		tile_selected.select_this_tile(false)
	
	selection_dict.clear()
			
func end_select_drag():
	
#	Locks in the dragged tiles on mouse-up

	tile_count_x_hist = 0
	tile_count_z_hist = 0

	selection_dict.merge(selection_drag_dict)
	
	if not verify_room():
		build_forbidden = true		
	
	selection_drag_dict.clear()
		
func draw_tile_click(start_pos):
	
	var build_start_pos: Vector3i = start_pos.snapped(Vector3i(1, 1, 1))
	tile_count_x_hist = 0
	tile_count_z_hist = 0
	
	select_tile(build_start_pos)

func init_select_drag(float_build_start_pos, float_build_mouse_pos):
	
	var select_drag_array = []
	
	var build_start_pos: Vector3i = float_build_start_pos.snapped(Vector3i(1.0, 1.0, 1.0))
	var build_mouse_pos: Vector3i = float_build_mouse_pos.snapped(Vector3i(1.0, 1.0, 1.0))

	var tile_count_x = build_mouse_pos.x - build_start_pos.x
	var tile_count_z = build_mouse_pos.z - build_start_pos.z
	
	if not tile_count_x_hist == tile_count_x or not tile_count_z_hist == tile_count_z:
		
		tile_count_x_hist = tile_count_x
		tile_count_z_hist = tile_count_z
		 
		for x in range(min(0, tile_count_x), max(0, tile_count_x) + 1):
			for z in range(min(0, tile_count_z), max(0, tile_count_z) + 1):
				var select_drag_pos = build_start_pos + Vector3i(x, 0, z)
				
				select_drag_array.append(select_drag_pos)
		
		draw_select_drag(select_drag_array)

func draw_select_drag(array):

	selection_drag_dict.clear()
	
	for i in tile_dict:
		if not selection_dict.has(i):
			var tile_selected = tile_dict[i]
			tile_selected.select_this_tile(false)
	
	for i in array:
		var id = i
		select_tile(id)

func select_tile(pos):
	
	if tile_dict.has(pos):
	
		var tile = tile_dict[pos]
		
		tile.select_this_tile(true)
			
		selection_drag_dict[pos] = tile

func verify_room():
	
	if selection_dict == selection_drag_dict:
		return true
	
	var verify_array = selection_dict.keys()
	var verify_queue_array = [verify_array[0]]
	var verify_checked_array = []
	
	while verify_array:
		if not verify_queue_array:
			return false

		var verify_pos = verify_queue_array[0]

		if selection_dict.has(Vector3i(verify_pos.x + 1, 0, verify_pos.z)):
			if not verify_checked_array.has(Vector3i(verify_pos.x + 1, 0, verify_pos.z)):
				if not verify_queue_array.has(Vector3i(verify_pos.x + 1, 0, verify_pos.z)):
					verify_queue_array.append(Vector3i(verify_pos.x + 1, 0, verify_pos.z))
		
		if selection_dict.has(Vector3i(verify_pos.x - 1, 0, verify_pos.z)):
			if not verify_checked_array.has(Vector3i(verify_pos.x - 1, 0, verify_pos.z)):
				if not verify_queue_array.has(Vector3i(verify_pos.x - 1, 0, verify_pos.z)):
					verify_queue_array.append(Vector3i(verify_pos.x - 1, 0, verify_pos.z))
				
		if selection_dict.has(Vector3i(verify_pos.x, 0, verify_pos.z + 1)):
			if not verify_checked_array.has(Vector3i(verify_pos.x, 0, verify_pos.z + 1)):
				if not verify_queue_array.has(Vector3i(verify_pos.x, 0, verify_pos.z + 1)):
					verify_queue_array.append(Vector3i(verify_pos.x, 0, verify_pos.z + 1))
	
		if selection_dict.has(Vector3i(verify_pos.x, 0, verify_pos.z - 1)):
			if not verify_checked_array.has(Vector3i(verify_pos.x, 0, verify_pos.z - 1)):
				if not verify_queue_array.has(Vector3i(verify_pos.x, 0, verify_pos.z - 1)):
					verify_queue_array.append(Vector3i(verify_pos.x, 0, verify_pos.z - 1))
		
		verify_checked_array.append(verify_pos)
		verify_queue_array.erase(verify_pos)
		verify_array.erase(verify_pos)
		
	return true

	
	



		#if verify_dict.has(Vector3i(verify_pos.x + 1, 0, verify_pos.z)) && not verified.has(Vector3i(verify_pos.x + 1, 0, verify_pos.z)):
			#verified.append(verify_pos)
			#verify_pos = Vector3i(verify_pos.x + 1, 0, verify_pos.z)
		#elif verify_dict.has(Vector3i(verify_pos.x - 1, 0, verify_pos.z)):
			#verified.append(verify_pos)
			#verify_pos = Vector3i(verify_pos.x - 1, 0, verify_pos.z)
		#elif verify_dict.has(Vector3i(verify_pos.x, 0, verify_pos.z + 1)):
			#verified.append(verify_pos)
			#verify_pos = Vector3i(verify_pos.x, 0, verify_pos.z + 1)
		#elif verify_dict.has(Vector3i(verify_pos.x, 0, verify_pos.z - 1)):
			#verified.append(verify_pos)
			#verify_pos = Vector3i(verify_pos.x, 0, verify_pos.z - 1)
		#else:
			#verify_dict.erase(verify_pos)
			#if verify_dict:
				#print(verify_dict)
				#return false

	return true
		#if selection_dict.has(Vector3i(verify_pos.x + 1, 0, verify_pos.z)) or (selection_dict.has(Vector3i(verify_pos.x - 1, 0, verify_pos.z))) or (selection_dict.has(Vector3i(verify_pos.x, 0, verify_pos.z + 1))) or (selection_dict.has(Vector3i(verify_pos.x, 0, verify_pos.z - 1))):
			#verify_dict.erase(verify_pos)