tool

extends Spatial

var GameTile = load("res://utils/GameTile.gd")
var HexCell = preload("res://addons/gdhexgrid/HexCell.gd")
onready var HexGrid = preload("res://addons/gdhexgrid/HexGrid.gd").new()
var IslandGenerator = preload("res://utils/IslandGenerator.gd").new()
onready var click_area = $ClckArea/CollisionShape
onready var water = $Water
onready var highlight = $Highlight
onready var noise = $Noise
onready var tiles = $Tiles

var has_tiles_initialized = false
var tile_map = {}
var active_tile = null
var island_count = 5

export var world_size = 50 setget do_resize
export var generate_flag: bool = false setget do_generate

func _ready():
	assert(get_node("Tiles") != null)

	do_resize(world_size)
	reset()
	generate()
	pass


func _process(_delta):
	pass


func do_generate(_flag):
	reset()
#	generate()
	generate_flag = false


func do_resize(new_size):
	print ("resizing world to size " + str (new_size))
	
	var water = $Water
	if water == null:
		return
		
	print ("water node: " + str(water))
	water.transform = Transform.IDENTITY.scaled(Vector3(new_size, new_size, new_size) * 0.5)
	
	var click_area = $ClckArea
	click_area.transform = water.transform
	
	world_size = new_size
	return world_size

func reset():
	var tiles = get_node("Tiles")
	if tiles == null:
		return
		
	print ("clearing old tiles: " + str(tiles.get_child_count()))
	for tile in tiles.get_children():
		tiles.remove_child(tile)
		tile.queue_free()
	tile_map = {}


func generate():
	print ("generating world with size " + str(world_size))
	reset()
	generate_base_tiles()
	apply_noise_as_height()


func apply_noise_as_height():
	var texture : Texture = noise.texture
	yield(texture, "changed")
	var noise = texture.get_data()
	noise.lock()
	
	var vec1 = Vector2.ONE
	vec1 = vec1 * Vector2(0.5, 0.2)
	
	for i in range (-world_size / 2, world_size / 2):
		for j in range (-world_size / 2, world_size / 2):
			var coord = Vector2(i,j)
			var tile = tile_map[coord]
			var tex_coord_normalized = (coord / world_size) * 0.5 + Vector2(0.5, 0.5)
			var tex_coord = tex_coord_normalized * texture.get_size()
#			-25 ... 25  -> 0 ... 1
#			(coord / (size * 0.5)) * 0.5 + 0.5: -1 .. 1
			var noise_value = texture.get_data().get_pixelv(tex_coord)
			tile.transform.origin.y = noise_value[0] * 5.0 - 3
	
	noise.unlock()


func generate_base_tiles():
	for i in range (-world_size / 2, world_size / 2):
		for j in range (-world_size / 2, world_size / 2):
			var tile = GameTile.new()
			tile.type = GameTile.TileType.Water
			tile.offset_coords = Vector2(i,j)
			
			add_tile_for_hex(tile)


func add_tile_for_hex(game_tile):
	var hexgrid = preload("res://addons/gdhexgrid/HexGrid.gd").new()
	var HexTile3D = preload("res://scenes/HexTile3D.tscn")
	
	var tile = HexTile3D.instance()
	var pos = hexgrid.get_hex_center_from_offset(game_tile.offset_coords)	
	var height = -2.0 # if game_tile.type == GameTile.TileType.Sand else 0.1 + rand_range(0.0, 0.05)

	tiles.add_child(tile)
	tile_map[game_tile.offset_coords] = tile

	tile.set_tiletype(game_tile.type)
	tile.transform.origin = Vector3(pos.x, height, pos.y)
	tile.game_tile = game_tile
	
	return tile


func _on_ClckArea_input_event(_camera, _event, position, _normal, _shape_idx):
	var hex_at_position = HexGrid.get_hex_at(position)
	var offset_coords = hex_at_position.offset_coords
	var hex_center = HexGrid.get_hex_center_from_offset(offset_coords)
	highlight.transform.origin = Vector3 (hex_center.x, 0.0, hex_center.y)
	
	var world_tile = null
	if offset_coords in tile_map.keys():
		world_tile = tile_map[offset_coords]
	
	if active_tile != null and world_tile != active_tile:
		pass

	if active_tile == world_tile:
		return

	if world_tile == null:
		return

	active_tile = world_tile


func _on_ClckArea_mouse_entered():
	highlight.visible = true


func _on_ClckArea_mouse_exited():
	highlight.visible = false