const std = @import("std");
const context_mod = @import("context.zig");
const diagnostics = @import("diagnostics.zig");
const input = @import("input.zig");
const job = @import("job.zig");
const layout = @import("layout.zig");
const leader = @import("leader.zig");
const lsp = @import("lsp.zig");
const mobile_acceptance = @import("mobile_acceptance.zig");
const panel = @import("panel.zig");
const pi_bridge = @import("pi_bridge.zig");
const profile = @import("profile.zig");
const protocol = @import("protocol.zig");
const replay = @import("replay.zig");
const repo = @import("repo.zig");
const session = @import("session.zig");
const socket = @import("socket.zig");
const symbol = @import("symbol.zig");
const syntax = @import("syntax.zig");
const terminal_debug = @import("terminal_debug.zig");
const tui = @import("tui.zig");

pub const version = "0.1.0-dev";

const help_text =
    \\mim - mobile-first terminal code editor for SSH sessions
    \\
    \\Usage:
    \\  mim [path]
    \\  mim [--help]
    \\  mim [--version]
    \\  mim context [task] [intent]
    \\  mim profile
    \\  mim mimctl context <socket|-> [task] [intent]
    \\  mim --mimctl <socket|-> <request...>
    \\
    \\With no path, mim opens the current directory. Existing files open in the
    \\editor; missing paths start a new buffer; directories open the file browser.
    \\This early build also exposes compact local context and mimctl for trusted tools.
    \\
;

const Command = union(enum) {
    help,
    version,
    open: []const u8,
};

fn parseArgs(args: []const []const u8) Command {
    if (args.len <= 1) return .{ .open = "." };

    const arg = args[1];
    if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) return .help;
    if (std.mem.eql(u8, arg, "--version")) return .version;
    return .{ .open = arg };
}

fn versionText() []const u8 {
    return "mim " ++ version ++ "\n";
}

pub fn main(init: std.process.Init) !u8 {
    var debug_allocator = std.heap.DebugAllocator(.{}){};
    defer _ = debug_allocator.deinit();
    const allocator = debug_allocator.allocator();

    var args = std.process.Args.Iterator.init(init.minimal.args);
    _ = args.skip();

    const stdout = std.Io.File.stdout();
    const stderr = std.Io.File.stderr();

    const first_arg = args.next();
    if (first_arg) |arg| {
        if (std.mem.eql(u8, arg, "context")) {
            try printLocalContext(allocator, init.io, &args, stdout);
            return 0;
        }
        if (std.mem.eql(u8, arg, "profile")) {
            try printProfile(allocator, init.io, stdout);
            return 0;
        }
        if (isProfileStub(arg)) {
            try printProfileStub(init.io, stderr, arg);
            return 69;
        }
        if (std.mem.eql(u8, arg, "mimctl")) {
            if (!profile.local_socket) {
                try printProfileStub(init.io, stderr, "mimctl");
                return 69;
            }
            const sub = args.next() orelse {
                try stderr.writeStreamingAll(init.io, "mim: mimctl requires a subcommand\n");
                return 64;
            };
            if (!std.mem.eql(u8, sub, "context")) {
                try stderr.writeStreamingAll(init.io, "mim: unknown mimctl subcommand\n");
                return 64;
            }
            const socket_path = args.next() orelse {
                try stderr.writeStreamingAll(init.io, "mim: mimctl context requires a socket path or '-'\n");
                return 64;
            };
            const line = try collectContextRequest(allocator, &args);
            defer allocator.free(line);
            requestMimctl(allocator, init.io, init.minimal.environ, stdout, stderr, socket_path, line) catch return 69;
            return 0;
        }

        if (std.mem.eql(u8, arg, "--mimctl")) {
            if (!profile.local_socket) {
                try printProfileStub(init.io, stderr, "mimctl");
                return 69;
            }
            const socket_path = args.next() orelse {
                try stderr.writeStreamingAll(init.io, "mim: --mimctl requires a socket path\n");
                return 64;
            };
            const line = try collectRemainingArgs(allocator, &args);
            defer allocator.free(line);
            if (line.len == 0) {
                try stderr.writeStreamingAll(init.io, "mim: --mimctl requires a request\n");
                return 64;
            }
            requestMimctl(allocator, init.io, init.minimal.environ, stdout, stderr, socket_path, line) catch return 69;
            return 0;
        }
    }

    var e2e_prelude_path: ?[]const u8 = null;
    var open_arg = first_arg;
    if (first_arg) |arg| {
        if (std.mem.eql(u8, arg, "--e2e-prelude-file")) {
            e2e_prelude_path = args.next() orelse {
                try stderr.writeStreamingAll(init.io, "mim: --e2e-prelude-file requires a path\n");
                return 64;
            };
            open_arg = args.next();
        }
    }
    const command = if (open_arg) |arg|
        parseArgs(&.{ "mim", arg })
    else
        parseArgs(&.{"mim"});

    switch (command) {
        .help => try stdout.writeStreamingAll(init.io, help_text),
        .version => try stdout.writeStreamingAll(init.io, versionText()),
        .open => |path| try openLocalEditor(allocator, init.io, stdout, stderr, path, e2e_prelude_path),
    }

    return 0;
}

fn openLocalEditor(
    allocator: std.mem.Allocator,
    io: std.Io,
    stdout: std.Io.File,
    stderr: std.Io.File,
    path: []const u8,
    e2e_prelude_path: ?[]const u8,
) !void {
    var client = try tui.Client.init(allocator, .{ .width = 80, .height = 22 });
    defer client.deinit();

    const stat = std.Io.Dir.cwd().statFile(io, path, .{}) catch |err| switch (err) {
        error.FileNotFound => null,
        else => {
            try stderr.writeStreamingAll(io, "mim: could not inspect path\n");
            return err;
        },
    };

    if (stat) |metadata| {
        switch (metadata.kind) {
            .directory => try openDirectoryPreview(allocator, io, &client, path),
            .file => {
                if (std.fs.path.dirname(path)) |parent| seedDirectoryRepo(allocator, io, &client, parent) catch {};
                const bytes = std.Io.Dir.cwd().readFileAlloc(io, path, allocator, .limited(diagnostics.max_file_bytes)) catch |err| switch (err) {
                    error.StreamTooLong => {
                        try client.handleTraceLine("open diagnostic:file_too_large");
                        return runLocalEditor(allocator, io, stdout, stderr, &client, path, false, e2e_prelude_path);
                    },
                    else => return err,
                };
                defer allocator.free(bytes);
                const command = try std.fmt.allocPrint(allocator, "open {s}", .{bytes});
                defer allocator.free(command);
                try client.handleTraceLine(command);
            },
            else => try client.handleTraceLine("open diagnostic:unsupported_file"),
        }
    } else {
        try client.handleTraceLine("open ");
    }

    try runLocalEditor(allocator, io, stdout, stderr, &client, path, stat != null and stat.?.kind == .directory, e2e_prelude_path);
}

fn seedDirectoryRepo(allocator: std.mem.Allocator, io: std.Io, client: *tui.Client, path: []const u8) !void {
    var dir = try std.Io.Dir.cwd().openDir(io, path, .{ .iterate = true });
    defer dir.close(io);

    var iterator = dir.iterate();
    var count: usize = 0;
    while (try iterator.next(io)) |entry| {
        if (count >= 80) break;
        if (entry.kind != .file and entry.kind != .directory) continue;
        const relative_path = try std.fmt.allocPrint(allocator, "{s}/{s}{s}", .{ path, entry.name, if (entry.kind == .directory) "/" else "" });
        defer allocator.free(relative_path);
        if (entry.kind == .file) {
            const bytes = std.Io.Dir.cwd().readFileAlloc(io, relative_path, allocator, .limited(diagnostics.max_file_bytes)) catch |err| switch (err) {
                error.StreamTooLong, error.AccessDenied, error.FileNotFound, error.NotDir => null,
                else => null,
            };
            if (bytes) |content| {
                defer allocator.free(content);
                client.addRepoFileContent(relative_path, content) catch {};
            } else {
                client.addRepoFileContent(relative_path, "") catch {};
            }
        } else {
            client.addRepoFileContent(relative_path, "") catch {};
        }
        count += 1;
    }
}

fn openDirectoryPreview(allocator: std.mem.Allocator, io: std.Io, client: *tui.Client, path: []const u8) !void {
    try seedDirectoryRepo(allocator, io, client, path);
    try client.handleTraceLine("file_picker");
}

fn runLocalEditor(
    allocator: std.mem.Allocator,
    io: std.Io,
    stdout: std.Io.File,
    stderr: std.Io.File,
    client: *tui.Client,
    path: []const u8,
    is_dir: bool,
    e2e_prelude_path: ?[]const u8,
) !void {
    const stdin_file = std.Io.File.stdin();
    const interactive = stdin_file.isTty(io) catch false;

    var last_saved = try client.snapshotBytesAlloc(allocator);
    defer allocator.free(last_saved);
    var last_client_saved: ?[]u8 = null;
    defer if (last_client_saved) |bytes| allocator.free(bytes);

    if (e2e_prelude_path) |prelude_path| {
        const prelude = try std.Io.Dir.cwd().readFileAlloc(io, prelude_path, allocator, .limited(64 * 1024));
        defer allocator.free(prelude);
        var lines = std.mem.splitScalar(u8, prelude, '\n');
        while (lines.next()) |line| if (line.len != 0) try client.handleTraceLine(line);
    }

    if (!interactive) {
        try renderLocalFrame(allocator, io, stdout, client, path, is_dir, false);
        return;
    }

    if (is_dir) try client.openFilePicker();

    var raw_terminal = try RawTerminal.enable(stdin_file.handle);
    defer raw_terminal.restore();

    while (true) {
        try renderLocalFrame(allocator, io, stdout, client, path, is_dir, true);
        const raw = try readEditorInputFdAlloc(allocator, stdin_file.handle);
        defer if (raw) |bytes| allocator.free(bytes);
        if (raw == null) return;

        client.handleInput(raw.?) catch |err| {
            if (err == tui.Error.ClientQuit) return;
            try stderr.writeStreamingAll(io, "mim: input failed: ");
            try stderr.writeStreamingAll(io, @errorName(err));
            try stderr.writeStreamingAll(io, "\n");
            continue;
        };

        const after = try client.snapshotBytesAlloc(allocator);
        defer allocator.free(after);
        var dirty = !std.mem.eql(u8, after, last_saved);
        if (client.saved()) |saved_bytes| {
            const new_save_request = last_client_saved == null or !std.mem.eql(u8, saved_bytes, last_client_saved.?);
            if (new_save_request) {
                if (is_dir and client.currentPath() == null) {
                    client.setStatusMessage("directory browser has nothing to save");
                } else {
                    const save_path = try resolveLocalSavePath(allocator, path, client.currentPath());
                    defer allocator.free(save_path);
                    try persistLocalSave(allocator, io, save_path, saved_bytes, &last_saved, &last_client_saved);
                    dirty = false;
                    client.setStatusMessage("saved");
                }
            }
        } else |_| {}

        if (client.requestedQuit()) {
            if (dirty and !client.requestedDiscardQuit()) {
                client.clearQuit();
                client.setStatusMessage("dirty buffer: Space w saves, Space Q discards");
                continue;
            }
            return;
        }
    }
}

fn resolveLocalSavePath(allocator: std.mem.Allocator, launch_path: []const u8, current_path: ?[]const u8) ![]u8 {
    const selected = current_path orelse launch_path;
    if (std.fs.path.isAbsolute(selected) or std.mem.indexOfScalar(u8, selected, '/') != null) return allocator.dupe(u8, selected);
    const base = std.fs.path.dirname(launch_path) orelse ".";
    return std.fs.path.join(allocator, &.{ base, selected });
}

fn persistLocalSave(
    allocator: std.mem.Allocator,
    io: std.Io,
    path: []const u8,
    bytes: []const u8,
    last_saved: *[]u8,
    last_client_saved: *?[]u8,
) !void {
    try std.Io.Dir.cwd().writeFile(io, .{ .sub_path = path, .data = bytes });
    const saved_copy = try allocator.dupe(u8, bytes);
    errdefer allocator.free(saved_copy);
    const client_copy = try allocator.dupe(u8, bytes);
    allocator.free(last_saved.*);
    last_saved.* = saved_copy;
    if (last_client_saved.*) |old| allocator.free(old);
    last_client_saved.* = client_copy;
}

const RawTerminal = struct {
    fd: std.posix.fd_t,
    original: std.posix.termios,

    fn enable(fd: std.posix.fd_t) !RawTerminal {
        const original = try std.posix.tcgetattr(fd);
        var raw = original;
        raw.iflag.BRKINT = false;
        raw.iflag.ICRNL = false;
        raw.iflag.INPCK = false;
        raw.iflag.ISTRIP = false;
        raw.iflag.IXON = false;
        raw.oflag.OPOST = false;
        raw.cflag.CSIZE = .CS8;
        raw.lflag.ECHO = false;
        raw.lflag.ICANON = false;
        raw.lflag.IEXTEN = false;
        raw.lflag.ISIG = false;
        raw.cc[@intFromEnum(std.posix.V.MIN)] = 1;
        raw.cc[@intFromEnum(std.posix.V.TIME)] = 0;
        try std.posix.tcsetattr(fd, .FLUSH, raw);
        return .{ .fd = fd, .original = original };
    }

    fn restore(self: *RawTerminal) void {
        std.posix.tcsetattr(self.fd, .FLUSH, self.original) catch {};
    }
};

fn readEditorInputFdAlloc(allocator: std.mem.Allocator, fd: std.posix.fd_t) !?[]u8 {
    var one: [1]u8 = undefined;
    const n = try std.posix.read(fd, &one);
    if (n == 0) return null;
    var bytes = std.ArrayList(u8).empty;
    errdefer bytes.deinit(allocator);
    try bytes.append(allocator, one[0]);
    if (one[0] != 0x1b) return try bytes.toOwnedSlice(allocator);

    var fds = [_]std.posix.pollfd{.{ .fd = fd, .events = std.posix.POLL.IN, .revents = 0 }};
    const ready = std.posix.poll(&fds, 30) catch 0;
    if (ready == 0 or (fds[0].revents & std.posix.POLL.IN) == 0) return try bytes.toOwnedSlice(allocator);
    const second_n = try std.posix.read(fd, &one);
    if (second_n == 0) return try bytes.toOwnedSlice(allocator);
    try bytes.append(allocator, one[0]);
    if (one[0] == '[') {
        while (bytes.items.len < 8) {
            const next_ready = std.posix.poll(&fds, 30) catch 0;
            if (next_ready == 0 or (fds[0].revents & std.posix.POLL.IN) == 0) break;
            const next_n = try std.posix.read(fd, &one);
            if (next_n == 0) break;
            try bytes.append(allocator, one[0]);
            if (one[0] >= '@' and one[0] <= '~') break;
        }
    }
    return try bytes.toOwnedSlice(allocator);
}

fn readEditorInputAlloc(allocator: std.mem.Allocator, stdin: *std.Io.Reader, fd: std.posix.fd_t) !?[]u8 {
    const first = stdin.takeByte() catch |err| switch (err) {
        error.EndOfStream => return null,
        else => return err,
    };
    var bytes = std.ArrayList(u8).empty;
    errdefer bytes.deinit(allocator);
    try bytes.append(allocator, first);

    if (first == 0x1b) {
        var fds = [_]std.posix.pollfd{.{ .fd = fd, .events = std.posix.POLL.IN, .revents = 0 }};
        const ready: usize = if (fd < 0) 1 else std.posix.poll(&fds, 30) catch 0;
        if (ready == 0 or (fd >= 0 and (fds[0].revents & std.posix.POLL.IN) == 0)) return try bytes.toOwnedSlice(allocator);
        const second = stdin.takeByte() catch return try bytes.toOwnedSlice(allocator);
        try bytes.append(allocator, second);
        if (second == '[') {
            const third_ready: usize = if (fd < 0) 1 else std.posix.poll(&fds, 30) catch 0;
            if (third_ready == 0 or (fd >= 0 and (fds[0].revents & std.posix.POLL.IN) == 0)) return try bytes.toOwnedSlice(allocator);
            const third = stdin.takeByte() catch return try bytes.toOwnedSlice(allocator);
            try bytes.append(allocator, third);
        }
        return try bytes.toOwnedSlice(allocator);
    }

    const len = std.unicode.utf8ByteSequenceLength(first) catch 1;
    var i: usize = 1;
    while (i < len) : (i += 1) {
        const next = stdin.takeByte() catch break;
        try bytes.append(allocator, next);
    }
    return try bytes.toOwnedSlice(allocator);
}

fn renderLocalFrame(allocator: std.mem.Allocator, io: std.Io, stdout: std.Io.File, client: *tui.Client, path: []const u8, is_dir: bool, interactive: bool) !void {
    const frame = try client.render(allocator);
    defer allocator.free(frame);
    if (interactive) {
        try stdout.writeStreamingAll(io, "\x1b[H\x1b[2J");
        try writeTerminalText(allocator, io, stdout, frame);
        try writeTerminalText(allocator, io, stdout, "\n\n");
        try writeTerminalText(allocator, io, stdout, "mim opened: ");
        try writeTerminalText(allocator, io, stdout, path);
        try writeTerminalText(allocator, io, stdout, if (is_dir)
            "\nDirectory browser. Space opens commands; o/Enter opens panel items where available; q quits when clean.\n"
        else
            "\nEditor starts in normal mode. Press i to insert; Space commands work in normal mode; Space w saves; Space q quits when clean; Space Q discards dirty changes.\n");
    } else {
        try stdout.writeStreamingAll(io, frame);
        try stdout.writeStreamingAll(io, "\n\n");
        try stdout.writeStreamingAll(io, "mim opened: ");
        try stdout.writeStreamingAll(io, path);
        try stdout.writeStreamingAll(io, if (is_dir)
            "\nDirectory browser. Space opens commands; o/Enter opens panel items where available; q quits when clean.\n"
        else
            "\nEditor starts in normal mode. Press i to insert; Space commands work in normal mode; Space w saves; Space q quits when clean; Space Q discards dirty changes.\n");
    }
}

fn writeTerminalText(allocator: std.mem.Allocator, io: std.Io, stdout: std.Io.File, bytes: []const u8) !void {
    const converted = try terminalCrlfAlloc(allocator, bytes);
    defer allocator.free(converted);
    try stdout.writeStreamingAll(io, converted);
}

fn terminalCrlfAlloc(allocator: std.mem.Allocator, bytes: []const u8) ![]u8 {
    var out = std.ArrayList(u8).empty;
    errdefer out.deinit(allocator);
    var start: usize = 0;
    for (bytes, 0..) |byte, i| {
        if (byte != '\n') continue;
        if (start < i) try out.appendSlice(allocator, bytes[start..i]);
        try out.appendSlice(allocator, "\r\n");
        start = i + 1;
    }
    if (start < bytes.len) try out.appendSlice(allocator, bytes[start..]);
    return out.toOwnedSlice(allocator);
}

fn printLocalContext(allocator: std.mem.Allocator, io: std.Io, args: *std.process.Args.Iterator, stdout: std.Io.File) !void {
    const task = args.next();
    const intent = args.next();
    const text = try context_mod.localContextAlloc(allocator, ".", task, intent, .{});
    defer allocator.free(text);
    try stdout.writeStreamingAll(io, text);
}

fn printProfile(allocator: std.mem.Allocator, io: std.Io, stdout: std.Io.File) !void {
    const text = try profile.statusAlloc(allocator);
    defer allocator.free(text);
    try stdout.writeStreamingAll(io, text);
}

fn isProfileStub(arg: []const u8) bool {
    return std.mem.eql(u8, arg, "remote") or
        std.mem.eql(u8, arg, "mimctl") or
        std.mem.eql(u8, arg, "plugin") or
        std.mem.eql(u8, arg, "plugins") or
        std.mem.eql(u8, arg, "background-agent") or
        std.mem.eql(u8, arg, "bundled-pi");
}

fn printProfileStub(io: std.Io, stderr: std.Io.File, arg: []const u8) !void {
    try stderr.writeStreamingAll(io, "mim: ");
    try stderr.writeStreamingAll(io, arg);
    try stderr.writeStreamingAll(io, " not built in this profile\n");
}

fn requestMimctl(
    allocator: std.mem.Allocator,
    io: std.Io,
    environ: std.process.Environ,
    stdout: std.Io.File,
    stderr: std.Io.File,
    socket_path: []const u8,
    line: []const u8,
) !void {
    const resolved_socket_path = if (std.mem.eql(u8, socket_path, "-"))
        std.process.Environ.getAlloc(environ, allocator, socket.socket_env_name) catch {
            try stderr.writeStreamingAll(io, "mim: MIM_SOCKET is not set\n");
            return error.MimctlFailed;
        }
    else
        try allocator.dupe(u8, socket_path);
    defer allocator.free(resolved_socket_path);

    const response = socket.request(allocator, resolved_socket_path, line) catch {
        try stderr.writeStreamingAll(io, "mim: mimctl request failed\n");
        return error.MimctlFailed;
    };
    defer allocator.free(response);
    try stdout.writeStreamingAll(io, response);
}

fn collectContextRequest(allocator: std.mem.Allocator, args: *std.process.Args.Iterator) ![]u8 {
    var line = std.ArrayList(u8).empty;
    errdefer line.deinit(allocator);
    try line.appendSlice(allocator, "context");
    while (args.next()) |arg| {
        try line.append(allocator, ' ');
        try line.appendSlice(allocator, arg);
    }
    return line.toOwnedSlice(allocator);
}

fn collectRemainingArgs(allocator: std.mem.Allocator, args: *std.process.Args.Iterator) ![]u8 {
    var line = std.ArrayList(u8).empty;
    errdefer line.deinit(allocator);
    var first = true;
    while (args.next()) |arg| {
        if (!first) try line.append(allocator, ' ');
        try line.appendSlice(allocator, arg);
        first = false;
    }
    return line.toOwnedSlice(allocator);
}

test {
    _ = context_mod;
    _ = diagnostics;
    _ = input;
    _ = job;
    _ = layout;
    _ = leader;
    _ = lsp;
    _ = mobile_acceptance;
    _ = panel;
    _ = pi_bridge;
    _ = profile;
    _ = protocol;
    _ = replay;
    _ = repo;
    _ = session;
    _ = socket;
    _ = symbol;
    _ = syntax;
    _ = tui;
}

test "regular: help text names the binary and open path" {
    try std.testing.expect(std.mem.indexOf(u8, help_text, "mim - mobile-first terminal code editor") != null);
    try std.testing.expect(std.mem.indexOf(u8, help_text, "mim [path]") != null);
    try std.testing.expect(std.mem.indexOf(u8, help_text, "mim context") != null);
    try std.testing.expect(std.mem.indexOf(u8, help_text, "mim profile") != null);
}

test "regular: excluded profile capabilities have explicit stubs" {
    try std.testing.expect(isProfileStub("remote"));
    try std.testing.expect(isProfileStub("mimctl"));
    try std.testing.expect(isProfileStub("plugin"));
    try std.testing.expect(isProfileStub("background-agent"));
    try std.testing.expect(!isProfileStub("context"));
}

test "regular: version output is stable enough for smoke checks" {
    try std.testing.expectEqualStrings("mim 0.1.0-dev\n", versionText());
}

test "regular: no args opens current directory" {
    const argv = [_][]const u8{"mim"};
    const parsed = parseArgs(&argv);
    switch (parsed) {
        .open => |path| try std.testing.expectEqualStrings(".", path),
        else => return error.ExpectedOpenPath,
    }
}

test "regular: positional path opens file directory or new buffer" {
    const argv = [_][]const u8{ "mim", "some-file.zig" };
    const parsed = parseArgs(&argv);
    switch (parsed) {
        .open => |path| try std.testing.expectEqualStrings("some-file.zig", path),
        else => return error.ExpectedOpenPath,
    }
}

test "regular: local editor input reader preserves text utf8 and arrows" {
    var ascii = std.Io.Reader.fixed("a");
    const ascii_event = (try readEditorInputAlloc(std.testing.allocator, &ascii, -1)).?;
    defer std.testing.allocator.free(ascii_event);
    try std.testing.expectEqualStrings("a", ascii_event);

    var utf8 = std.Io.Reader.fixed("é");
    const utf8_event = (try readEditorInputAlloc(std.testing.allocator, &utf8, -1)).?;
    defer std.testing.allocator.free(utf8_event);
    try std.testing.expectEqualStrings("é", utf8_event);

    var arrow = std.Io.Reader.fixed("\x1b[D");
    const arrow_event = (try readEditorInputAlloc(std.testing.allocator, &arrow, -1)).?;
    defer std.testing.allocator.free(arrow_event);
    try std.testing.expectEqualStrings("\x1b[D", arrow_event);
}

test "regular: local editor client exposes save and dirty quit guards" {
    var client = try tui.Client.init(std.testing.allocator, .{ .width = 32, .height = 8 });
    defer client.deinit();

    try client.handleTraceLine("open ");
    const initial = try client.snapshotBytesAlloc(std.testing.allocator);
    defer std.testing.allocator.free(initial);
    try std.testing.expectEqualStrings("", initial);

    try client.handleInput("i");
    try client.handleInput("h");
    try client.handleInput("e");
    try client.handleInput("l");
    try client.handleInput("l");
    try client.handleInput("o");
    const edited = try client.snapshotBytesAlloc(std.testing.allocator);
    defer std.testing.allocator.free(edited);
    try std.testing.expectEqualStrings("hello", edited);

    try client.handleInput(" ");
    try client.handleInput("x");
    const with_space = try client.snapshotBytesAlloc(std.testing.allocator);
    defer std.testing.allocator.free(with_space);
    try std.testing.expectEqualStrings("hello x", with_space);
    try client.handleTraceLine("key escape");
    try std.testing.expectEqualStrings("normal", client.modeName());
    try client.handleInput(" ");
    try client.handleInput("w");
    try std.testing.expectEqualStrings("hello x", try client.saved());

    try client.handleInput("i");
    try client.handleInput("!");
    try client.handleTraceLine("key escape");
    try client.handleInput(" ");
    try client.handleInput("q");
    try std.testing.expect(client.requestedQuit());
    client.clearQuit();
    try std.testing.expect(!client.requestedQuit());
}

test "terminal debug helpers are included in main test root" {
    _ = terminal_debug;
}

test "regular: raw terminal output converts newline to carriage-return newline" {
    const converted = try terminalCrlfAlloc(std.testing.allocator, "a\nb\n");
    defer std.testing.allocator.free(converted);
    try std.testing.expectEqualStrings("a\r\nb\r\n", converted);
}