package render_ir_tests

import ir "../../render_ir"
import "core:strings"
import "core:testing"

make_intent_frame :: proc(
) -> (
	frame: ir.Frame_IR,
	pass: ir.Pass_Handle,
	pipeline: ir.Pipeline_Handle,
	target: ir.Target_Handle,
	layer: ir.Layer_Handle,
	clip: ir.Clip_Handle,
	material: ir.Material_Handle,
	vertices: ir.Resource_Handle,
) {
	frame = ir.init_frame_ir()
	vertices = ir.add_buffer(&frame, "quad-vertices", 256, {.Vertex}, {.Host_Visible})
	pass = ir.add_pass(&frame, {kind = .Render, name = "main"})
	pipeline = ir.add_graphics_pipeline(&frame, "quads", ir.default_graphics_pipeline_state())
	target = ir.add_target(
		&frame,
		{
			kind = .Present,
			name = "swapchain",
			width = 800,
			height = 600,
			color_format = .B8G8R8A8_SRGB,
			clear_color = {0, 0, 0, 1},
			clear_depth = 1,
		},
	)
	layer = ir.add_layer(
		&frame,
		{target = target, name = "ui", sort_base = 10_000, order = .Strict},
	)
	clip = ir.add_clip(
		&frame,
		{target = target, kind = .Rect, rect = {x = 0, y = 0, width = 800, height = 600}},
	)
	material = ir.add_material(
		&frame,
		{name = "ui-material", pipeline = pipeline, blend_mode = .Alpha},
	)
	return
}

@(test)
test_generic_draw_packet_stores_intent_handles :: proc(t: ^testing.T) {
	frame, pass, pipeline, target, layer, clip, material, vertices := make_intent_frame()
	defer ir.destroy_frame_ir(&frame)

	cmd := ir.add_draw_packet(
		&frame,
		pass,
		pipeline,
		.Quad_Stream,
		{
			target = target,
			layer = layer,
			sort_key = 42,
			clip = clip,
			material = material,
			geometry = {kind = .Quad_Stream, resource = vertices, vertex_count = 6},
			instances = {count = 1},
			order = .Strict,
		},
		6,
		1,
	)

	draw, ok := ir.get_draw(&frame, cmd)
	testing.expect(t, ok)
	testing.expect(t, ir.draw_kind_is_packet(draw.kind))
	testing.expect(t, draw.packet.target == target)
	testing.expect(t, draw.packet.layer == layer)
	testing.expect(t, draw.packet.clip == clip)
	testing.expect(t, draw.packet.material == material)
	testing.expect(t, draw.packet.geometry.resource == vertices)
	testing.expect_value(t, draw.packet.sort_key, u64(42))
	testing.expect_value(t, draw.packet.sequence, u64(1))
	testing.expect_value(t, ir.target_count(&frame), 1)
	testing.expect_value(t, ir.layer_count(&frame), 1)
	testing.expect_value(t, ir.clip_count(&frame), 1)
	testing.expect_value(t, ir.material_count(&frame), 1)

	diagnostics := ir.init_diagnostics()
	defer ir.destroy_diagnostics(&diagnostics)
	ir.validate_intent_handles(&frame, &diagnostics)
	testing.expect_value(t, len(diagnostics.items), 0)
}

@(test)
test_generic_draw_packet_dump_and_trace :: proc(t: ^testing.T) {
	frame, pass, pipeline, target, layer, clip, material, vertices := make_intent_frame()
	defer ir.destroy_frame_ir(&frame)

	_ = ir.add_draw_packet(
		&frame,
		pass,
		pipeline,
		.Quad_Stream,
		{
			target = target,
			layer = layer,
			sort_key = 7,
			clip = clip,
			material = material,
			geometry = {kind = .Quad_Stream, resource = vertices, vertex_count = 6},
			instances = {count = 1},
			order = .Strict,
		},
		6,
		1,
	)

	dump := ir.dump_frame_ir(&frame)
	defer delete(dump)
	testing.expect(t, strings.contains(dump, "targets 1"))
	testing.expect(t, strings.contains(dump, "layers 1"))
	testing.expect(t, strings.contains(dump, "clips 1"))
	testing.expect(t, strings.contains(dump, "materials 1"))
	testing.expect(
		t,
		strings.contains(
			dump,
			"Draw kind=Quad_Stream pass=1 pipeline=1 target=1 layer=1 order=Strict sort_key=7 sequence=1",
		),
	)

	trace := ir.trace_frame_ir(&frame)
	defer delete(trace)
	testing.expect(
		t,
		strings.contains(
			trace,
			"draw_packet kind=Quad_Stream target=1 layer=1 order=Strict sort_key=7 sequence=1",
		),
	)
}

@(test)
test_generic_draw_packet_invalid_handles_diagnose :: proc(t: ^testing.T) {
	frame := ir.init_frame_ir()
	defer ir.destroy_frame_ir(&frame)

	pass := ir.add_pass(&frame, {kind = .Render, name = "main"})
	pipeline := ir.add_graphics_pipeline(&frame, "quads", ir.default_graphics_pipeline_state())
	_ = ir.add_draw_packet(
		&frame,
		pass,
		pipeline,
		.Quad_Stream,
		{
			target = ir.Target_Handle(99),
			layer = ir.Layer_Handle(99),
			geometry = {kind = .Quad_Stream, resource = ir.Resource_Handle(99), vertex_count = 6},
			order = .Strict,
		},
		6,
		1,
	)

	diagnostics := ir.init_diagnostics()
	defer ir.destroy_diagnostics(&diagnostics)
	ir.validate_intent_handles(&frame, &diagnostics)
	testing.expect_value(t, len(diagnostics.items), 3)
}