const std = @import("std");
const drm = @import("drm/root.zig");
const graphics = @import("estd").graphics;

pub fn main() !void {
	var gpa = std.heap.GeneralPurposeAllocator(.{}){};
	const allocator = gpa.allocator();

	var card = try drm.Card.open("card0", allocator);
	defer card.close();

	var resources = try card.resources();
	defer resources.deinit();

	var connector = try resources.connector(0);
	defer connector.deinit();

	const mode = connector.modes[12];
	std.debug.print("using mode: {s}@{d:.2}\n", .{mode.name, mode.frame_rate()});

	var crtc = try resources.crtc(
		connector.compatible_crtc() orelse @panic("no crtc found")
	);
	defer crtc.detach();

	var buffer = try card.create_buffer(mode.horizontal.size, mode.vertical.size);
	defer buffer.deinit();

	try crtc.attach(&buffer, &connector, mode);

	const center_x = (buffer.current.width / 2);
	const center_y = (buffer.current.height / 2);

	var line = graphics.Line {
		.start = .{ .x = center_x, .y = center_y },
		.end = .{ .x = center_x + 110 , .y = center_y + 100  },
		.color = .{ .red = 0xff, .green = 0, .blue = 0 },
	};

	var last_duration: f64 = 0;
	var delta: f64 = 0;
	var angle: f64 = 0;

	while (true) {
		const start = try std.time.Instant.now();
		const canvas = buffer.canvas();

		canvas.fill(.{ .red = 0x25, .green = 0x25, .blue = 0x25 });

		(graphics.Box {
			.x = center_x - 100,
			.y = center_y - 100,
			.width = 200,
			.height = 200,
			.radius = 100,
			.color = .{ .red = 0xff, .green = 0xff, .blue = 0xff },
		}).render(&canvas);

		line.render(&canvas);
		const cos = @cos(std.math.degreesToRadians(angle));
		const sin = @sin(std.math.degreesToRadians(angle));
		line.end.x = @intCast(@as(i64, @intCast(center_x)) + @as(i64, @intFromFloat(100 * cos)));
		line.end.y = @intCast(@as(i64, @intCast(center_y)) + @as(i64, @intFromFloat(100 * sin)));

		angle += delta;
		if (angle > 360) {
			angle = 0;
		}

		const end = try std.time.Instant.now();
		const duration: f64 = @floatFromInt(end.since(start));
		const average = (duration + last_duration) / 2;
		last_duration = duration;
		std.debug.print("@FPS: {d:.3}\r", .{ std.time.ns_per_s / average });
		delta = 60 * last_duration / std.time.ns_per_s;

		try crtc.page_flip(&buffer);

		while (true) {
			var event: ?drm.Event = null;
			while (event == null) {
				event = try card.poll_event(5000);
			}

			switch ((event orelse unreachable).kind) {
				.page_flip_complete => break,
				else => {},
			}
		}
	}
}