const std = @import("std");
const zterm = @import("zterm");

const App = zterm.App(union(enum) {});
const Key = zterm.Key;

const log = std.log.scoped(.example);

pub fn main() !void {
    errdefer |err| log.err("Application Error: {any}", .{err});

    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer {
        const deinit_status = gpa.deinit();
        if (deinit_status == .leak) {
            log.err("memory lead", .{});
        }
    }
    const allocator = gpa.allocator();

    var app: App = .{};
    var renderer = zterm.Renderer.Buffered.init(allocator);
    defer renderer.deinit();

    var container = try App.Container.init(allocator, .{});
    defer container.deinit();

    // NOTE: should the min-size here be required?
    try app.start(null);
    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});

    // event loop
    while (true) {
        const event = app.nextEvent();
        log.debug("received event: {s}", .{@tagName(event)});

        switch (event) {
            .init => {
                if (container.handle(event)) |e| app.postEvent(e);
                continue;
            },
            .quit => break,
            .resize => |size| try renderer.resize(size),
            .key => |key| {
                if (key.matches(.{ .cp = 'q' }))
                    app.quit();
            },
            .err => |err| {
                log.err("Received {any} with message: {s}", .{ @errorName(err.err), err.msg });
            },
            else => {},
        }

        // TODO: should instead use tryPost because it may block the main loop from actually removing events from the queue, deadlocking itself
        if (container.handle(event)) |e| app.postEvent(e);
        renderer.render(@TypeOf(container), &container);
        try renderer.flush();
    }
}