const QuitText = struct {
    const text = "Press ctrl+c to quit.";

    pub fn element(this: *@This()) App.Element {
        return .{
            .ptr = this,
            .vtable = &.{
                .minSize = minSize,
                .content = content,
            },
        };
    }

    fn minSize(_: *anyopaque, _: *const App.Model, size: zterm.Point) zterm.Point {
        return .{ .x = size.x, .y = 10 }; // this includes the border
    }

    pub fn content(ctx: *anyopaque, _: *const App.Model, cells: []zterm.Cell, size: zterm.Point) !void {
        _ = ctx;
        assert(cells.len == @as(usize, size.x) * @as(usize, size.y));

        const y = 0;
        const x = size.x / 2 -| (text.len / 2);
        const anchor = (y * size.x) + x;

        for (text, 0..) |cp, idx| {
            cells[anchor + idx].style.fg = .white;
            cells[anchor + idx].style.emphasis = &.{.bold};
            cells[anchor + idx].cp = cp;

            // NOTE do not write over the contents of this `Container`'s `Size`
            if (anchor + idx == cells.len - 1) break;
        }
    }
};

const Prompt = struct {
    len: u16 = 5,
    pub fn element(this: *@This()) App.Element {
        return .{
            .ptr = this,
            .vtable = &.{
                // .minSize = minSize,
                .content = content,
            },
        };
    }

    // fn minSize(ctx: *anyopaque, _: *const App.Model, _: zterm.Point) zterm.Point {
    //     const this: *@This() = @ptrCast(@alignCast(ctx));
    //     return .{ .x = this.len, .y = 1 };
    // }

    pub fn content(ctx: *anyopaque, _: *const App.Model, cells: []zterm.Cell, size: zterm.Point) !void {
        const this: *@This() = @ptrCast(@alignCast(ctx));
        assert(cells.len > 2); // expect at least two cells
        assert(cells.len == @as(usize, size.x) * @as(usize, size.y));

        for (0..this.len) |idx| {
            cells[idx].style.bg = .red;
            cells[idx].style.fg = .black;
            cells[idx].style.emphasis = &.{.bold};
        }
        cells[this.len - 1].style.cursor = true; // marks the actual end of the rendering!

        const anchor = 1;
        cells[anchor + 0].cp = 'N';
        cells[anchor + 1].cp = 'O';
        cells[anchor + 2].cp = 'R';
    }
};

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

    var allocator: std.heap.DebugAllocator(.{}) = .init;
    defer if (allocator.deinit() == .leak) log.err("memory leak", .{});

    const gpa = allocator.allocator();

    var app: App = .init(.{}, .{});
    var renderer = zterm.Renderer.Direct.init(gpa);
    defer renderer.deinit();

    var container: App.Container = try .init(gpa, .{
        .layout = .{
            .direction = .vertical,
        },
        .size = .{
            .grow = .horizontal_only,
        },
    }, .{});
    defer container.deinit();

    var quit_text: QuitText = .{};
    var intermediate: App.Container = try .init(gpa, .{
        .border = .{
            .sides = .all,
        },
        .layout = .{
            .direction = .horizontal,
        },
    }, quit_text.element());
    try intermediate.append(try .init(gpa, .{
        .rectangle = .{ .fill = .blue },
    }, .{}));

    try intermediate.append(try .init(gpa, .{
        .rectangle = .{ .fill = .green },
    }, .{}));
    try container.append(intermediate);

    var prompt: Prompt = .{};
    try container.append(try .init(gpa, .{
        .rectangle = .{ .fill = .red },
        .size = .{
            .dim = .{ .y = 1 },
        },
    }, prompt.element()));

    try app.start(.direct); // needs to become configurable, as what should be enabled / disabled (i.e. show cursor, hide cursor, use alternate screen, etc.)
    defer app.stop() catch |err| log.err("Failed to stop application: {any}", .{err});

    // event loop
    event: while (true) {
        // batch events since last iteration
        const len = blk: {
            app.queue.poll();
            app.queue.lock();
            defer app.queue.unlock();
            break :blk app.queue.len();
        };

        // handle events
        for (0..len) |_| {
            const event = app.queue.pop();
            log.debug("received event: {s}", .{@tagName(event)});

            // pre event handling
            switch (event) {
                // NOTE maybe I want to decouple the `key`s from the user input too? i.e. this only makes sense if the output is not echoed!
                // otherwise just use gnu's `readline`?
                .key => |key| {
                    // if (key.eql(.{ .cp = 'q' })) app.quit();
                    _ = key;
                },
                // NOTE errors could be displayed in another container in case one was received, etc. to provide the user with feedback
                .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
                else => {},
            }

            // NOTE returned errors should be propagated back to the application
            container.handle(&app.model, event) catch |err| app.postEvent(.{
                .err = .{
                    .err = err,
                    .msg = "Container Event handling failed",
                },
            });

            // post event handling
            switch (event) {
                .quit => break :event,
                else => {},
            }
        }
        // if there are more events to process continue handling them otherwise I can render the next frame
        if (app.queue.len() > 0) continue :event;

        container.resize(&app.model, try renderer.resize());
        container.reposition(&app.model, .{});
        try renderer.render(@TypeOf(container), &container, App.Model, &app.model);
        try renderer.flush();
    }
}

pub const panic = App.panic_handler;
const log = std.log.scoped(.default);

const std = @import("std");
const assert = std.debug.assert;
const zterm = @import("zterm");
const input = zterm.input;
const App = zterm.App(struct {}, union(enum) {});