extends Node2D

@onready var GroundLayer: TileMapLayer = $Ground
@onready var ObstacleLayer: TileMapLayer = $Obstacles
# Maybe a SubClass that is a Singleton, so we can create one grid
# and then change it per Map
var _aStarGrid: AStarGrid2D

var _gridData = {
	"cellSize": Vector2.ZERO,
	"fullRegion": Rect2i(0,0,0,0),
	"currentRegion": Rect2i(0,0,0,0)
}

# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	#_aStarGrid = generateSimpleGrid()
#	_aStarGrid = generateObstacleGrid()
#	%GridDisplay.grid = _aStarGrid
	pass

func generateSimpleGrid() -> AStarGrid2D:
	var grid = newGrid(Vector2.ZERO, Rect2i(0,0,0,0))
	
	for id in GroundLayer.get_used_cells():
		var data: TileData = GroundLayer.get_cell_tile_data(id)
		if data and data.get_custom_data('obstacle'):
			grid.set_point_solid(id)
	
	return grid

func generateObstacleGrid() -> AStarGrid2D:
	var grid = newGrid(Vector2.ZERO, Rect2i(0,0,0,0))
	
	var layers = ObstacleLayer.get_children()
	for layer in layers:
		for id in layer.get_used_cells():
			var data: TileData = layer.get_cell_tile_data(id)
			if data and data.get_custom_data('obstacle'):
				grid.set_point_solid(id)
	
	return grid

func GenerateGridFromLayer(layer: TileMapLayer):
	var ground = layer.get_parent().get_node("Ground")
	#var grid = newGrid(ground.tile_set.tile_size, ground.get_used_rect())
	var grid = GetGrid()
	
	if _gridData["cellSize"] == Vector2.ZERO:
		SetCellSize(ground.tile_set.tile_size)
	
	if _gridData["fullRegion"] == Rect2i(0,0,0,0):
		_gridData["fullRegion"] = ground.get_used_rect()
	
	_updateRegionFrom("fullRegion")
	
	var childLayers = layer.get_children()
	if childLayers.size() > 0:
		for childLayer in childLayers:
			for id in childLayer.get_used_cells():
				var data: TileData = childLayer.get_cell_tile_data(id)
				if data and data.get_custom_data('obstacle'):
					GetGrid().set_point_solid(id)
	else:
		for id in layer.get_used_cells():
			var data: TileData = layer.get_cell_tile_data(id)
			if data and data.get_custom_data('obstacle'):
				GetGrid().set_point_solid(id)
	
	GetGrid().update()

func newGrid(cellSize: Vector2, region: Rect2i) -> AStarGrid2D:
	_gridData["cellSize"] = cellSize
	_gridData["fullRegion"] = region
	var _astarGrid = AStarGrid2D.new()
	_astarGrid.default_compute_heuristic = AStarGrid2D.HEURISTIC_MANHATTAN
	_astarGrid.default_estimate_heuristic = AStarGrid2D.HEURISTIC_MANHATTAN
	_astarGrid.diagonal_mode = AStarGrid2D.DIAGONAL_MODE_ONLY_IF_NO_OBSTACLES
	_astarGrid.cell_size = cellSize
	_astarGrid.region = region

	_astarGrid.update()
	
	_aStarGrid = _astarGrid
	
	return _astarGrid

# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
	pass

func GetGrid():
	if !_aStarGrid:
		_aStarGrid = newGrid(Vector2.ZERO, Rect2i())
	
	return _aStarGrid

func SetGridData(key: Variant, value: Variant):
	if _gridData.has(key):
		_gridData[key] = value

func getData(): 
	return _gridData

func SetRegion(region: Rect2i, offset: Vector2i = Vector2i.ZERO):
	_gridData["currentRegion"] = region
	_aStarGrid.offset = offset
	_updateRegionFrom("currentRegion")

func _updateRegionFrom(region: String):
	_aStarGrid.region = _gridData[region]
	_aStarGrid.update()

func SetCellSize(cellSize: Vector2):
	_gridData["cellSize"] = cellSize
	_updateCellSize()

func _updateCellSize():
	_aStarGrid.cell_size = _gridData["cellSize"]
	_aStarGrid.update()