tool # https://www.youtube.com/watch?v=Y7JG63IuaWs

extends EditorPlugin

const HTerrain = preload("../hterrain.gd")
const HTerrainDetailLayer = preload("../hterrain_detail_layer.gd")
const HTerrainData = preload("../hterrain_data.gd")
const HTerrainMesher = preload("../hterrain_mesher.gd")
const HTerrainTextureSet = preload("../hterrain_texture_set.gd")
const PackedTextureImporter = preload("./packed_textures/packed_texture_importer.gd")
const PackedTextureArrayImporter = preload("./packed_textures/packed_texture_array_importer.gd")
const PreviewGenerator = preload("./preview_generator.gd")
const TerrainPainter = preload("./brush/terrain_painter.gd")
const BrushDecal = preload("./brush/decal.gd")
const Util = preload("../util/util.gd")
const EditorUtil = preload("./util/editor_util.gd")
const LoadTextureDialog = preload("./load_texture_dialog.gd")
const GlobalMapBaker = preload("./globalmap_baker.gd")
const ImageFileCache = preload("../util/image_file_cache.gd")
const Logger = preload("../util/logger.gd")

# TODO Suffix with Scene
const EditPanel = preload("./panel.tscn")
const ProgressWindow = preload("./progress_window.tscn")
const GeneratorDialog = preload("./generator/generator_dialog.tscn")
const ImportDialog = preload("./importer/importer_dialog.tscn")
const GenerateMeshDialog = preload("./generate_mesh_dialog.tscn")
const ResizeDialog = preload("./resize_dialog/resize_dialog.tscn")
const ExportImageDialog = preload("./exporter/export_image_dialog.tscn")
const TextureSetEditor = preload("./texture_editor/set_editor/texture_set_editor.tscn")
const TextureSetImportEditor = preload("./texture_editor/set_editor/texture_set_import_editor.tscn")
const AboutDialogScene = preload("./about/about_dialog.tscn")

const DOCUMENTATION_URL = "https://hterrain-plugin.readthedocs.io/en/latest"

const MENU_IMPORT_MAPS = 0
const MENU_GENERATE = 1
const MENU_BAKE_GLOBALMAP = 2
const MENU_RESIZE = 3
const MENU_UPDATE_EDITOR_COLLIDER = 4
const MENU_GENERATE_MESH = 5
const MENU_EXPORT_HEIGHTMAP = 6
const MENU_LOOKDEV = 7
const MENU_DOCUMENTATION = 8
const MENU_ABOUT = 9


# TODO Rename _terrain
var _node : HTerrain = null

# GUI
var _panel = null
var _toolbar = null
var _toolbar_brush_buttons = {}
var _generator_dialog = null
# TODO Rename _import_terrain_dialog
var _import_dialog = null
var _export_image_dialog = null
var _progress_window = null
var _generate_mesh_dialog = null
var _preview_generator = null
var _resize_dialog = null
var _about_dialog = null
var _menu_button : MenuButton
var _lookdev_menu : PopupMenu
var _texture_set_editor = null
var _texture_set_import_editor = null

var _globalmap_baker = null
var _terrain_had_data_previous_frame = false
var _image_cache : ImageFileCache

# Import
var _packed_texture_importer := PackedTextureImporter.new()
var _packed_texture_array_importer := PackedTextureArrayImporter.new()

var _terrain_painter : TerrainPainter = null
var _brush_decal : BrushDecal = null
var _mouse_pressed := false
#var _pending_paint_action = null
var _pending_paint_commit := false

var _logger = Logger.get_for(self)


static func get_icon(name: String) -> Texture:
	return load("res://addons/zylann.hterrain/tools/icons/icon_" + name + ".svg") as Texture


func _enter_tree():
	_logger.debug("HTerrain plugin Enter tree")
	
	var dpi_scale = EditorUtil.get_dpi_scale(get_editor_interface().get_editor_settings())
	_logger.debug(str("DPI scale: ", dpi_scale))
	
	add_custom_type("HTerrain", "Spatial", HTerrain, get_icon("heightmap_node"))
	add_custom_type("HTerrainDetailLayer", "Spatial", HTerrainDetailLayer, 
		get_icon("detail_layer_node"))
	add_custom_type("HTerrainData", "Resource", HTerrainData, get_icon("heightmap_data"))
	# TODO Proper texture
	add_custom_type("HTerrainTextureSet", "Resource", HTerrainTextureSet, null)
	
	add_import_plugin(_packed_texture_importer)
	add_import_plugin(_packed_texture_array_importer)
	
	_preview_generator = PreviewGenerator.new()
	get_editor_interface().get_resource_previewer().add_preview_generator(_preview_generator)
	
	_terrain_painter = TerrainPainter.new()
	_terrain_painter.set_brush_size(5)
	_terrain_painter.get_brush().connect("size_changed", self, "_on_brush_size_changed")
	add_child(_terrain_painter)

	_brush_decal = BrushDecal.new()
	_brush_decal.set_size(_terrain_painter.get_brush_size())
	
	_image_cache = ImageFileCache.new("user://temp_hterrain_image_cache")
	
	var editor_interface := get_editor_interface()
	var base_control := editor_interface.get_base_control()
	
	_panel = EditPanel.instance()
	Util.apply_dpi_scale(_panel, dpi_scale)
	_panel.hide()
	add_control_to_container(EditorPlugin.CONTAINER_SPATIAL_EDITOR_BOTTOM, _panel)
	# Apparently _ready() still isn't called at this point...
	_panel.call_deferred("set_terrain_painter", _terrain_painter)
	_panel.call_deferred("setup_dialogs", base_control)
	_panel.set_undo_redo(get_undo_redo())
	_panel.set_image_cache(_image_cache)
	_panel.connect("detail_selected", self, "_on_detail_selected")
	_panel.connect("texture_selected", self, "_on_texture_selected")
	_panel.connect("detail_list_changed", self, "_update_brush_buttons_availability")
	_panel.connect("edit_texture_pressed", self, "_on_Panel_edit_texture_pressed")
	_panel.connect("import_textures_pressed", self, "_on_Panel_import_textures_pressed")
	
	_toolbar = HBoxContainer.new()
	add_control_to_container(EditorPlugin.CONTAINER_SPATIAL_EDITOR_MENU, _toolbar)
	_toolbar.hide()
	
	var menu := MenuButton.new()
	menu.set_text("Terrain")
	menu.get_popup().add_item("Import maps...", MENU_IMPORT_MAPS)
	menu.get_popup().add_item("Generate...", MENU_GENERATE)
	menu.get_popup().add_item("Resize...", MENU_RESIZE)
	menu.get_popup().add_item("Bake global map", MENU_BAKE_GLOBALMAP)
	menu.get_popup().add_separator()
	menu.get_popup().add_item("Update Editor Collider", MENU_UPDATE_EDITOR_COLLIDER)
	menu.get_popup().add_separator()
	menu.get_popup().add_item("Generate mesh (heavy)", MENU_GENERATE_MESH)
	menu.get_popup().add_separator()
	menu.get_popup().add_item("Export heightmap", MENU_EXPORT_HEIGHTMAP)
	menu.get_popup().add_separator()
	_lookdev_menu = PopupMenu.new()
	_lookdev_menu.name = "LookdevMenu"
	_lookdev_menu.connect("about_to_show", self, "_on_lookdev_menu_about_to_show")
	_lookdev_menu.connect("id_pressed", self, "_on_lookdev_menu_id_pressed")
	menu.get_popup().add_child(_lookdev_menu)
	menu.get_popup().add_submenu_item("Lookdev", _lookdev_menu.name, MENU_LOOKDEV)
	menu.get_popup().connect("id_pressed", self, "_menu_item_selected")
	menu.get_popup().add_separator()
	menu.get_popup().add_item("Documentation", MENU_DOCUMENTATION)
	menu.get_popup().add_item("About HTerrain...", MENU_ABOUT)
	_toolbar.add_child(menu)
	_menu_button = menu
	
	var mode_icons := {}
	mode_icons[TerrainPainter.MODE_RAISE] = get_icon("heightmap_raise")
	mode_icons[TerrainPainter.MODE_LOWER] = get_icon("heightmap_lower")
	mode_icons[TerrainPainter.MODE_SMOOTH] = get_icon("heightmap_smooth")
	mode_icons[TerrainPainter.MODE_FLATTEN] = get_icon("heightmap_flatten")
	mode_icons[TerrainPainter.MODE_SPLAT] = get_icon("heightmap_paint")
	mode_icons[TerrainPainter.MODE_COLOR] = get_icon("heightmap_color")
	mode_icons[TerrainPainter.MODE_DETAIL] = get_icon("grass")
	mode_icons[TerrainPainter.MODE_MASK] = get_icon("heightmap_mask")
	mode_icons[TerrainPainter.MODE_LEVEL] = get_icon("heightmap_level")
	mode_icons[TerrainPainter.MODE_ERODE] = get_icon("heightmap_erode")
	
	var mode_tooltips := {}
	mode_tooltips[TerrainPainter.MODE_RAISE] = "Raise height"
	mode_tooltips[TerrainPainter.MODE_LOWER] = "Lower height"
	mode_tooltips[TerrainPainter.MODE_SMOOTH] = "Smooth height"
	mode_tooltips[TerrainPainter.MODE_FLATTEN] = "Flatten (flatten to a specific height)"
	mode_tooltips[TerrainPainter.MODE_SPLAT] = "Texture paint"
	mode_tooltips[TerrainPainter.MODE_COLOR] = "Color paint"
	mode_tooltips[TerrainPainter.MODE_DETAIL] = "Grass paint"
	mode_tooltips[TerrainPainter.MODE_MASK] = "Cut holes"
	mode_tooltips[TerrainPainter.MODE_LEVEL] = "Level (smoothly flattens to average)"
	mode_tooltips[TerrainPainter.MODE_ERODE] = "Erode"
	
	_toolbar.add_child(VSeparator.new())
	
	# I want modes to be in that order in the GUI
	var ordered_brush_modes := [
		TerrainPainter.MODE_RAISE,
		TerrainPainter.MODE_LOWER,
		TerrainPainter.MODE_SMOOTH,
		TerrainPainter.MODE_LEVEL,
		TerrainPainter.MODE_FLATTEN,
		TerrainPainter.MODE_ERODE,
		TerrainPainter.MODE_SPLAT,
		TerrainPainter.MODE_COLOR,
		TerrainPainter.MODE_DETAIL,
		TerrainPainter.MODE_MASK
	]
	
	var mode_group := ButtonGroup.new()
	
	for mode in ordered_brush_modes:
		var button := ToolButton.new()
		button.icon = mode_icons[mode]
		button.set_tooltip(mode_tooltips[mode])
		button.set_toggle_mode(true)
		button.set_button_group(mode_group)
		
		if mode == _terrain_painter.get_mode():
			button.set_pressed(true)
		
		button.connect("pressed", self, "_on_mode_selected", [mode])
		_toolbar.add_child(button)
		
		_toolbar_brush_buttons[mode] = button
	
	_generator_dialog = GeneratorDialog.instance()
	_generator_dialog.connect("progress_notified", self, "_terrain_progress_notified")
	_generator_dialog.set_image_cache(_image_cache)
	_generator_dialog.set_undo_redo(get_undo_redo())
	base_control.add_child(_generator_dialog)
	_generator_dialog.apply_dpi_scale(dpi_scale)

	_import_dialog = ImportDialog.instance()
	_import_dialog.connect("permanent_change_performed", self, "_on_permanent_change_performed")
	Util.apply_dpi_scale(_import_dialog, dpi_scale)
	base_control.add_child(_import_dialog)

	_progress_window = ProgressWindow.instance()
	base_control.add_child(_progress_window)
	
	_generate_mesh_dialog = GenerateMeshDialog.instance()
	_generate_mesh_dialog.connect(
		"generate_selected", self, "_on_GenerateMeshDialog_generate_selected")
	Util.apply_dpi_scale(_generate_mesh_dialog, dpi_scale)
	base_control.add_child(_generate_mesh_dialog)
	
	_resize_dialog = ResizeDialog.instance()
	_resize_dialog.connect("permanent_change_performed", self, "_on_permanent_change_performed")
	Util.apply_dpi_scale(_resize_dialog, dpi_scale)
	base_control.add_child(_resize_dialog)
	
	_globalmap_baker = GlobalMapBaker.new()
	_globalmap_baker.connect("progress_notified", self, "_terrain_progress_notified")
	_globalmap_baker.connect("permanent_change_performed", self, "_on_permanent_change_performed")
	add_child(_globalmap_baker)
	
	_export_image_dialog = ExportImageDialog.instance()
	Util.apply_dpi_scale(_export_image_dialog, dpi_scale)
	base_control.add_child(_export_image_dialog)
	# Need to call deferred because in the specific case where you start the editor
	# with the plugin enabled, _ready won't be called at this point
	_export_image_dialog.call_deferred("setup_dialogs", base_control)
	
	_about_dialog = AboutDialogScene.instance()
	Util.apply_dpi_scale(_about_dialog, dpi_scale)
	base_control.add_child(_about_dialog)

	_texture_set_editor = TextureSetEditor.instance()
	_texture_set_editor.set_undo_redo(get_undo_redo())
	Util.apply_dpi_scale(_texture_set_editor, dpi_scale)
	base_control.add_child(_texture_set_editor)
	_texture_set_editor.call_deferred("setup_dialogs", base_control)

	_texture_set_import_editor = TextureSetImportEditor.instance()
	_texture_set_import_editor.set_undo_redo(get_undo_redo())
	_texture_set_import_editor.set_editor_file_system(
		get_editor_interface().get_resource_filesystem())
	Util.apply_dpi_scale(_texture_set_import_editor, dpi_scale)
	base_control.add_child(_texture_set_import_editor)
	_texture_set_import_editor.call_deferred("setup_dialogs", base_control)

	_texture_set_editor.connect("import_selected", self, "_on_TextureSetEditor_import_selected")
	

func _exit_tree():
	_logger.debug("HTerrain plugin Exit tree")
	
	# Make sure we release all references to edited stuff
	edit(null)

	_panel.queue_free()
	_panel = null
	
	_toolbar.queue_free()
	_toolbar = null
	
	_generator_dialog.queue_free()
	_generator_dialog = null
	
	_import_dialog.queue_free()
	_import_dialog = null
	
	_progress_window.queue_free()
	_progress_window = null
	
	_generate_mesh_dialog.queue_free()
	_generate_mesh_dialog = null
	
	_resize_dialog.queue_free()
	_resize_dialog = null
	
	_export_image_dialog.queue_free()
	_export_image_dialog = null
	
	_about_dialog.queue_free()
	_about_dialog = null

	_texture_set_editor.queue_free()
	_texture_set_editor = null

	_texture_set_import_editor.queue_free()
	_texture_set_import_editor = null

	get_editor_interface().get_resource_previewer().remove_preview_generator(_preview_generator)
	_preview_generator = null
	
	# TODO Manual clear cuz it can't do it automatically due to a Godot bug
	_image_cache.clear()
	
	# TODO https://github.com/godotengine/godot/issues/6254#issuecomment-246139694
	# This was supposed to be automatic, but was never implemented it seems...
	remove_custom_type("HTerrain")
	remove_custom_type("HTerrainDetailLayer")
	remove_custom_type("HTerrainData")
	remove_custom_type("HTerrainTextureSet")
	
	remove_import_plugin(_packed_texture_importer)
	_packed_texture_importer = null
	
	remove_import_plugin(_packed_texture_array_importer)
	_packed_texture_array_importer = null


func handles(object):
	return _get_terrain_from_object(object) != null


func edit(object):
	_logger.debug(str("Edit ", object))
	
	var node = _get_terrain_from_object(object)
	
	if _node != null:
		_node.disconnect("tree_exited", self, "_terrain_exited_scene")
	
	_node = node
	
	if _node != null:
		_node.connect("tree_exited", self, "_terrain_exited_scene")
	
	_update_brush_buttons_availability()
	
	_panel.set_terrain(_node)
	_generator_dialog.set_terrain(_node)
	_import_dialog.set_terrain(_node)
	_terrain_painter.set_terrain(_node)
	_brush_decal.set_terrain(_node)
	_generate_mesh_dialog.set_terrain(_node)
	_resize_dialog.set_terrain(_node)
	_export_image_dialog.set_terrain(_node)
	
	if object is HTerrainDetailLayer:
		# Auto-select layer for painting
		if object.is_layer_index_valid():
			_panel.set_detail_layer_index(object.get_layer_index())
		_on_detail_selected(object.get_layer_index())
	
	_update_toolbar_menu_availability()


static func _get_terrain_from_object(object):
	if object != null and object is Spatial:
		if not object.is_inside_tree():
			return null
		if object is HTerrain:
			return object
		if object is HTerrainDetailLayer and object.get_parent() is HTerrain:
			return object.get_parent()
	return null


func _update_brush_buttons_availability():
	if _node == null:
		return
	if _node.get_data() != null:
		var data = _node.get_data()
		var has_details = (data.get_map_count(HTerrainData.CHANNEL_DETAIL) > 0)
		
		if has_details:
			var button = _toolbar_brush_buttons[TerrainPainter.MODE_DETAIL]
			button.disabled = false
		else:
			var button = _toolbar_brush_buttons[TerrainPainter.MODE_DETAIL]
			if button.pressed:
				_select_brush_mode(TerrainPainter.MODE_RAISE)
			button.disabled = true


func _update_toolbar_menu_availability():
	var data_available := false
	if _node != null and _node.get_data() != null:
		data_available = true
	var popup : PopupMenu = _menu_button.get_popup()
	for i in popup.get_item_count():
		#var id = popup.get_item_id(i)
		# Turn off items if there is no data for them to work on
		if data_available:
			popup.set_item_disabled(i, false)
			popup.set_item_tooltip(i, "")
		else:
			popup.set_item_disabled(i, true)
			popup.set_item_tooltip(i, "Terrain has no data")


func make_visible(visible: bool):
	_panel.set_visible(visible)
	_toolbar.set_visible(visible)
	_brush_decal.update_visibility()

	# TODO Workaround https://github.com/godotengine/godot/issues/6459
	# When the user selects another node,
	# I want the plugin to release its references to the terrain.
	# This is important because if we don't do that, some modified resources will still be
	# loaded in memory, so if the user closes the scene and reopens it later, the changes will
	# still be partially present, and this is not expected.
	if not visible:
		edit(null)


# TODO Can't hint return as `Vector2?` because it's nullable
func _get_pointed_cell_position(mouse_position: Vector2, p_camera: Camera):# -> Vector2:
	# Need to do an extra conversion in case the editor viewport is in half-resolution mode
	var viewport = p_camera.get_viewport()
	var viewport_container = viewport.get_parent()
	var screen_pos = mouse_position * viewport.size / viewport_container.rect_size
	
	var origin = p_camera.project_ray_origin(screen_pos)
	var dir = p_camera.project_ray_normal(screen_pos)

	var ray_distance := p_camera.far * 1.2
	return _node.cell_raycast(origin, dir, ray_distance)


func forward_spatial_gui_input(p_camera: Camera, p_event: InputEvent) -> bool:
	if _node == null || _node.get_data() == null:
		return false
	
	_node._edit_update_viewer_position(p_camera)
	_panel.set_camera_transform(p_camera.global_transform)

	var captured_event = false
	
	if p_event is InputEventMouseButton:
		var mb = p_event
		
		if mb.button_index == BUTTON_LEFT or mb.button_index == BUTTON_RIGHT:
			if mb.pressed == false:
				_mouse_pressed = false

			# Need to check modifiers before capturing the event,
			# because they are used in navigation schemes
			if (not mb.control) and (not mb.alt) and mb.button_index == BUTTON_LEFT:
				if mb.pressed:
					# TODO Allow to paint on click
					# TODO `pressure` is not available in button press events
					# So I have to assume zero to avoid discontinuities with move events
					#_terrain_painter.paint_input(hit_pos_in_cells, 0.0)
					_mouse_pressed = true
				
				captured_event = true
				
				if not _mouse_pressed:
					# Just finished painting
					_pending_paint_commit = true
					_terrain_painter.get_brush().on_paint_end()
		
			if _terrain_painter.get_mode() == TerrainPainter.MODE_FLATTEN \
			and _terrain_painter.has_meta("pick_height") \
			and _terrain_painter.get_meta("pick_height"):
				_terrain_painter.set_meta("pick_height", false)
				# Pick height
				var hit_pos_in_cells = _get_pointed_cell_position(mb.position, p_camera)
				if hit_pos_in_cells != null:
					var h = _node.get_data().get_height_at(
						int(hit_pos_in_cells.x), int(hit_pos_in_cells.y))
					_logger.debug("Picking height {0}".format([h]))
					_terrain_painter.set_flatten_height(h)

	elif p_event is InputEventMouseMotion:
		var mm = p_event
		var hit_pos_in_cells = _get_pointed_cell_position(mm.position, p_camera)
		if hit_pos_in_cells != null:
			_brush_decal.set_position(Vector3(hit_pos_in_cells.x, 0, hit_pos_in_cells.y))
			
			if _mouse_pressed:
				if Input.is_mouse_button_pressed(BUTTON_LEFT):
					_terrain_painter.paint_input(hit_pos_in_cells, mm.pressure)
					captured_event = true

		# This is in case the data or textures change as the user edits the terrain,
		# to keep the decal working without having to noodle around with nested signals
		_brush_decal.update_visibility()

	return captured_event


func _process(delta: float):
	if _node == null:
		return

	var has_data = (_node.get_data() != null)
	
	if _pending_paint_commit:
		if has_data:
			if not _terrain_painter.is_operation_pending():
				_pending_paint_commit = false
				if _terrain_painter.has_modified_chunks():
					_logger.debug("Paint completed")
					var changes : Dictionary = _terrain_painter.commit()
					_paint_completed(changes)
		else:
			_pending_paint_commit = false
	
	# Poll presence of data resource
	if has_data != _terrain_had_data_previous_frame:
		_terrain_had_data_previous_frame = has_data
		_update_toolbar_menu_availability()


func _paint_completed(changes: Dictionary):
	var time_before = OS.get_ticks_msec()

	var heightmap_data = _node.get_data()
	assert(heightmap_data != null)
	
	var chunk_positions : Array = changes.chunk_positions
	# Should not create an UndoRedo action if nothing changed
	assert(len(chunk_positions) > 0)
	var changed_maps : Array = changes.maps
	
	var action_name := "Modify HTerrainData "
	for i in len(changed_maps):
		var mm = changed_maps[i]
		var map_debug_name := HTerrainData.get_map_debug_name(mm.map_type, mm.map_index)
		if i > 0:
			action_name += " and "
		action_name += map_debug_name

	var redo_maps := []
	var undo_maps := []
	var chunk_size := _terrain_painter.get_undo_chunk_size()
	
	for map in changed_maps:
		# Cache images to disk so RAM does not continuously go up (or at least much slower)
		for chunks in [map.chunk_initial_datas, map.chunk_final_datas]:
			for i in len(chunks):
				var im : Image = chunks[i]
				chunks[i] = _image_cache.save_image(im)
		
		redo_maps.append({
			"map_type": map.map_type,
			"map_index": map.map_index,
			"chunks": map.chunk_final_datas
		})
		undo_maps.append({
			"map_type": map.map_type,
			"map_index": map.map_index,
			"chunks": map.chunk_initial_datas
		})
	
	var undo_data := {
		"chunk_positions": chunk_positions,
		"chunk_size": chunk_size,
		"maps": undo_maps
	}
	var redo_data := {
		"chunk_positions": chunk_positions,
		"chunk_size": chunk_size,
		"maps": redo_maps
	}
	
#	{
#		chunk_positions: [Vector2, Vector2, ...]
#		chunk_size: int
#		maps: [
#			{
#				map_type: int
#				map_index: int
#				chunks: [
#					int, int, ...
#				]
#			},
#			...
#		]
#	}

	var ur := get_undo_redo()

	ur.create_action(action_name)
	ur.add_do_method(heightmap_data, "_edit_apply_undo", redo_data, _image_cache)
	ur.add_undo_method(heightmap_data, "_edit_apply_undo", undo_data, _image_cache)

	# Small hack here:
	# commit_actions executes the do method, however terrain modifications are heavy ones,
	# so we don't really want to re-run an update in every chunk that was modified during painting.
	# The data is already in its final state,
	# so we just prevent the resource from applying changes here.
	heightmap_data._edit_set_disable_apply_undo(true)
	ur.commit_action()
	heightmap_data._edit_set_disable_apply_undo(false)
	
	var time_spent = OS.get_ticks_msec() - time_before
	_logger.debug(str(action_name, " | ", len(chunk_positions), " chunks | ", time_spent, " ms"))


func _terrain_exited_scene():
	_logger.debug("HTerrain exited the scene")
	edit(null)


func _menu_item_selected(id: int):
	_logger.debug(str("Menu item selected ", id))
	
	match id:
		MENU_IMPORT_MAPS:
			_import_dialog.popup_centered()
					
		MENU_GENERATE:
			_generator_dialog.popup_centered()
		
		MENU_BAKE_GLOBALMAP:
			var data = _node.get_data()
			if data != null:
				_globalmap_baker.bake(_node)
		
		MENU_RESIZE:
			_resize_dialog.popup_centered()
			
		MENU_UPDATE_EDITOR_COLLIDER:
			# This is for editor tools to be able to use terrain collision.
			# It's not automatic because keeping this collider up to date is
			# expensive, but not too bad IMO because that feature is not often
			# used in editor for now.
			# If users complain too much about this, there are ways to improve it:
			#
			# 1) When the terrain gets deselected, update the terrain collider
			#    in a thread automatically. This is still expensive but should
			#    be easy to do.
			#
			# 2) Bullet actually support modifying the heights dynamically,
			#    as long as we stay within min and max bounds,
			#    so PR a change to the Godot heightmap collider to support passing
			#    a Float Image directly, and make it so the data is in sync
			#    (no CoW plz!!). It's trickier than 1) but almost free.
			#
			_node.update_collider()
		
		MENU_GENERATE_MESH:
			if _node != null and _node.get_data() != null:
				_generate_mesh_dialog.popup_centered()
		
		MENU_EXPORT_HEIGHTMAP:
			if _node != null and _node.get_data() != null:
				_export_image_dialog.popup_centered()
		
		MENU_LOOKDEV:
			# No actions here, it's a submenu
			pass

		MENU_DOCUMENTATION:
			OS.shell_open(DOCUMENTATION_URL)
		
		MENU_ABOUT:
			_about_dialog.popup_centered()


func _on_lookdev_menu_about_to_show():
	_lookdev_menu.clear()
	_lookdev_menu.add_check_item("Disabled")
	_lookdev_menu.set_item_checked(0, not _node.is_lookdev_enabled())
	_lookdev_menu.add_separator()
	var terrain_data : HTerrainData = _node.get_data()
	if terrain_data == null:
		_lookdev_menu.add_item("No terrain data")
		_lookdev_menu.set_item_disabled(0, true)
	else:
		for map_type in HTerrainData.CHANNEL_COUNT:
			var count := terrain_data.get_map_count(map_type)
			for map_index in count:
				var map_name := HTerrainData.get_map_debug_name(map_type, map_index)
				var lookdev_item_index := _lookdev_menu.get_item_count()
				_lookdev_menu.add_item(map_name, lookdev_item_index)
				_lookdev_menu.set_item_metadata(lookdev_item_index, {
					"map_type": map_type,
					"map_index": map_index
				})


func _on_lookdev_menu_id_pressed(id: int):
	var meta = _lookdev_menu.get_item_metadata(id)
	if meta == null:
		_node.set_lookdev_enabled(false)
	else:
		_node.set_lookdev_enabled(true)
		var data : HTerrainData = _node.get_data()
		var map_texture = data.get_texture(meta.map_type, meta.map_index)
		_node.set_lookdev_shader_param("u_map", map_texture)
	_lookdev_menu.set_item_checked(0, not _node.is_lookdev_enabled())


func _on_mode_selected(mode: int):
	_logger.debug(str("On mode selected ", mode))
	_terrain_painter.set_mode(mode)
	_panel.set_brush_editor_display_mode(mode)


func _on_texture_selected(index: int):
	# Switch to texture paint mode when a texture is selected
	_select_brush_mode(TerrainPainter.MODE_SPLAT)
	_terrain_painter.set_texture_index(index)


func _on_detail_selected(index: int):
	# Switch to detail paint mode when a detail item is selected
	_select_brush_mode(TerrainPainter.MODE_DETAIL)
	_terrain_painter.set_detail_index(index)


func _select_brush_mode(mode: int):
	_toolbar_brush_buttons[mode].pressed = true
	_on_mode_selected(mode)


static func get_size_from_raw_length(flen: int):
	var side_len = round(sqrt(float(flen/2)))
	return int(side_len)


func _terrain_progress_notified(info: Dictionary):
	if info.has("finished") and info.finished:
		_progress_window.hide()
	
	else:
		if not _progress_window.visible:
			_progress_window.popup_centered()
		
		var message = ""
		if info.has("message"):
			message = info.message
		
		_progress_window.show_progress(info.message, info.progress)
		# TODO Have builtin modal progress bar
		# https://github.com/godotengine/godot/issues/17763


func _on_GenerateMeshDialog_generate_selected(lod: int):
	var data := _node.get_data()
	if data == null:
		_logger.error("Terrain has no data, cannot generate mesh")
		return
	var heightmap := data.get_image(HTerrainData.CHANNEL_HEIGHT)
	var scale := _node.map_scale
	var mesh := HTerrainMesher.make_heightmap_mesh(heightmap, lod, scale, _logger)
	var mi := MeshInstance.new()
	mi.name = str(_node.name, "_FullMesh")
	mi.mesh = mesh
	mi.transform = _node.transform
	_node.get_parent().add_child(mi)
	mi.set_owner(get_editor_interface().get_edited_scene_root())


# TODO Workaround for https://github.com/Zylann/godot_heightmap_plugin/issues/101
func _on_permanent_change_performed(message: String):
	var data := _node.get_data()
	if data == null:
		_logger.error("Terrain has no data, cannot mark it as changed")
		return
	var ur := get_undo_redo()
	ur.create_action(message)
	ur.add_do_method(data, "_dummy_function")
	#ur.add_undo_method(data, "_dummy_function")
	ur.commit_action()


func _on_brush_size_changed(size):
	_brush_decal.set_size(size)


func _on_Panel_edit_texture_pressed(index: int):
	var ts := _node.get_texture_set()
	_texture_set_editor.set_texture_set(ts)
	_texture_set_editor.select_slot(index)
	_texture_set_editor.popup_centered()


func _on_TextureSetEditor_import_selected():
	_open_texture_set_import_editor()


func _on_Panel_import_textures_pressed():
	_open_texture_set_import_editor()


func _open_texture_set_import_editor():
	var ts := _node.get_texture_set()
	_texture_set_import_editor.set_texture_set(ts)
	_texture_set_import_editor.popup_centered()


################
# DEBUG LAND

# TEST
#func _physics_process(delta):
#	if Input.is_key_pressed(KEY_KP_0):
#		_debug_spawn_collider_indicators()


func _debug_spawn_collider_indicators():
	var root = get_editor_interface().get_edited_scene_root()
	var terrain := Util.find_first_node(root, HTerrain) as HTerrain
	if terrain == null:
		return
	
	var test_root : Spatial
	if not terrain.has_node("__DEBUG"):
		test_root = Spatial.new()
		test_root.name = "__DEBUG"
		terrain.add_child(test_root)
	else:
		test_root = terrain.get_node("__DEBUG")
	
	var space_state := terrain.get_world().direct_space_state
	var hit_material = SpatialMaterial.new()
	hit_material.albedo_color = Color(0, 1, 1)
	var cube = CubeMesh.new()
	
	for zi in 16:
		for xi in 16:
			var hit_name = str(xi, "_", zi)
			var pos = Vector3(xi * 16, 1000, zi * 16)
			var hit = space_state.intersect_ray(pos, pos + Vector3(0, -2000, 0))
			var mi : MeshInstance
			if not test_root.has_node(hit_name):
				mi = MeshInstance.new()
				mi.name = hit_name
				mi.material_override = hit_material
				mi.mesh = cube
				test_root.add_child(mi)
			else:
				mi = test_root.get_node(hit_name)
			if hit.empty():
				mi.hide()
			else:
				mi.show()
				mi.translation = hit.position


func _spawn_vertical_bound_boxes():
	var data = _node.get_data()
#	var sy = data._chunked_vertical_bounds_size_y
#	var sx = data._chunked_vertical_bounds_size_x
	var mat = SpatialMaterial.new()
	mat.flags_transparent = true
	mat.albedo_color = Color(1,1,1,0.2)
	data._chunked_vertical_bounds.lock()
	for cy in range(30, 60):
		for cx in range(30, 60):
			var vb = data._chunked_vertical_bounds.get_pixel(cx, cy)
			var minv = vb.r
			var maxv = vb.g
			var mi = MeshInstance.new()
			mi.mesh = CubeMesh.new()
			var cs = HTerrainData.VERTICAL_BOUNDS_CHUNK_SIZE
			mi.mesh.size = Vector3(cs, maxv - minv, cs)
			mi.translation = Vector3(
				(float(cx) + 0.5) * cs,
				minv + mi.mesh.size.y * 0.5, 
				(float(cy) + 0.5) * cs)
			mi.translation *= _node.map_scale
			mi.scale = _node.map_scale
			mi.material_override = mat
			_node.add_child(mi)
			mi.owner = get_editor_interface().get_edited_scene_root()
			
	data._chunked_vertical_bounds.unlock()
	
#	if p_event is InputEventKey:
#		if p_event.pressed == false:
#			if p_event.scancode == KEY_SPACE and p_event.control:
#				_spawn_vertical_bound_boxes()