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

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

    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 row = 2;
        const col = size.x / 2 -| (text.len / 2);
        const anchor = (row * size.x) + col;

        for (text, 0..) |cp, idx| {
            cells[anchor + idx].style.fg = .white;
            cells[anchor + idx].style.bg = .black;
            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 Clickable = struct {
    const text = "Press me";

    queue: *App.Queue,
    color: zterm.Color = .black,

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

    fn handle(ctx: *anyopaque, _: *App.Model, event: App.Event) !void {
        const this: *@This() = @ptrCast(@alignCast(ctx));
        switch (event) {
            .mouse => |mouse| if (mouse.button == .left and mouse.kind == .release) {
                var value = @intFromEnum(this.color);
                value += 1;
                value %= 17;
                if (value == 0) value = 1;
                this.color = @enumFromInt(value);
                this.queue.push(.{ .click = @tagName(mouse.button) });
            },
            else => {},
        }
    }

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

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

        for (text, 0..) |cp, idx| {
            cells[anchor + idx].style.fg = this.color;
            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;
        }
    }
};

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

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

    const allocator = gpa.allocator();

    var threaded_io: std.Io.Threaded = .init(allocator, .{});
    defer threaded_io.deinit();

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

    var clickable: Clickable = .{ .queue = &app.queue };
    const element = clickable.element();

    var button: App.Button(.accept) = .init(&app.queue, .init(.default, "Button"));

    var quit_text: QuitText = .{};

    var container = try App.Container.init(allocator, .{
        .rectangle = .{ .fill = .grey },
        .layout = .{ .padding = .all(5) },
    }, quit_text.element());
    defer container.deinit();

    try container.append(try App.Container.init(allocator, .{ .rectangle = .{ .fill = .lightgrey } }, element));
    try container.append(try App.Container.init(allocator, .{ .rectangle = .{ .fill = .black } }, button.element()));

    try app.start();
    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)});

        // pre event handling
        switch (event) {
            .key => |key| if (key.eql(.{ .cp = 'c', .mod = .{ .ctrl = true } })) app.quit(),
            .click => |b| log.info("Clicked with mouse using Button: {s}", .{b}),
            .accept => log.info("Clicked built-in button using the mouse", .{}),
            .err => |err| log.err("Received {s} with message: {s}", .{ @errorName(err.err), err.msg }),
            else => {},
        }

        container.handle(&app.model, event) catch |err| app.postEvent(.{
            .err = .{
                .err = err,
                .msg = "Container Event handling failed",
            },
        });

        // post event handling
        switch (event) {
            .quit => break,
            else => {},
        }

        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 App = zterm.App(
    struct {},
    union(enum) {
        click: [:0]const u8,
        accept,
    },
);