# Phase 9 Prop Editor - headless regression checks for the .prop schema
# (PropFile: round-trip, version rejection, defaults, flattening, sanitize).
# Run with:
# & "C:\Godot4\Godot_v4.7.1-stable_win64_console.exe" --headless --path "C:\tmp\stickman" --script "res://tests/test_prop_editor_file.gd"

extends SceneTree

const PROP_FILE := preload("res://scripts/editors/prop/prop_file.gd")
const PROP_BLOCK := preload("res://scripts/props/prop_block.gd")
const TERRAIN_UTILS := preload("res://scripts/terrain/terrain_utils.gd")

var _checks: int = 0
var _failures: int = 0


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


func _run() -> void:
	print("\n=== PHASE 9 PROP FILE TEST ===")
	await _test_preset_conversion()
	await _test_to_file_dict()
	await _test_round_trip()
	await _test_version_rejection()
	await _test_missing_key_defaults()
	await _test_flattening()
	await _test_sanitize_shape()
	await _test_save_load()
	print("----------------------------------------")
	if _failures == 0:
		print("RESULT: ALL PASSED (%d assertions)" % _checks)
		quit(0)
	else:
		print("RESULT: %d FAILURE(S) out of %d assertions" % [_failures, _checks])
		quit(1)


func check(label: String, condition: bool) -> void:
	_checks += 1
	if condition:
		print("PASS: %s" % label)
	else:
		_failures += 1
		print("FAIL: %s" % label)


func _hex(v: Vector2) -> Dictionary:
	return {"x": v.x, "y": v.y}


func _box_shape(points: Array, fill: String = "#112233", outline: String = "#445566") -> Dictionary:
	return {
		"shape_type": "polygon",
		"points": points,
		"fill_color": fill,
		"outline_color": outline,
		"outline_width": 2.0,
		"closed": true,
		"vertex_flags": [0, 0, 0, 0],
	}


func _test_preset_conversion() -> void:
	for i: int in PROP_FILE.PRESET_STRINGS.size():
		var s: String = PROP_FILE.preset_to_string(i)
		check("preset_to_string(%d) == PRESET_STRINGS[%d]" % [i, i], s == PROP_FILE.PRESET_STRINGS[i])
		check("preset_from_string round trip %s" % s, PROP_FILE.preset_from_string(s) == i)
	check("preset_from_string unknown -> NONE", PROP_FILE.preset_from_string("banana") == PROP_BLOCK.MaterialPreset.NONE)
	check("preset_from_string case-insensitive", PROP_FILE.preset_from_string("WOOD") == PROP_BLOCK.MaterialPreset.WOOD)
	check("preset_to_string clamps low", PROP_FILE.preset_to_string(-5) == PROP_FILE.PRESET_STRINGS[0])
	check("preset_to_string clamps high", PROP_FILE.preset_to_string(99) == PROP_FILE.PRESET_STRINGS[PROP_FILE.PRESET_STRINGS.size() - 1])
	check("shape_type_to_payload_type circle", PROP_FILE.shape_type_to_payload_type("circle") == PROP_BLOCK.ShapeType.CIRCLE)
	check("shape_type_to_payload_type polygon", PROP_FILE.shape_type_to_payload_type("polygon") == PROP_BLOCK.ShapeType.POLYGON)
	check("shape_type_to_payload_type unknown", PROP_FILE.shape_type_to_payload_type("line") == PROP_BLOCK.ShapeType.POLYGON)


func _test_to_file_dict() -> void:
	var shapes: Array[Dictionary] = [_box_shape([_hex(Vector2(0, 0)), _hex(Vector2(64, 0)), _hex(Vector2(64, 64)), _hex(Vector2(0, 64))])]
	var data: Dictionary = PROP_FILE.to_file_dict("My Crate", PROP_BLOCK.MaterialPreset.WOOD, shapes)
	check("to_file_dict version", str(data.get("version", "")) == PROP_FILE.FILE_VERSION)
	check("to_file_dict prop_name", str(data.get("prop_name", "")) == "My Crate")
	check("to_file_dict preset string", str(data.get("material_preset", "")) == "wood")
	check("to_file_dict shapes count", (data.get("shapes", []) as Array).size() == 1)
	var meta: Dictionary = data.get("metadata", {})
	check("to_file_dict metadata present", not meta.is_empty())
	var serialized: Dictionary = (data.get("shapes", []) as Array)[0]
	check("serialized points are {x,y} dicts", serialized.get("points", []) is Array and ((serialized.get("points", []) as Array)[0] as Dictionary).has("x"))
	check("serialized point values preserved", is_equal_approx(float(((serialized.get("points", []) as Array)[1] as Dictionary).get("x", -1.0)), 64.0))
	check("serialized flags array", (serialized.get("vertex_flags", []) as Array).size() == 4)


func _test_round_trip() -> void:
	var shapes: Array[Dictionary] = []
	shapes.append(_box_shape([_hex(Vector2(0, 0)), _hex(Vector2(64, 0)), _hex(Vector2(64, 64)), _hex(Vector2(0, 64))]))
	shapes.append({
		"shape_type": "circle",
		"points": [],
		"radius": 40.0,
		"fill_color": "#FF0000",
		"outline_color": "#000000",
		"outline_width": 3.0,
		"closed": true,
		"vertex_flags": [],
	})
	shapes.append({
		"shape_type": "line",
		"points": [_hex(Vector2(0, 0)), _hex(Vector2(64, 0))],
		"fill_color": "#00FF00",
		"outline_color": "#0000FF",
		"outline_width": 1.5,
		"closed": false,
		"vertex_flags": [0, 0],
		"reshaped": true,
	})
	var data: Dictionary = PROP_FILE.to_file_dict("Round Trip", PROP_BLOCK.MaterialPreset.METAL, shapes)
	var model: Dictionary = PROP_FILE.from_file_dict(data)
	check("round trip non-empty", not model.is_empty())
	check("round trip name", str(model.get("prop_name", "")) == "Round Trip")
	check("round trip preset", int(model.get("material_preset", -1)) == PROP_BLOCK.MaterialPreset.METAL)
	var parsed: Array = model.get("shapes", [])
	check("round trip shapes count", parsed.size() == 3)
	var poly: Dictionary = parsed[0]
	check("round trip polygon points", (poly.get("points", PackedVector2Array()) as PackedVector2Array).size() == 4)
	check("round trip polygon point values", ((poly.get("points", PackedVector2Array()) as PackedVector2Array)[1]).is_equal_approx(Vector2(64, 0)) and ((poly.get("points", PackedVector2Array()) as PackedVector2Array)[2]).is_equal_approx(Vector2(64, 64)))
	check("round trip polygon closed", bool(poly.get("closed", false)) == true)
	check("round trip polygon fill", str(poly.get("fill_color", "")) == "#112233")
	var circ: Dictionary = parsed[1]
	check("round trip circle type", str(circ.get("shape_type", "")) == "circle")
	check("round trip circle radius", is_equal_approx(float(circ.get("radius", 0.0)), 40.0))
	check("round trip circle points rebuilt", (circ.get("points", PackedVector2Array()) as PackedVector2Array).size() == PROP_FILE.DEFAULT_CIRCLE_SEGMENTS)
	var line: Dictionary = parsed[2]
	check("round trip line closed", bool(line.get("closed", true)) == false)
	check("round trip line width", is_equal_approx(float(line.get("outline_width", 0.0)), 1.5))
	check("round trip reshaped preserved", bool(line.get("reshaped", false)) == true)
	check("round trip reshaped defaults false", bool(poly.get("reshaped", true)) == false)


func _test_version_rejection() -> void:
	check("reject missing version", PROP_FILE.from_file_dict({"prop_name": "x"}).is_empty())
	check("reject future version", PROP_FILE.from_file_dict({"version": "9.9", "shapes": []}).is_empty())
	check("reject non-dict data", PROP_FILE.from_file_dict([1, 2, 3]).is_empty())
	check("accept json string", not PROP_FILE.from_file_dict(JSON.stringify({"version": "1.0", "shapes": []})).is_empty())


func _test_missing_key_defaults() -> void:
	var data := {
		"version": "1.0",
		"shapes": [
			{"shape_type": "polygon", "points": [_hex(Vector2(0, 0)), _hex(Vector2(16, 0)), _hex(Vector2(16, 16))]},
			{"points": [_hex(Vector2(0, 0)), _hex(Vector2(16, 0))]},
		],
	}
	var model: Dictionary = PROP_FILE.from_file_dict(data)
	var shapes: Array = model.get("shapes", [])
	check("defaults shapes parsed", shapes.size() == 2)
	check("default preset NONE", int(model.get("material_preset", -1)) == PROP_BLOCK.MaterialPreset.NONE)
	var s0: Dictionary = shapes[0]
	check("default closed for polygon", bool(s0.get("closed", false)) == true)
	check("default fill from tint", str(s0.get("fill_color", "")).to_lower() == PROP_BLOCK.tint_for(PROP_BLOCK.MaterialPreset.NONE).to_html().to_lower())
	check("default outline darkened", str(s0.get("outline_color", "")) != "")
	check("default width", is_equal_approx(float(s0.get("outline_width", 0.0)), 2.0))
	check("default flags sized", (s0.get("vertex_flags", PackedInt32Array()) as PackedInt32Array).size() == 3)
	var s1: Dictionary = shapes[1]
	check("missing shape_type -> polygon", str(s1.get("shape_type", "")) == "polygon")


func _test_flattening() -> void:
	check("flatten empty -> {}", PROP_FILE.flatten_to_payload([]).is_empty())
	var line_shape := {
		"shape_type": "line",
		"points": [_hex(Vector2(0, 0)), _hex(Vector2(64, 0))],
		"fill_color": "#AABBCC",
		"outline_color": "#112233",
		"outline_width": 2.0,
		"closed": false,
		"vertex_flags": [0, 0],
	}
	var poly_back := _box_shape([_hex(Vector2(0, 0)), _hex(Vector2(64, 0)), _hex(Vector2(64, 64)), _hex(Vector2(0, 64))], "#101010", "#202020")
	var poly_front := _box_shape([_hex(Vector2(0, 0)), _hex(Vector2(32, 0)), _hex(Vector2(32, 32)), _hex(Vector2(0, 32))], "#FEFEFE", "#0F0F0F")
	var circle_shape := {
		"shape_type": "circle",
		"points": [],
		"radius": 40.0,
		"fill_color": "#FF0000",
		"outline_color": "#000000",
		"outline_width": 2.0,
		"closed": true,
		"vertex_flags": [],
	}
	var payload: Dictionary = PROP_FILE.flatten_to_payload([line_shape, poly_back, poly_front])
	check("flatten prefers frontmost closed polygon", int(payload.get("type", -1)) == PROP_BLOCK.ShapeType.POLYGON and (payload.get("fill_color", Color.BLACK) as Color).is_equal_approx(Color("#FEFEFE")))
	payload = PROP_FILE.flatten_to_payload([line_shape, circle_shape])
	check("flatten falls back to circle", int(payload.get("type", -1)) == PROP_BLOCK.ShapeType.CIRCLE)
	check("flatten circle radius", is_equal_approx(float(payload.get("radius", 0.0)), 40.0))
	payload = PROP_FILE.flatten_to_payload([line_shape])
	check("flatten line -> polygon payload", int(payload.get("type", -1)) == PROP_BLOCK.ShapeType.POLYGON)
	var pts: PackedVector2Array = payload.get("points", PackedVector2Array())
	check("flatten line points sanitized to grid", pts.size() == 2 and pts[0].x == 0.0 and pts[1].x == 64.0)
	var z_payload: Dictionary = PROP_FILE.flatten_to_payload([poly_front, poly_back])
	check("flatten z-order: last closed polygon wins", (z_payload.get("fill_color", Color.BLACK) as Color).is_equal_approx(Color("#101010")))


func _test_sanitize_shape() -> void:
	var dirty := {
		"shape_type": "polygon",
		"points": [_hex(Vector2(16, 16)), _hex(Vector2(16, 0)), _hex(Vector2(16, 0)), _hex(Vector2(0, 0)), _hex(Vector2(0, 16))],
		"fill_color": "#000000",
		"outline_color": "#000000",
		"outline_width": 2.0,
		"closed": true,
		"vertex_flags": [0, 0, 1, 0, 0],
	}
	var cleaned: Dictionary = PROP_FILE.sanitize_shape(dirty)
	var pts: PackedVector2Array = cleaned.get("points", PackedVector2Array())
	check("sanitize drops consecutive duplicate", pts.size() == 4)
	check("sanitize enforces clockwise", Geometry2D.is_polygon_clockwise(pts))
	var collinear := {
		"shape_type": "polygon",
		"points": [_hex(Vector2(0, 0)), _hex(Vector2(16, 0)), _hex(Vector2(32, 0)), _hex(Vector2(32, 32)), _hex(Vector2(0, 32))],
		"fill_color": "#000000",
		"outline_color": "#000000",
		"outline_width": 2.0,
		"closed": true,
		"vertex_flags": [0, 1, 0, 0, 0],
	}
	var cleaned2: Dictionary = PROP_FILE.sanitize_shape(collinear)
	check("sanitize drops collinear middle vertex", (cleaned2.get("points", PackedVector2Array()) as PackedVector2Array).size() == 4)
	check("sanitize flags aligned", (cleaned2.get("vertex_flags", PackedInt32Array()) as PackedInt32Array).size() == 4)
	var circle := {
		"shape_type": "circle",
		"points": [],
		"radius": 24.0,
		"fill_color": "#000000",
		"outline_color": "#000000",
		"outline_width": 2.0,
		"closed": true,
		"vertex_flags": [],
	}
	check("sanitize passes circles through", is_equal_approx(float(PROP_FILE.sanitize_shape(circle).get("radius", 0.0)), 24.0))


func _test_save_load() -> void:
	var shapes: Array[Dictionary] = [_box_shape([_hex(Vector2(0, 0)), _hex(Vector2(64, 0)), _hex(Vector2(64, 64)), _hex(Vector2(0, 64))])]
	var data: Dictionary = PROP_FILE.to_file_dict("Save Test", PROP_BLOCK.MaterialPreset.RUBBER, shapes)
	var path := "user://prop_editor_test_save.prop"
	check("save returns true", PROP_FILE.save(path, data))
	var loaded: Dictionary = PROP_FILE.load(path)
	check("load returns dict", not loaded.is_empty())
	check("load matches", loaded.get("prop_name", "") == "Save Test" and loaded.get("material_preset", "") == "rubber")
	check("load missing -> {}", PROP_FILE.load("user://definitely_missing.prop").is_empty())
	DirAccess.remove_absolute(path)