# SPDX-License-Identifier: GPL-3.0-or-later
extends SceneTree

const CANVAS_COUNT: int = 10
const GRID_SIZE: int = 128
const MAX_SETUP_MSEC: float = 2500.0
const MAX_STATIC_MEMORY_MIB: float = 32.0
const FINGERPRINT_A := (
	"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
)
const FINGERPRINT_B := (
	"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
)


func _initialize() -> void:
	call_deferred("_run")


func _run() -> void:
	_validate_finalized_capacity()
	_validate_dense_cells_and_author_index()
	var drawing_root := Node3D.new()
	root.add_child(drawing_root)
	var colors := PackedByteArray()
	colors.resize(GRID_SIZE * GRID_SIZE)
	colors.fill(1)
	var authors := PackedInt32Array()
	authors.resize(GRID_SIZE * GRID_SIZE)
	authors.fill(1)
	var memory_before: int = OS.get_static_memory_usage()
	var started_usec: int = Time.get_ticks_usec()
	for canvas_index: int in CANVAS_COUNT:
		var canvas := SurfaceDrawingCanvas.new()
		drawing_root.add_child(canvas)
		var state: Dictionary = _compact_state(
			"canvas-%d" % canvas_index,
			canvas_index,
			colors,
			authors,
		)
		assert(SurfaceDrawingProtocol.validate_canvas_state(state))
		assert(canvas.setup(state, null))
		assert(canvas.get_rendered_pixel_count() == GRID_SIZE * GRID_SIZE)
		var artwork := canvas.get("_pixel_instance") as MeshInstance3D
		var arrays: Array = artwork.mesh.surface_get_arrays(0)
		var vertices: PackedVector3Array = arrays[Mesh.ARRAY_VERTEX]
		assert(
			vertices.size()
			<= (SurfaceDrawingCanvas.FINALIZED_MAX_SUBDIVISIONS + 1) ** 2
		)
	var setup_msec: float = (
		float(Time.get_ticks_usec() - started_usec) / 1000.0
	)
	var memory_mib: float = (
		float(OS.get_static_memory_usage() - memory_before) / 1048576.0
	)
	assert(
		setup_msec <= MAX_SETUP_MSEC,
		"finalized artwork setup took %.2f ms" % setup_msec,
	)
	assert(
		memory_mib <= MAX_STATIC_MEMORY_MIB,
		"finalized artwork retained %.2f MiB" % memory_mib,
	)
	print(
		"Surface drawing performance validation: PASS (%.2f ms, %.2f MiB)"
		% [setup_msec, memory_mib]
	)
	drawing_root.queue_free()
	await process_frame
	quit()


func _validate_finalized_capacity() -> void:
	var world_scene := load(
		"res://world/generation/generated_world_region.tscn"
	) as PackedScene
	assert(world_scene != null)
	var world_region: Node = world_scene.instantiate()
	var generator := world_region.get_node(
		"Terrain/TerrainChunkGenerator"
	) as TerrainChunkGenerator
	assert(generator != null and generator.catalog != null)
	var canvas_extent: float = (
		float(SurfaceDrawingProtocol.MAX_GRID_SIZE)
		* SurfaceDrawingProtocol.CELL_SIZE
	)
	var required_columns: int = ceili(
		float(generator.grid_size.x) * generator.catalog.chunk_size
		/ canvas_extent
	)
	var required_rows: int = ceili(
		float(generator.grid_size.y) * generator.catalog.chunk_size
		/ canvas_extent
	)
	var required_canvases: int = required_columns * required_rows
	var cells_per_canvas: int = (
		SurfaceDrawingProtocol.MAX_GRID_SIZE
		* SurfaceDrawingProtocol.MAX_GRID_SIZE
	)
	assert(
		SurfaceDrawingProtocol.MAX_FINALIZED_CANVASES >= required_canvases,
		"finalized canvas budget cannot tile the generated world",
	)
	assert(
		SurfaceDrawingProtocol.MAX_FINALIZED_GRID_CELLS
		>= required_canvases * cells_per_canvas,
		"finalized cell budget cannot tile the generated world",
	)
	world_region.free()


func _validate_dense_cells_and_author_index() -> void:
	var state: Dictionary = {
		"session_id": "dense-cell-test",
		"canvas_id": "dense-cell-canvas",
		"origin": [0.0, 0.0, 0.0],
		"normal": [0.0, 1.0, 0.0],
		"tangent": [1.0, 0.0, 0.0],
		"width": 16,
		"height": 16,
		"cell_size": SurfaceDrawingProtocol.CELL_SIZE,
		"revision": 1,
		"guide_visible": false,
		"finalized": true,
		"layer": 1,
		"creator_fingerprint": FINGERPRINT_A,
		"participant_fingerprints": [FINGERPRINT_A, FINGERPRINT_B],
		"cells": [
			{"x": 1, "y": 2, "color_id": "coral", "author_fingerprint": FINGERPRINT_A},
			{"x": 3, "y": 4, "color_id": "blue", "author_fingerprint": FINGERPRINT_B},
		],
	}
	var buffer := SurfaceDrawingCellBuffer.new()
	assert(buffer.configure_from_state(state))
	assert(buffer.get_painted_count() == 2)
	assert(buffer.get_author_cell_keys(FINGERPRINT_A) == PackedInt32Array([33]))
	assert(buffer.get_author_cell_keys(FINGERPRINT_B) == PackedInt32Array([67]))
	var compact: Dictionary = state.duplicate(true)
	compact.erase("cells")
	compact.merge(buffer.to_compact_fields(), true)
	assert(SurfaceDrawingProtocol.validate_canvas_state(compact))
	var restored := SurfaceDrawingCellBuffer.new()
	assert(restored.configure_from_state(compact))
	assert(restored.to_cells() == buffer.to_cells())
	assert(restored.apply_edits([
		{"x": 1, "y": 2, "color_id": "", "author_fingerprint": ""},
	]))
	assert(restored.get_author_cell_keys(FINGERPRINT_A).is_empty())
	assert(restored.get_painted_count() == 1)


func _compact_state(
	canvas_id: String,
	layer: int,
	colors: PackedByteArray,
	authors: PackedInt32Array,
) -> Dictionary:
	return {
		"session_id": "performance-test",
		"canvas_id": canvas_id,
		"origin": [float(layer) * 12.0, 0.0, 0.0],
		"normal": [0.0, 1.0, 0.0],
		"tangent": [1.0, 0.0, 0.0],
		"width": GRID_SIZE,
		"height": GRID_SIZE,
		"cell_size": SurfaceDrawingProtocol.CELL_SIZE,
		"revision": 1,
		"guide_visible": false,
		"finalized": true,
		"layer": layer,
		"creator_fingerprint": FINGERPRINT_A,
		"participant_fingerprints": [FINGERPRINT_A],
		"cell_encoding": SurfaceDrawingProtocol.CELL_ENCODING,
		"cell_colors": colors,
		"cell_authors": authors,
	}