const std = @import("std");

const cdl = @import("cdl");

const ansi = @import("ansi.zig");

const ascii_raw = @embedFile("ascii.txt");
const ascii = blk: {
    var ar: []const []const u8 = &.{};
    var it = std.mem.splitScalar(u8, ascii_raw, '\n');
    while (it.next()) |line| if (line.len != 0) {
        ar = ar ++ .{line};
    };
    break :blk ar;
};

const base_padding = 1;

pub fn main(init: std.process.Init) !void {
    cdl.init(init);
    defer cdl.deinit();

    const stdout = std.Io.File.stdout();
    var buf: [0x400]u8 = undefined;
    var file_writer = stdout.writer(cdl.io, &buf);
    try term.init(&file_writer.interface);

    // SYS ====================================================================

    const hostname = try cdl.info.hostname();
    defer cdl.gpa.free(hostname);

    const nuser = try cdl.info.user();
    const nshell = try cdl.info.shell();

    const nosname = try cdl.info.osname();

    try term.writeascii();
    try term.writekeyn(" host ", .green);
    try ansi.fg(term.writer, .cyan);
    if (nuser) |v| {
        try term.writefmtn("{s}", .{v});
        try ansi.fg_bright(term.writer, .black);
        try term.writer.writeByte('@');
        try ansi.fg(term.writer, .cyan);
        try term.writefmtn("{s}", .{hostname});
    } else try term.writefmtn("{s}", .{hostname});
    try ansi.style(term.writer, .reset);
    if (nosname) |v| {
        try ansi.fg(term.writer, .white);
        try term.writefmtn(
            \\ ({s})
        , .{v});
        try ansi.style(term.writer, .reset);
    }
    try term.writer.writeByte('\n');
    try term.writer.flush();

    if (nshell) |shell| {
        try term.writeascii();
        try term.writekeyn(" ├   ", .yellow);
        if (cdl.info.terminal()) |v| {
            try term.writefmtn("{s}", .{v});
            try ansi.fg_bright(term.writer, .black);
            try term.writer.writeAll(" + ");
            try ansi.style(term.writer, .reset);
            try term.writefmtn("{s}", .{shell});
        } else try term.writefmtn("{s}", .{shell});
        try term.writer.writeByte('\n');
        try term.writer.flush();
    }

    if (cdl.info.desktop()) |desktop| {
        try term.writeascii();
        try term.writekeyn(" ├   ", .blue);
        try term.writefmtn("{s}", .{desktop});
        if (cdl.info.session()) |v| {
            try ansi.fg(term.writer, .white);
            try term.writefmtn(" ({s})", .{v});
            try ansi.style(term.writer, .reset);
        }
        try term.writer.writeByte('\n');
        try term.writer.flush();
    }

    if (cdl.info.editor()) |v| {
        try term.writeascii();
        try term.writekeyn(" ├   ", .magenta);
        try term.writefmtn("{s}", .{v});
        try term.writer.writeByte('\n');
        try term.writer.flush();
    }

    var cols_buf: [0x100]u8 = undefined;
    const cols = blk: {
        var w: std.Io.Writer = .fixed(&cols_buf);
        for (0..8) |i| {
            if (i != 0) try w.writeByte(' ');
            try ansi.fg(&w, .int(@intCast(i)));
            try w.writeAll("●");
        }
        break :blk w.buffered();
    };

    try term.writeascii();
    try term.writekeyn(" └ ", .cyan);
    try term.writefmtn("{s}", .{cols});
    try term.writer.writeByte('\n');
    try term.writer.flush();

    try term.writer.flush();
}

const term = struct {
    pub var writer: *std.Io.Writer = undefined;

    var ascii_line_widths: [ascii.len]usize = undefined;
    var longest: usize = undefined;

    pub fn init(w: *std.Io.Writer) !void {
        writer = w;

        _ = std.c.setlocale(.ALL, "");

        for (ascii, 0..) |line, c| {
            const len = try cdl.strwidth.width(line);
            ascii_line_widths[c] = len;
        }

        longest = blk: {
            var max: usize = 0;
            for (ascii_line_widths) |len| if (len > max) {
                max = len;
            };
            break :blk max;
        };
    }

    pub fn write(buf: []const u8) !void {
        try writeascii();

        try writer.writeAll(buf);
        try writer.writeByte('\n');
        try writer.flush();
    }
    pub fn writefmt(comptime format: []const u8, args: anytype) !void {
        try writeascii();

        try writefmtn(format, args);
        try writer.writeByte('\n');
        try writer.flush();
    }
    pub fn writefmtn(comptime format: []const u8, args: anytype) !void {
        const buf = try std.fmt.allocPrint(cdl.gpa, format, args);
        defer cdl.gpa.free(buf);
        try writer.writeAll(buf);
    }
    pub fn writekeyn(buf: []const u8, c: ansi.Color) !void {
        try ansi.fg(term.writer, c);
        try ansi.style(term.writer, .bold);
        try term.writer.writeAll(buf);
        try ansi.style(term.writer, .reset);
    }

    var i: usize = 0;
    pub fn writeascii() !void {
        try ansi.fg(writer, .white);

        defer i += 1;

        const n = blk: {
            if (i >= ascii.len)
                break :blk longest;

            try writer.writeAll(ascii[i]);
            const len = ascii_line_widths[i];
            break :blk longest - len;
        };
        for (0..n + base_padding) |_| try writer.writeByte(' ');

        try ansi.style(writer, .reset);
    }
};