const std = @import("std");
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const Thread = std.Thread;
const Mutex = std.Thread.Mutex;

const parser = @import("parser.zig");
const Command = parser.Command;

const eval = @import("eval.zig");
const CommandStatus = eval.CommandStatus;

const paths = @import("paths.zig");
const convertTo83 = paths.convertTo83;

const STDOUT_BUFFER_SIZE: usize = 1024;
const STDERR_BUFFER_SIZE: usize = 1024;

fn formatPath(allocator: Allocator, path: []const u8) ![]const u8 {
    // Normalize separators and case first
    var normalized = ArrayList(u8).init(allocator);
    defer normalized.deinit();

    for (path) |ch| {
        if (ch == '/') {
            try normalized.append('\\');
        } else {
            try normalized.append(std.ascii.toUpper(ch));
        }
    }

    // Extract drive letter if present (e.g., "C:")
    var idx: usize = 0;
    var has_drive = false;
    var drive_letter: u8 = 'C';
    if (normalized.items.len >= 2 and normalized.items[1] == ':') {
        has_drive = true;
        drive_letter = normalized.items[0];
        idx = 2;
    }

    // Remember if the path is absolute after the drive (leading backslash)
    var starts_with_backslash = false;
    if (idx < normalized.items.len and normalized.items[idx] == '\\') {
        starts_with_backslash = true;
        // Skip the first leading backslash to avoid creating an empty component
        idx += 1;
    }

    // Build result with components converted to 8.3
    var result = ArrayList(u8).init(allocator);
    defer result.deinit();

    // If absolute, start with a backslash (after potential drive prefix)
    if (starts_with_backslash) {
        try result.append('\\');
    }

    var it = std.mem.splitScalar(u8, normalized.items[idx..], '\\');
    var first_component = true;
    while (it.next()) |component| {
        if (component.len == 0) continue;

        if (!first_component and result.items.len > 0 and result.items[result.items.len - 1] != '\\') {
            try result.append('\\');
        }
        first_component = false;

        const short_name = try convertTo83(allocator, component);
        defer allocator.free(short_name.name);
        defer allocator.free(short_name.ext);
        try result.appendSlice(short_name.name);
        if (short_name.ext.len > 0) {
            try result.append('.');
            try result.appendSlice(short_name.ext);
        }
    }

    // Prepend drive if present or add default C:
    var final_buf = ArrayList(u8).init(allocator);
    defer final_buf.deinit();

    if (has_drive) {
        try final_buf.append(drive_letter);
        try final_buf.append(':');
        if (result.items.len > 0 and result.items[0] != '\\') {
            try final_buf.append('\\');
        }
        try final_buf.appendSlice(result.items);
    } else {
        // No drive: default to C:
        try final_buf.appendSlice("C:");
        if (result.items.len > 0 and result.items[0] != '\\') {
            try final_buf.append('\\');
        }
        try final_buf.appendSlice(result.items);
    }

    return allocator.dupe(u8, final_buf.items);
}

fn parseAndExecute(input: []const u8, allocator: Allocator) !CommandStatus {
    var command = parser.parse(input, allocator) catch |err| {
        switch (err) {
            error.ExpectedWord, error.UnexpectedToken => {
                return CommandStatus{ .Code = 1 };
            },
            else => return err,
        }
    };
    defer command.deinit(allocator);

    return try eval.executeCommand(command, allocator);
}

fn readLine(allocator: Allocator, prompt_text: []const u8) !?[]const u8 {
    const stdin = std.io.getStdIn().reader();
    const stdout = std.io.getStdOut();
    try stdout.writeAll(prompt_text);

    if (try stdin.readUntilDelimiterOrEofAlloc(allocator, '\n', 4096)) |input| {
        // Remove trailing \r on Windows
        if (input.len > 0 and input[input.len - 1] == '\r') {
            return input[0 .. input.len - 1];
        }
        return input;
    }
    return null;
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    try printWelcomeMessage();

    const prompt_spec = "$p$g ";

    while (true) {
        const cwd = std.fs.cwd().realpathAlloc(allocator, ".") catch |err| switch (err) {
            error.FileNotFound => "C:\\",
            else => return err,
        };
        defer allocator.free(cwd);

        const full_cwd = try formatPath(allocator, cwd);
        defer allocator.free(full_cwd);

        const interpolated_prompt = try std.mem.replaceOwned(u8, allocator, prompt_spec, "$p", full_cwd);
        defer allocator.free(interpolated_prompt);

        const final_prompt = try std.mem.replaceOwned(u8, allocator, interpolated_prompt, "$g", ">");
        defer allocator.free(final_prompt);

        if (try readLine(allocator, final_prompt)) |line| {
            defer allocator.free(line);

            const command_result = parseAndExecute(line, allocator) catch |err| {
                switch (err) {
                    error.ExpectedWord, error.UnexpectedToken => {
                        const stdout = std.io.getStdOut();
                        try stdout.writeAll("Bad command or file name\n");
                        continue;
                    },
                    else => return err,
                }
            };

            switch (command_result) {
                .ExitShell => break,
                .Code => |_| {},
            }
        } else {
            break; // EOF
        }
    }
}

fn printWelcomeMessage() !void {
    const stdout = std.io.getStdOut();
    if (!stdout.isTty()) return;

    try stdout.writeAll(
        \\Starting MB-DOS...
        \\
        \\HIMEM is testing extended memory...done.
        \\
        \\MULKROSOFT Expanded Memory Manager 386  Version 4.48
        \\EMM386 active.
        \\
        \\64K High Memory Area available.
        \\
        \\
    );
}