extends Node2D

@export var world : World
@export var camera : WorldCamera

@export var chunk_shader : Shader

var chunk_textures : Dictionary[Chunk, Sprite2D]

func _ready():
	world.updated.connect(update_chunk_shader_parameters)

func _draw():
	var camera_chunk : Vector2i = world.tile_pos_to_chunk_pos(world.global_position_to_tile(camera.position))
	
	var camera_size : Vector2 = camera.get_camera_rect().size / TileGlobals.chunk_size / TileGlobals.tile_size / 2
	var adjusted_size : Vector2i = Vector2i(ceil(camera_size.x), ceil(camera_size.y))
	
	for y in range(-adjusted_size.y, adjusted_size.y+1):
		for x in range(-adjusted_size.x, adjusted_size.x+1):
			draw_chunk(world.get_chunk_at(camera_chunk + Vector2i(x,y)))

func draw_chunk(chunk : Chunk) -> void:
	var offset : Vector2 = chunk.position * TileGlobals.chunk_size * TileGlobals.tile_size

	if not chunk_textures.has(chunk):
		var chunk_sprite : Sprite2D = Sprite2D.new()
		chunk_sprite.texture = preload("res://resources/items/textures/blank_tile.png")
		chunk_sprite.position = offset
		chunk_sprite.centered = false
		chunk_sprite.scale = Vector2(
			TileGlobals.chunk_size,
			TileGlobals.chunk_size
		)
		
		chunk_sprite.texture_repeat = CanvasItem.TEXTURE_REPEAT_ENABLED
		
		chunk_textures[chunk] = chunk_sprite

		var new_shader_material : ShaderMaterial = ShaderMaterial.new()
		new_shader_material.shader = chunk_shader
		
		chunk_sprite.material = new_shader_material
		add_child(chunk_sprite)
		
		update_chunk_shader_parameters(chunk)

func update_chunk_shader_parameters(chunk : Chunk):
	draw_chunk(chunk)
	var chunk_sprite : Sprite2D = chunk_textures[chunk]
	chunk_sprite.material.set_shader_parameter("tile_size", TileGlobals.tile_size)
	chunk_sprite.material.set_shader_parameter("tile_count", len(TileGlobals.tile_definitions))
	chunk_sprite.material.set_shader_parameter("tile_texture", TileGlobals.tile_atlas)
	
	var item_array : Array[int]
	
	for iy in range(TileGlobals.chunk_size):
		for ix in range(TileGlobals.chunk_size):
			item_array.append(-1)
	
	for item_pos in chunk.items.keys():
		item_array[item_pos.y*TileGlobals.chunk_size+item_pos.x] = chunk.items[item_pos].id
	
	var arrow_array : Array[int]
	
	for iy in range(TileGlobals.chunk_size):
		for ix in range(TileGlobals.chunk_size):
			arrow_array.append(-1)
	
	for arrow_pos in chunk.arrows.keys():
		var arrow_direction = chunk.arrows[arrow_pos].direction
		var int_direction = 0
		
		match arrow_direction:
			Vector2i(1, 0):
				int_direction = 0
			Vector2i(0, 1):
				int_direction = 1
			Vector2i(-1, 0):
				int_direction = 2
			Vector2i(0, -1):
				int_direction = 3
		
		arrow_array[arrow_pos.y*TileGlobals.chunk_size+arrow_pos.x] = int_direction
	
	chunk_sprite.material.set_shader_parameter("item_texture", ItemGlobals.item_atlas)
	chunk_sprite.material.set_shader_parameter("arrow_texture", preload("res://resources/misc/arrows.png"))

	chunk_sprite.material.set_shader_parameter("tiles", chunk.tiles)
	chunk_sprite.material.set_shader_parameter("items", item_array)
	chunk_sprite.material.set_shader_parameter("arrows", arrow_array)


func _process(delta: float) -> void:
	queue_redraw()