const std = @import("std");
const terminal = @import("terminal.zig");
const zlog = @import("zlog");

const App = @import("app.zig").App(
    union(enum) {},
    @import("render.zig").PlainRenderer,
    true,
);
const Key = @import("key.zig");

pub const std_options = zlog.std_options;
const log = std.log.scoped(.default);

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

    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .{};
    defer {
        const deinit_status = gpa.deinit();
        // fail test; can't try in defer as defer is executed after we return
        if (deinit_status == .leak) {
            log.err("memory leak", .{});
        }
    }
    const allocator = gpa.allocator();

    var app: App = .{};
    var renderer: App.Renderer = .{};

    var rawText = App.Widget.RawText.init(allocator);
    const widget = App.Widget.createFrom(&rawText);
    var layout = App.Layout.Pane.init(allocator, widget);
    defer layout.deinit(); // deinitializes the contained widget

    try app.start();
    defer app.stop() catch unreachable;

    // App.Event loop
    while (true) {
        const event = app.nextEvent();

        switch (event) {
            .quit => break,
            .key => |key| {
                // ctrl+c to quit
                if (Key.matches(key, .{ .cp = 'c', .mod = .{ .ctrl = true } })) {
                    app.quit();
                }
                if (Key.matches(key, .{ .cp = 'n', .mod = .{ .ctrl = true } })) {
                    try app.interrupt();
                    defer app.start() catch @panic("could not start app event loop");
                    var child = std.process.Child.init(&.{"hx"}, allocator);
                    _ = child.spawnAndWait() catch |err| {
                        app.postEvent(.{
                            .err = .{
                                .err = err,
                                .msg = "Spawning Helix failed",
                            },
                        });
                    };
                }
            },
            .err => |err| {
                log.err("Received {any} with message: {s}", .{ err.err, err.msg });
            },
            else => {},
        }
        // NOTE: this currently re-renders the screen for every key-press -> which might be a bit of an overkill
        const events = try layout.handle(event);
        for (events.items) |e| {
            app.postEvent(e);
        }
        try renderer.render(try layout.content());
    }
    // TODO: I could use the ascii codes in vaxis
    // - see https://gist.github.com/ConnerWill/d4b6c776b509add763e17f9f113fd25b
    // how would I draw?
    // use array for screen contents? <-> support partial re-draws
    // support widget type drawing similar to the already existing widgets
    // determine the corresponding capabilities of the terminal?
    // support layouts
    // - contents of corresponding locations
    // resize event
}

test {
    _ = @import("queue.zig");
}