const std = @import("std");
const vaxis = @import("vaxis");
const ghostty_vt = @import("ghostty-vt");

extern "c" fn forkpty(
    amaster: *c_int,
    name: ?[*:0]u8,
    termp: ?*const anyopaque,
    winp: ?*const std.posix.winsize,
) c_int;

extern "c" fn execvp(
    file: [*:0]const u8,
    argv: [*:null]const ?[*:0]const u8,
) c_int;

extern "c" fn _exit(status: c_int) noreturn;

// basic file navigation
// basic shell io
// basic layouting: for now following acme and ad
// * /home/goblin/05-genizah/plan9port/src/cmd/acme
// * /home/goblin/05-genizah/ad
// * /usr/lib/zig
// * ../03-plano
// right click and enter on lines to open files at specified lines

pub const Command = struct {
    prev: ?*Command = null,
    pub var value: union(enum) {
        close,
        ping,
        nop,
        quit,
        tick,
        key_press: vaxis.Key,
        pty_read: []u8,
        winsize: vaxis.Winsize,
        mouse: vaxis.Mouse,
    } = .nop;
};

const Loop = vaxis.Loop(@TypeOf(Command.value));
const MAX_LINES: usize = 0x1000;
const MAX_LINE_LEN: usize = 0x200;
const MAX_HISTORY: usize = 0x100;
const FILE_PANE: usize = 0;
const TTY_PANE: usize = 1;

fn ticker(io: std.Io, loop: *Loop) void {
    while (true) {
        io.sleep(.fromMilliseconds(2), .awake) catch return;
        _ = loop.tryPostEvent(.tick) catch return;
    }
}

fn fork_pty(argv: [:0]const u8, ws: std.posix.winsize) std.Io.File {
    var master: c_int = undefined;
    const pid = forkpty(&master, null, null, &ws);
    if (pid == 0) {
        const child_argv = [_:null]?[*:0]const u8{ argv.ptr, null };
        _ = execvp(argv.ptr, &child_argv);
        _exit(127);
    }

    // not sure about the false here
    const f: std.Io.File = .{ .handle = master, .flags = .{ .nonblocking = false } };
    return f;
}

fn readPty(io: std.Io, gpa: std.mem.Allocator, pty: std.Io.File, loop: *Loop) !void {
    var read_buf: [0x1000]u8 = undefined;
    var reader = pty.readerStreaming(io, &read_buf);
    while (true) {
        var buf: [0x1000]u8 = undefined;
        var vec = [_][]u8{&buf};
        const n = try reader.interface.readVec(&vec);
        if (n == 0) break;
        const bytes = try gpa.dupe(u8, buf[0..n]);
        errdefer gpa.free(bytes);
        try loop.postEvent(.{ .pty_read = bytes });
    }
    try loop.postEvent(.quit);
}

fn putLine(lines: *[MAX_LINES][MAX_LINE_LEN]u8, idx: usize, text: []const u8) void {
    const len = @min(text.len, MAX_LINE_LEN - 1);
    @memcpy(lines[idx][0..len], text[0..len]);
    lines[idx][len] = 0;
}

fn putString(buf: *[MAX_LINE_LEN]u8, text: []const u8) usize {
    const len = @min(text.len, MAX_LINE_LEN - 1);
    @memcpy(buf[0..len], text[0..len]);
    buf[len] = 0;
    return len;
}

fn pathFrom(base: []const u8, name: []const u8, buf: *[MAX_LINE_LEN]u8) []const u8 {
    if (std.fs.path.isAbsolute(name)) {
        const len = putString(buf, name);
        return buf[0..len];
    }

    return std.fmt.bufPrint(buf, "{s}/{s}", .{ base, name }) catch blk: {
        const len = putString(buf, name);
        break :blk buf[0..len];
    };
}

fn splitLines(lines: *[MAX_LINES][MAX_LINE_LEN]u8, text: []const u8) usize {
    var iter = std.mem.splitScalar(u8, text, '\n');
    var i: usize = 0;
    while (iter.next()) |line| : (i += 1) {
        if (i >= MAX_LINES) break;
        putLine(lines, i, line);
    }
    if (i == 0) {
        putLine(lines, 0, "");
        i = 1;
    }
    return i;
}

fn extractWord(str: []const u8, i: usize) []const u8 {
    if (str.len == 0) return "";
    var l = @min(i, str.len - 1);
    var r = @min(i, str.len);

    while (l > 0 and !std.ascii.isWhitespace(str[l - 1])) : (l -= 1) {}
    while (r < str.len and !std.ascii.isWhitespace(str[r])) : (r += 1) {}

    var word = str[l..r];
    word = std.mem.trim(u8, word, " \t\r\n\"'`()[]{}<>;,");
    if (std.mem.indexOfScalar(u8, word, ':')) |colon| {
        word = word[0..colon];
    }
    return word;
}

fn loadFile(
    io: std.Io,
    gpa: std.mem.Allocator,
    path: []const u8,
    lines: *[MAX_LINES][MAX_LINE_LEN]u8,
    rendered_lines: *usize,
    current_path: *[MAX_LINE_LEN]u8,
    current_path_len: *usize,
) !void {
    const path_len = @min(path.len, MAX_LINE_LEN - 1);
    @memcpy(current_path[0..path_len], path[0..path_len]);
    current_path[path_len] = 0;
    current_path_len.* = path_len;

    var file = std.Io.Dir.cwd().openFile(io, path, .{ .mode = .read_only }) catch |err| {
        const msg = try std.fmt.bufPrint(&lines[0], "could not open {s}: {}", .{ path, err });
        lines[0][msg.len] = 0;
        rendered_lines.* = 1;
        return;
    };
    defer file.close(io);

    var read_buf: [0x1000]u8 = undefined;
    const flen = try file.length(io);
    var reader = file.reader(io, &read_buf);
    const text = reader.interface.readAlloc(gpa, @min(flen, 0x100000)) catch |err| {
        const msg = try std.fmt.bufPrint(&lines[0], "could not read {s}: {}", .{ path, err });
        lines[0][msg.len] = 0;
        rendered_lines.* = 1;
        return;
    };
    defer gpa.free(text);

    rendered_lines.* = splitLines(lines, text);
}

fn ghostColor(color: ghostty_vt.Style.Color) vaxis.Color {
    return switch (color) {
        .none => .default,
        .palette => |idx| .{ .index = idx },
        .rgb => |rgb| .{ .rgb = .{ rgb.r, rgb.g, rgb.b } },
    };
}

fn cellStyle(cell_info: ghostty_vt.PageList.Cell) vaxis.Style {
    const style = cell_info.style();
    var vstyle: vaxis.Style = .{};
    vstyle.fg = ghostColor(style.fg_color);
    vstyle.bg = ghostColor(style.bg_color);
    vstyle.bold = style.flags.bold;
    vstyle.dim = style.flags.faint;
    vstyle.italic = style.flags.italic;
    vstyle.blink = style.flags.blink;
    vstyle.reverse = style.flags.inverse;
    vstyle.invisible = style.flags.invisible;
    vstyle.strikethrough = style.flags.strikethrough;
    vstyle.ul_style = switch (style.flags.underline) {
        .none => .off,
        .single => .single,
        .double => .double,
        .curly => .curly,
        .dotted => .dotted,
        .dashed => .dashed,
    };

    switch (cell_info.cell.content_tag) {
        .bg_color_palette => vstyle.bg = .{ .index = cell_info.cell.content.color_palette.data },
        .bg_color_rgb => {
            const rgb = cell_info.cell.content.color_rgb;
            vstyle.bg = .{ .rgb = .{ rgb.r, rgb.g, rgb.b } };
        },
        else => {},
    }

    return vstyle;
}

fn appendCp(buf: *[MAX_LINE_LEN]u8, len: *usize, cp: u21) void {
    if (cp == 0) {
        if (len.* < buf.len) {
            buf[len.*] = ' ';
            len.* += 1;
        }
        return;
    }

    if (len.* + 4 > buf.len) return;
    const n = std.unicode.utf8Encode(cp, buf[len.*..]) catch return;
    len.* += n;
}

const nrows = 64;
const ncols = 100;

pub fn main(init: std.process.Init) !void {
    const io = init.io;
    const gpa = init.gpa;
    const args = try init.minimal.args.toSlice(init.arena.allocator());

    var term: ghostty_vt.Terminal = try .init(gpa, .{
        .cols = ncols,
        .rows = nrows,
    });
    defer term.deinit(gpa);
    var term_stream = term.vtStream();
    defer term_stream.deinit();

    var tty_buf: [0x10000]u8 = undefined;
    var display_lines: [2][MAX_LINES][MAX_LINE_LEN]u8 = undefined;
    var tty_render_lines: [MAX_LINES][MAX_LINE_LEN]u8 = undefined;
    var rendered_lines = [_]usize{ 0, 0 };
    var line_nums: [MAX_LINES][8]u8 = undefined;
    var file_scroll: usize = 0;
    var current_path: [MAX_LINE_LEN]u8 = undefined;
    var current_path_len: usize = 0;
    var term_cwd: [MAX_LINE_LEN]u8 = undefined;
    var term_cwd_len = putString(&term_cwd, init.environ_map.get("PWD") orelse ".");
    var cwd_history: [MAX_HISTORY][MAX_LINE_LEN]u8 = undefined;
    var cwd_history_lens: [MAX_HISTORY]usize = undefined;
    var cwd_history_len: usize = 0;
    try loadFile(
        io,
        gpa,
        if (args.len > 1) args[1] else "main.zig",
        &display_lines[FILE_PANE],
        &rendered_lines[FILE_PANE],
        &current_path,
        &current_path_len,
    );

    var tty = try vaxis.Tty.init(io, &tty_buf);

    var vx = try vaxis.init(io, gpa, init.environ_map, .{});
    defer vx.deinit(gpa, tty.writer());

    const pty_master = fork_pty("/usr/bin/bash", .{
        .row = nrows,
        .col = ncols,
        .xpixel = 0,
        .ypixel = 0,
    });

    var write_buf: [0x100]u8 = undefined;
    var writer = pty_master.writer(io, &write_buf);

    std.debug.print("written {}\n", .{try writer.interface.write("ls /\r\n")});
    try writer.flush();

    try vx.setMouseMode(tty.writer(), true);
    try vx.enterAltScreen(tty.writer());
    defer vx.exitAltScreen(tty.writer()) catch {};

    var loop: Loop = .init(io, &tty, &vx);
    try loop.start();
    defer loop.stop();

    var pty_reader = try io.concurrent(readPty, .{ io, gpa, pty_master, &loop });
    defer _ = pty_reader.cancel(io) catch {};
    defer pty_master.close(io);

    var mouse_seen = false;
    var mouse_row: i16 = 0;
    var mouse_col: i16 = 0;

    while (true) {
        const event = try loop.nextEvent();
        const win = vx.window();
        const left_outer_width: u16 = @max(1, win.width / 2);
        const right_x: i16 = @intCast(left_outer_width);
        switch (event) {
            .mouse => |mouse| {
                mouse_seen = true;
                mouse_row = mouse.row;
                mouse_col = mouse.col;

                const mouse_on_left = mouse.col < right_x;

                if (mouse.button == .wheel_down) {
                    if (mouse_on_left) {
                        if (file_scroll + 1 < rendered_lines[FILE_PANE]) file_scroll += 1;
                    } else {
                        term.screens.active.scroll(.{ .delta_row = 1 });
                    }
                }

                if (mouse.button == .wheel_up) {
                    if (mouse_on_left) {
                        if (file_scroll > 0) file_scroll -= 1;
                    } else {
                        term.screens.active.scroll(.{ .delta_row = -1 });
                    }
                }

                if (mouse.type == .press and (mouse.button == .left or mouse.button == .right)) {
                    var selected_word: ?[]const u8 = null;

                    if (mouse_on_left) {
                        if (mouse.row > 0 and mouse.col >= 5) {
                            const line_idx = @as(usize, @intCast(mouse.row - 1)) + file_scroll;
                            if (line_idx < rendered_lines[FILE_PANE]) {
                                const len = std.mem.findSentinel(u8, 0, @ptrCast(&display_lines[FILE_PANE][line_idx]));
                                const selected_col: usize = @intCast(mouse.col - 5);
                                const selected_line = display_lines[FILE_PANE][line_idx][0..len];
                                selected_word = extractWord(selected_line, selected_col);
                            }
                        }
                    } else {
                        const line_idx: usize = @intCast(@max(mouse.row, 0));
                        if (line_idx < rendered_lines[TTY_PANE]) {
                            const len = std.mem.findSentinel(u8, 0, @ptrCast(&display_lines[TTY_PANE][line_idx]));
                            const selected_col: usize = @intCast(@max(mouse.col - right_x, 0));
                            const selected_line = display_lines[TTY_PANE][line_idx][0..len];
                            selected_word = extractWord(selected_line, selected_col);
                        }
                    }

                    if (selected_word) |word| {
                        if (word.len > 0) {
                            var found_path_buf: [MAX_LINE_LEN]u8 = undefined;
                            var candidate_buf: [MAX_LINE_LEN]u8 = undefined;
                            var found_path: []const u8 = "";
                            var found_kind: ?std.Io.File.Kind = null;

                            const current_candidate = pathFrom(term_cwd[0..term_cwd_len], word, &candidate_buf);
                            if (std.Io.Dir.cwd().statFile(io, current_candidate, .{})) |stat| {
                                const found_len = putString(&found_path_buf, current_candidate);
                                found_path = found_path_buf[0..found_len];
                                found_kind = stat.kind;
                            } else |_| {}

                            var h = cwd_history_len;
                            while (found_kind == null and h > 0) {
                                h -= 1;
                                const old_cwd = cwd_history[h][0..cwd_history_lens[h]];
                                const candidate = pathFrom(old_cwd, word, &candidate_buf);
                                if (std.Io.Dir.cwd().statFile(io, candidate, .{})) |stat| {
                                    const found_len = putString(&found_path_buf, candidate);
                                    found_path = found_path_buf[0..found_len];
                                    found_kind = stat.kind;
                                } else |_| {}
                            }

                            if (found_kind) |kind| {
                                if (kind == .directory) {
                                    if (cwd_history_len < MAX_HISTORY) {
                                        cwd_history_lens[cwd_history_len] = putString(&cwd_history[cwd_history_len], term_cwd[0..term_cwd_len]);
                                        cwd_history_len += 1;
                                    }
                                    term_cwd_len = putString(&term_cwd, found_path);

                                    try writer.interface.writeAll("cd ");
                                    try writer.interface.writeAll(found_path);
                                    try writer.interface.writeAll(" && ls\r");
                                    try writer.flush();
                                    if (!mouse_on_left) term.scrollViewport(.bottom);
                                } else {
                                    loadFile(io, gpa, found_path, &display_lines[FILE_PANE], &rendered_lines[FILE_PANE], &current_path, &current_path_len) catch {};
                                    file_scroll = 0;
                                }
                            }
                        }
                    }
                }
            },
            .key_press => |key| {
                if (key.matches('c', .{ .ctrl = true })) {
                    break;
                }

                if (key.matches('k', .{ .ctrl = true })) {
                    win.clear();
                }

                // this is not what I expected; it's just blank up or down
                // if (key.matches('d', .{ .ctrl = true })) {
                //     try term.scrollUp(1);
                // }

                if (key.matches('d', .{ .ctrl = true })) {
                    term.screens.active.scroll(.{ .delta_row = 15 });
                }
                if (key.matches('u', .{ .ctrl = true })) {
                    term.screens.active.scroll(.{ .delta_row = -15 });
                }

                if (key.text) |text| {
                    try writer.interface.writeAll(text);
                } else switch (key.codepoint) {
                    vaxis.Key.enter => try writer.interface.writeAll("\r"),
                    vaxis.Key.backspace => try writer.interface.writeAll("\x7f"),
                    vaxis.Key.tab => try writer.interface.writeAll("\t"),
                    vaxis.Key.escape => try writer.interface.writeAll("\x1b"),
                    vaxis.Key.up => try writer.interface.writeAll("\x1b[A"),
                    vaxis.Key.down => try writer.interface.writeAll("\x1b[B"),
                    vaxis.Key.right => try writer.interface.writeAll("\x1b[C"),
                    vaxis.Key.left => try writer.interface.writeAll("\x1b[D"),
                    else => {},
                }
                try writer.flush();
            },
            .pty_read => |bytes| {
                defer gpa.free(bytes);
                term_stream.nextSlice(bytes);
            },
            .winsize => |ws| try vx.resize(gpa, tty.writer(), ws),
            .quit => break,
            else => {},
        }

        // term.scrollViewport(.bottom);
        const tty_str = try term.plainString(gpa);
        defer gpa.free(tty_str);
        rendered_lines[TTY_PANE] = splitLines(&display_lines[TTY_PANE], tty_str);

        const win_file = win.child(.{
            .border = .{ .where = .right },
            .width = left_outer_width,
        });
        const win_term = win.child(.{
            .x_off = @intCast(left_outer_width),
            .width = win.width -| left_outer_width,
        });

        win.clear();
        _ = win_file.printSegment(.{ .text = current_path[0..current_path_len] }, .{
            .row_offset = 0,
            .col_offset = 5,
            .wrap = .none,
        });

        const visible_lines = if (win_file.height > 1) win_file.height - 1 else 0;
        var i: usize = 0;
        while (i < visible_lines and i + file_scroll < rendered_lines[FILE_PANE]) : (i += 1) {
            const line_idx = i + file_scroll;
            const len = std.mem.findSentinel(u8, 0, @ptrCast(&display_lines[FILE_PANE][line_idx]));
            const num = try std.fmt.bufPrint(&line_nums[i], "{d:0>4}", .{line_idx + 1});
            _ = win_file.printSegment(.{ .text = num }, .{
                .row_offset = @intCast(i + 1),
                .col_offset = 0,
                .wrap = .none,
            });
            _ = win_file.printSegment(.{ .text = display_lines[FILE_PANE][line_idx][0..len] }, .{
                .row_offset = @intCast(i + 1),
                .col_offset = 5,
                .wrap = .none,
            });
        }

        i = 0;
        while (i < win_term.height and i < MAX_LINES) : (i += 1) {
            var len: usize = 0;
            var span_start: usize = 0;
            var span_col: usize = 0;
            var span_style: vaxis.Style = .{};
            var span_open = false;

            var col: usize = 0;
            while (col < win_term.width and col < ncols and len < MAX_LINE_LEN - 4) : (col += 1) {
                const cell_info = term.screens.active.pages.getCell(.{ .viewport = .{
                    .x = @intCast(col),
                    .y = @intCast(i),
                } }) orelse continue;

                if (cell_info.cell.wide == .spacer_tail) continue;

                const style = cellStyle(cell_info);
                if (!span_open) {
                    span_open = true;
                    span_start = len;
                    span_col = col;
                    span_style = style;
                } else if (!vaxis.Style.eql(span_style, style)) {
                    _ = win_term.printSegment(.{
                        .text = tty_render_lines[i][span_start..len],
                        .style = span_style,
                    }, .{
                        .row_offset = @intCast(i),
                        .col_offset = @intCast(span_col),
                        .wrap = .none,
                    });
                    span_start = len;
                    span_col = col;
                    span_style = style;
                }

                switch (cell_info.cell.content_tag) {
                    .codepoint, .codepoint_grapheme => {
                        appendCp(&tty_render_lines[i], &len, cell_info.cell.codepoint());
                        if (cell_info.cell.hasGrapheme()) {
                            if (cell_info.node.data.lookupGrapheme(cell_info.cell)) |grapheme| {
                                for (grapheme) |cp| appendCp(&tty_render_lines[i], &len, cp);
                            }
                        }
                    },
                    .bg_color_palette, .bg_color_rgb => appendCp(&tty_render_lines[i], &len, ' '),
                }
            }

            if (span_open and len > span_start) {
                _ = win_term.printSegment(.{
                    .text = tty_render_lines[i][span_start..len],
                    .style = span_style,
                }, .{
                    .row_offset = @intCast(i),
                    .col_offset = @intCast(span_col),
                    .wrap = .none,
                });
            }
        }
        win_term.showCursor(term.screens.active.cursor.x, term.screens.active.cursor.y);

        if (mouse_seen and mouse_row >= 0 and mouse_col >= 0 and mouse_row < win.height and mouse_col < win.width) {
            _ = win.printSegment(.{ .text = "@", .style = .{ .reverse = true, .bold = true } }, .{
                .row_offset = @intCast(mouse_row),
                .col_offset = @intCast(mouse_col),
                .wrap = .none,
            });
        }

        try vx.render(tty.writer());
    }
}