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

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

const FileSpec = union(enum) {
    Con,
    Lpt1,
    Lpt2, 
    Lpt3,
    Prn,
    Path: []const u8,
};

const RedirectType = enum {
    OutputOverwrite, // >
    OutputAppend,    // >>
    InputFrom,       // <
};

const Redirect = struct {
    redirect_type: RedirectType,
    target: FileSpec,
};

const BuiltinCommand = union(enum) {
    // File-oriented
    Copy: struct {
        from: FileSpec,
        to: FileSpec,
    },
    Deltree: struct {
        path: []const u8,
    },
    Dir: struct {
        path: []const u8,
    },
    Fc,
    Find,
    Mkdir: struct {
        path: []const u8,
    },
    Move,
    Remove: struct {
        path: []const u8,
    },
    Rename: struct {
        from: FileSpec,
        to: FileSpec,
    },
    Replace,
    Rmdir: struct {
        path: []const u8,
    },
    Sort,
    Tree: struct {
        path: []const u8,
    },
    Type: struct {
        file: FileSpec,
    },
    Xcopy: struct {
        from: FileSpec,
        to: FileSpec,
        recursive: bool,
    },

    // Shell-oriented
    Append,
    Chdir: struct {
        path: []const u8,
    },
    EchoOff,
    EchoOn,
    EchoPlain,
    EchoText: struct {
        message: []const u8,
    },
    Exit,
    PathGet,
    PathSet: struct {
        value: []const u8,
    },
    PromptGet,
    PromptSet: struct {
        message: []const u8,
    },
    Set: struct {
        name: []const u8,
        value: []const u8,
    },
    Setver,
    Ver,

    // Utilities
    Date,
    Time,

    // Screen-oriented
    Cls,
    More,

    // Dummies
    Verify,
    Fastopen,
    Smartdrv,
    Sizer,

    // For later
    Assign,
    Attrib,
    Chkdsk,
    Doskey,
    Dosshell,
    Edit,
    Fasthelp,
    Help,
    Join,
    Mem,
    Power,
    Subst,
    Truename,

    // For much later, if ever
    Break,
    Chcp,
    Ctty,
    Defrag,
    Diskcopy,
    Emm386,
    Fdisk,
    Format,
    Interlnk,
    Keyb,
    Label,
    Mode,
    Msav,
    Msbackup,
    Mscdex,
    Msd,
    Print_: void, // 'print' is reserved in Zig
    Qbasic,
    Restore,
    Scandisk,
    Share,
    Sys,
    Undelete,
    Unformat,
    Vol,
    Vsafe,

    // Scripting
    Call,
    Choice,
    Echo,
    For,
    Goto,
    If,
    Pause,
    Prompt,
    Rem: struct {
        message: []const u8,
    },
    Shift,
};

const Command = union(enum) {
    Pipe: struct {
        left: *Command,
        right: *Command,
    },
    Redirect: struct {
        command: *Command,
        redirects: ArrayList(Redirect),
    },
    External: struct {
        program: []const u8,
        args: ArrayList([]const u8),
    },
    Builtin: BuiltinCommand,
    Empty,

    pub fn deinit(self: *Command, allocator: Allocator) void {
        switch (self.*) {
            .Pipe => |*pipe| {
                pipe.left.deinit(allocator);
                pipe.right.deinit(allocator);
                allocator.destroy(pipe.left);
                allocator.destroy(pipe.right);
            },
            .Redirect => |*redirect| {
                redirect.command.deinit(allocator);
                allocator.destroy(redirect.command);
                redirect.redirects.deinit();
            },
            .External => |*external| {
                external.args.deinit();
            },
            else => {},
        }
    }
};

const CommandStatus = union(enum) {
    Code: u16,
    ExitShell,
};

const Token = union(enum) {
    Word: []const u8,
    Pipe,
    RedirectOut,    // >
    RedirectAppend, // >>
    RedirectIn,     // <
    Newline,
    Eof,
};

const Lexer = struct {
    input: []const u8,
    position: usize,
    current_char: ?u8,

    pub fn init(input: []const u8) Lexer {
        return Lexer{
            .input = input,
            .position = 0,
            .current_char = if (input.len > 0) input[0] else null,
        };
    }

    fn advance(self: *Lexer) void {
        self.position += 1;
        self.current_char = if (self.position < self.input.len) self.input[self.position] else null;
    }

    fn peek(self: *const Lexer) ?u8 {
        const next_pos = self.position + 1;
        return if (next_pos < self.input.len) self.input[next_pos] else null;
    }

    fn skipWhitespace(self: *Lexer) void {
        while (self.current_char) |ch| {
            if (std.ascii.isWhitespace(ch) and ch != '\n') {
                self.advance();
            } else {
                break;
            }
        }
    }

    fn readWord(self: *Lexer, allocator: Allocator) ![]const u8 {
        var word = ArrayList(u8).init(allocator);
        defer word.deinit();
        
        var in_quotes = false;
        var quote_char: u8 = '"';

        while (self.current_char) |ch| {
            switch (ch) {
                '"', '\'' => {
                    if (!in_quotes) {
                        in_quotes = true;
                        quote_char = ch;
                        self.advance();
                    } else if (ch == quote_char) {
                        in_quotes = false;
                        self.advance();
                    } else {
                        try word.append(ch);
                        self.advance();
                    }
                },
                '|', '>', '<', '\n' => {
                    if (!in_quotes) break;
                    try word.append(ch);
                    self.advance();
                },
                else => {
                    if (!in_quotes and std.ascii.isWhitespace(ch)) break;
                    try word.append(ch);
                    self.advance();
                },
            }
        }

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

    fn nextToken(self: *Lexer, allocator: Allocator) !Token {
        while (true) {
            if (self.current_char) |ch| {
                switch (ch) {
                    '\n' => {
                        self.advance();
                        return Token.Newline;
                    },
                    '|' => {
                        self.advance();
                        return Token.Pipe;
                    },
                    '>' => {
                        self.advance();
                        if (self.current_char == '>') {
                            self.advance();
                            return Token.RedirectAppend;
                        }
                        return Token.RedirectOut;
                    },
                    '<' => {
                        self.advance();
                        return Token.RedirectIn;
                    },
                    else => {
                        if (std.ascii.isWhitespace(ch)) {
                            self.skipWhitespace();
                            continue;
                        }
                        const word = try self.readWord(allocator);
                        if (word.len == 0) {
                            self.advance();
                            continue;
                        }
                        return Token{ .Word = word };
                    },
                }
            } else {
                return Token.Eof;
            }
        }
    }

    pub fn tokenize(self: *Lexer, allocator: Allocator) !ArrayList(Token) {
        var tokens = ArrayList(Token).init(allocator);
        
        while (true) {
            const token = try self.nextToken(allocator);
            const is_eof = switch (token) {
                .Eof => true,
                else => false,
            };
            try tokens.append(token);
            if (is_eof) break;
        }

        return tokens;
    }
};

const Parser = struct {
    tokens: ArrayList(Token),
    position: usize,
    allocator: Allocator,

    pub fn init(tokens: ArrayList(Token), allocator: Allocator) Parser {
        return Parser{
            .tokens = tokens,
            .position = 0,
            .allocator = allocator,
        };
    }

    fn currentToken(self: *const Parser) Token {
        if (self.position < self.tokens.items.len) {
            return self.tokens.items[self.position];
        }
        return Token.Eof;
    }

    fn advance(self: *Parser) void {
        if (self.position < self.tokens.items.len) {
            self.position += 1;
        }
    }

    fn expectWord(self: *Parser) ![]const u8 {
        switch (self.currentToken()) {
            .Word => |word| {
                self.advance();
                return word;
            },
            else => return error.ExpectedWord,
        }
    }

    pub fn parseCommand(self: *Parser) !Command {
        return self.parsePipeline();
    }

    fn parsePipeline(self: *Parser) !Command {
        var left = try self.parseRedirectedCommand();

        while (true) {
            switch (self.currentToken()) {
                .Pipe => {
                    self.advance(); // consume |
                    const right = try self.parseRedirectedCommand();
                    const left_ptr = try self.allocator.create(Command);
                    const right_ptr = try self.allocator.create(Command);
                    left_ptr.* = left;
                    right_ptr.* = right;
                    left = Command{ .Pipe = .{ .left = left_ptr, .right = right_ptr } };
                },
                else => break,
            }
        }

        return left;
    }

    fn parseRedirectedCommand(self: *Parser) !Command {
        const command = try self.parseSimpleCommand();
        var redirects = ArrayList(Redirect).init(self.allocator);

        while (true) {
            const redirect_type = switch (self.currentToken()) {
                .RedirectOut => RedirectType.OutputOverwrite,
                .RedirectAppend => RedirectType.OutputAppend,
                .RedirectIn => RedirectType.InputFrom,
                else => break,
            };

            self.advance(); // consume redirect token

            const target_str = try self.expectWord();
            const target = parseFilespec(target_str);

            try redirects.append(Redirect{
                .redirect_type = redirect_type,
                .target = target,
            });
        }

        if (redirects.items.len == 0) {
            redirects.deinit();
            return command;
        } else {
            const command_ptr = try self.allocator.create(Command);
            command_ptr.* = command;
            return Command{ .Redirect = .{ .command = command_ptr, .redirects = redirects } };
        }
    }

    fn parseSimpleCommand(self: *Parser) !Command {
        switch (self.currentToken()) {
            .Eof, .Newline => return Command.Empty,
            .Word => |command_name| {
                self.advance();
                var args = ArrayList([]const u8).init(self.allocator);

                // Collect arguments
                while (true) {
                    switch (self.currentToken()) {
                        .Word => |arg| {
                            try args.append(arg);
                            self.advance();
                        },
                        else => break,
                    }
                }

                return try self.parseBuiltinCommand(command_name, args);
            },
            else => return error.UnexpectedToken,
        }
    }

    fn parseBuiltinCommand(self: *Parser, command_name: []const u8, args: ArrayList([]const u8)) !Command {
        const cmd_upper = try std.ascii.allocUpperString(self.allocator, command_name);
        defer self.allocator.free(cmd_upper);

        if (std.mem.eql(u8, cmd_upper, "ECHO")) {
            if (args.items.len == 0) {
                return Command{ .Builtin = BuiltinCommand.EchoPlain };
            } else {
                const first_arg_upper = try std.ascii.allocUpperString(self.allocator, args.items[0]);
                defer self.allocator.free(first_arg_upper);
                
                if (std.mem.eql(u8, first_arg_upper, "ON") and args.items.len == 1) {
                    return Command{ .Builtin = BuiltinCommand.EchoOn };
                } else if (std.mem.eql(u8, first_arg_upper, "OFF") and args.items.len == 1) {
                    return Command{ .Builtin = BuiltinCommand.EchoOff };
                } else {
                    const message = try std.mem.join(self.allocator, " ", args.items);
                    return Command{ .Builtin = BuiltinCommand{ .EchoText = .{ .message = message } } };
                }
            }
        } else if (std.mem.eql(u8, cmd_upper, "CLS")) {
            return Command{ .Builtin = BuiltinCommand.Cls };
        } else if (std.mem.eql(u8, cmd_upper, "EXIT")) {
            return Command{ .Builtin = BuiltinCommand.Exit };
        } else if (std.mem.eql(u8, cmd_upper, "MORE")) {
            return Command{ .Builtin = BuiltinCommand.More };
        } else if (std.mem.eql(u8, cmd_upper, "VERIFY")) {
            return Command{ .Builtin = BuiltinCommand.Verify };
        } else if (std.mem.eql(u8, cmd_upper, "DIR")) {
            const path = if (args.items.len == 0) "." else args.items[0];
            return Command{ .Builtin = BuiltinCommand{ .Dir = .{ .path = path } } };
        } else if (std.mem.eql(u8, cmd_upper, "VER")) {
            return Command{ .Builtin = BuiltinCommand.Ver };
        } else if (std.mem.eql(u8, cmd_upper, "DATE")) {
            return Command{ .Builtin = BuiltinCommand.Date };
        } else if (std.mem.eql(u8, cmd_upper, "TIME")) {
            return Command{ .Builtin = BuiltinCommand.Time };
        } else if (std.mem.eql(u8, cmd_upper, "TYPE")) {
            if (args.items.len == 0) {
                return error.ExpectedWord; // Will be caught and show "Bad command or file name"
            }
            const file_spec = parseFilespec(args.items[0]);
            return Command{ .Builtin = BuiltinCommand{ .Type = .{ .file = file_spec } } };
        } else if (std.mem.eql(u8, cmd_upper, "SORT")) {
            return Command{ .Builtin = BuiltinCommand.Sort };
        } else {
            // External command
            return Command{ .External = .{ .program = command_name, .args = args } };
        }
    }
};

fn isLeapYear(year: u32) bool {
    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0);
}

fn parseFilespec(path_str: []const u8) FileSpec {
    var upper_buf: [256]u8 = undefined;
    if (path_str.len >= upper_buf.len) return FileSpec{ .Path = path_str };
    const upper_str = std.ascii.upperString(upper_buf[0..path_str.len], path_str);

    if (std.mem.eql(u8, upper_str, "CON")) return FileSpec.Con;
    if (std.mem.eql(u8, upper_str, "LPT1")) return FileSpec.Lpt1;
    if (std.mem.eql(u8, upper_str, "LPT2")) return FileSpec.Lpt2;
    if (std.mem.eql(u8, upper_str, "LPT3")) return FileSpec.Lpt3;
    if (std.mem.eql(u8, upper_str, "PRN")) return FileSpec.Prn;
    return FileSpec{ .Path = path_str };
}

fn formatPath(allocator: Allocator, path: []const u8) ![]const u8 {
    var result = ArrayList(u8).init(allocator);
    defer result.deinit();

    // Simple DOS-style path formatting
    // Convert to uppercase and replace / with \
    for (path) |ch| {
        if (ch == '/') {
            try result.append('\\');
        } else {
            try result.append(std.ascii.toUpper(ch));
        }
    }

    // Add C: prefix if no drive letter
    if (result.items.len == 0 or result.items[1] != ':') {
        var prefixed = ArrayList(u8).init(allocator);
        defer prefixed.deinit();
        try prefixed.appendSlice("C:");
        try prefixed.appendSlice(result.items);
        return allocator.dupe(u8, prefixed.items);
    }

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

fn parseAndExecute(input: []const u8, allocator: Allocator) !CommandStatus {
    const trimmed = std.mem.trim(u8, input, " \t\r\n");
    if (trimmed.len == 0) {
        return CommandStatus{ .Code = 0 };
    }

    var lexer = Lexer.init(trimmed);
    var tokens = try lexer.tokenize(allocator);
    defer {
        for (tokens.items) |token| {
            switch (token) {
                .Word => |word| allocator.free(word),
                else => {},
            }
        }
        tokens.deinit();
    }

    var parser = Parser.init(tokens, allocator);
    var command = try parser.parseCommand();
    defer command.deinit(allocator);

    return try executeCommand(command, allocator);
}

const OutputCapture = struct {
    buffer: ArrayList(u8),
    
    pub fn init(allocator: Allocator) OutputCapture {
        return OutputCapture{
            .buffer = ArrayList(u8).init(allocator),
        };
    }
    
    pub fn deinit(self: *OutputCapture) void {
        self.buffer.deinit();
    }
    
    pub fn write(self: *OutputCapture, data: []const u8) !void {
        try self.buffer.appendSlice(data);
    }
    
    pub fn getContents(self: *const OutputCapture) []const u8 {
        return self.buffer.items;
    }
};

const InputSource = struct {
    data: []const u8,
    position: usize,
    
    pub fn init(data: []const u8) InputSource {
        return InputSource{
            .data = data,
            .position = 0,
        };
    }
    
    pub fn readLine(self: *InputSource, allocator: Allocator) !?[]const u8 {
        if (self.position >= self.data.len) {
            return null; // EOF
        }
        
        var line_end = self.position;
        while (line_end < self.data.len and self.data[line_end] != '\n') {
            line_end += 1;
        }
        
        const line = self.data[self.position..line_end];
        self.position = if (line_end < self.data.len) line_end + 1 else self.data.len;
        
        // Remove trailing \r if present (DOS line endings)
        if (line.len > 0 and line[line.len - 1] == '\r') {
            return try allocator.dupe(u8, line[0..line.len - 1]);
        } else {
            return try allocator.dupe(u8, line);
        }
    }
};

fn executeCommandWithOutput(command: Command, allocator: Allocator, output_capture: ?*OutputCapture, input_source: ?*InputSource) !CommandStatus {
    switch (command) {
        .Empty => return CommandStatus{ .Code = 0 },
        
        .Builtin => |builtin_cmd| {
            switch (builtin_cmd) {
                .EchoText => |echo| {
                    const output = try std.fmt.allocPrint(allocator, "{s}\n", .{echo.message});
                    defer allocator.free(output);
                    if (output_capture) |capture| {
                        try capture.write(output);
                    } else {
                        print("{s}", .{output});
                    }
                    return CommandStatus{ .Code = 0 };
                },
                .Cls => {
                    if (output_capture == null) {
                        // Clear screen - only works when not redirected
                        print("\x1B[2J\x1B[H", .{});
                    }
                    return CommandStatus{ .Code = 0 };
                },
                .Exit => {
                    return CommandStatus.ExitShell;
                },
                .EchoPlain => {
                    const output = "ECHO is on\n";
                    if (output_capture) |capture| {
                        try capture.write(output);
                    } else {
                        print("{s}", .{output});
                    }
                    return CommandStatus{ .Code = 0 };
                },
                .EchoOn => {
                    const output = "ECHO is on\n";
                    if (output_capture) |capture| {
                        try capture.write(output);
                    } else {
                        print("{s}", .{output});
                    }
                    return CommandStatus{ .Code = 0 };
                },
                .EchoOff => {
                    return CommandStatus{ .Code = 0 };
                },
                .Ver => {
                    const output = "MS-DOS Version 6.22 (Zig Implementation)\n";
                    if (output_capture) |capture| {
                        try capture.write(output);
                    } else {
                        print("{s}", .{output});
                    }
                    return CommandStatus{ .Code = 0 };
                },
                .Date => {
                    const timestamp = std.time.timestamp();
                    const epoch_seconds = @as(u64, @intCast(timestamp));
                    const epoch_day = @divFloor(epoch_seconds, std.time.s_per_day);
                    
                    // Calculate days since Unix epoch (1970-01-01)
                    // Unix epoch is 719163 days since year 1 AD
                    const days_since_year_1 = epoch_day + 719163;
                    
                    // Simple algorithm to convert days to year/month/day
                    var year: u32 = 1;
                    var remaining_days = days_since_year_1;
                    
                    // Find the year
                    while (true) {
                        const days_in_year: u64 = if (isLeapYear(year)) 366 else 365;
                        if (remaining_days < days_in_year) break;
                        remaining_days -= days_in_year;
                        year += 1;
                    }
                    
                    // Days in each month (non-leap year)
                    const days_in_month = [_]u32{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
                    
                    var month: u32 = 1;
                    for (days_in_month, 1..) |days, m| {
                        var month_days = days;
                        // Adjust February for leap years
                        if (m == 2 and isLeapYear(year)) {
                            month_days = 29;
                        }
                        
                        if (remaining_days < month_days) {
                            month = @intCast(m);
                            break;
                        }
                        remaining_days -= month_days;
                    }
                    
                    const day = remaining_days + 1; // Days are 1-indexed
                    
                    const output = try std.fmt.allocPrint(allocator, "Current date is {d:0>2}/{d:0>2}/{d}\n", .{ month, day, year });
                    defer allocator.free(output);
                    if (output_capture) |capture| {
                        try capture.write(output);
                    } else {
                        print("{s}", .{output});
                    }
                    return CommandStatus{ .Code = 0 };
                },
                .Time => {
                    const timestamp = std.time.timestamp();
                    const epoch_seconds = @as(u64, @intCast(timestamp));
                    const day_seconds = epoch_seconds % std.time.s_per_day;
                    const hours = day_seconds / std.time.s_per_hour;
                    const minutes = (day_seconds % std.time.s_per_hour) / std.time.s_per_min;
                    const seconds = day_seconds % std.time.s_per_min;
                    
                    const output = try std.fmt.allocPrint(allocator, "Current time is {d:0>2}:{d:0>2}:{d:0>2}\n", .{ hours, minutes, seconds });
                    defer allocator.free(output);
                    if (output_capture) |capture| {
                        try capture.write(output);
                    } else {
                        print("{s}", .{output});
                    }
                    return CommandStatus{ .Code = 0 };
                },
                .Dir => |dir| {
                    var output_buffer = ArrayList(u8).init(allocator);
                    defer output_buffer.deinit();
                    
                    try output_buffer.writer().print("Directory of {s}\n\n", .{dir.path});
                    
                    var dir_iterator = std.fs.cwd().openDir(dir.path, .{ .iterate = true }) catch {
                        const error_msg = "File not found\n";
                        if (output_capture) |capture| {
                            try capture.write(error_msg);
                        } else {
                            print("{s}", .{error_msg});
                        }
                        return CommandStatus{ .Code = 1 };
                    };
                    defer dir_iterator.close();
                    
                    var iterator = dir_iterator.iterate();
                    var file_count: u32 = 0;
                    var dir_count: u32 = 0;
                    
                    while (try iterator.next()) |entry| {
                        switch (entry.kind) {
                            .directory => {
                                try output_buffer.writer().print("<DIR>          {s}\n", .{entry.name});
                                dir_count += 1;
                            },
                            .file => {
                                const stat = dir_iterator.statFile(entry.name) catch continue;
                                try output_buffer.writer().print("{d:>14} {s}\n", .{ stat.size, entry.name });
                                file_count += 1;
                            },
                            else => {},
                        }
                    }
                    
                    try output_buffer.writer().print("\n{d} File(s)\n", .{file_count});
                    try output_buffer.writer().print("{d} Dir(s)\n", .{dir_count});
                    
                    if (output_capture) |capture| {
                        try capture.write(output_buffer.items);
                    } else {
                        print("{s}", .{output_buffer.items});
                    }
                    return CommandStatus{ .Code = 0 };
                },
                .Type => |type_cmd| {
                    const file_path = switch (type_cmd.file) {
                        .Con => {
                            const error_msg = "Cannot TYPE from CON\n";
                            if (output_capture) |capture| {
                                try capture.write(error_msg);
                            } else {
                                print("{s}", .{error_msg});
                            }
                            return CommandStatus{ .Code = 1 };
                        },
                        .Lpt1, .Lpt2, .Lpt3, .Prn => {
                            const error_msg = "Cannot TYPE from device\n";
                            if (output_capture) |capture| {
                                try capture.write(error_msg);
                            } else {
                                print("{s}", .{error_msg});
                            }
                            return CommandStatus{ .Code = 1 };
                        },
                        .Path => |path| path,
                    };
                    
                    const file = std.fs.cwd().openFile(file_path, .{}) catch |err| {
                        const error_msg = switch (err) {
                            error.FileNotFound => "The system cannot find the file specified.\n",
                            error.IsDir => "Access is denied.\n",
                            error.AccessDenied => "Access is denied.\n",
                            else => "Cannot access file.\n",
                        };
                        if (output_capture) |capture| {
                            try capture.write(error_msg);
                        } else {
                            print("{s}", .{error_msg});
                        }
                        return CommandStatus{ .Code = 1 };
                    };
                    defer file.close();
                    
                    // Read and display file contents
                    var buffer: [4096]u8 = undefined;
                    while (true) {
                        const bytes_read = file.readAll(&buffer) catch |err| {
                            const error_msg = switch (err) {
                                error.AccessDenied => "Access is denied.\n",
                                else => "Error reading file.\n",
                            };
                            if (output_capture) |capture| {
                                try capture.write(error_msg);
                            } else {
                                print("{s}", .{error_msg});
                            }
                            return CommandStatus{ .Code = 1 };
                        };
                        
                        if (bytes_read == 0) break;
                        
                        // Process buffer contents for output
                        var processed_output = ArrayList(u8).init(allocator);
                        defer processed_output.deinit();
                        
                        for (buffer[0..bytes_read]) |byte| {
                            // Convert to printable characters, similar to DOS TYPE behavior
                            if (byte >= 32 and byte <= 126) {
                                try processed_output.append(byte);
                            } else if (byte == '\n') {
                                try processed_output.append('\n');
                            } else if (byte == '\r') {
                                // Skip carriage return in DOS-style line endings
                                continue;
                            } else if (byte == '\t') {
                                try processed_output.append('\t');
                            } else {
                                // Replace non-printable characters with '?'
                                try processed_output.append('?');
                            }
                        }
                        
                        if (output_capture) |capture| {
                            try capture.write(processed_output.items);
                        } else {
                            print("{s}", .{processed_output.items});
                        }
                        
                        // If we read less than the buffer size, we're done
                        if (bytes_read < buffer.len) break;
                    }
                    
                    return CommandStatus{ .Code = 0 };
                },
                .Sort => {
                    var lines = ArrayList([]const u8).init(allocator);
                    defer {
                        for (lines.items) |line| {
                            allocator.free(line);
                        }
                        lines.deinit();
                    }
                    
                    // Read input lines
                    if (input_source) |source| {
                        // Read from input redirection
                        while (try source.readLine(allocator)) |line| {
                            try lines.append(line);
                        }
                    } else {
                        // Read from stdin (simplified - just show message)
                        const msg = "SORT: Use input redirection (< file.txt) to sort file contents\n";
                        if (output_capture) |capture| {
                            try capture.write(msg);
                        } else {
                            print("{s}", .{msg});
                        }
                        return CommandStatus{ .Code = 0 };
                    }
                    
                    // Sort the lines
                    std.mem.sort([]const u8, lines.items, {}, struct {
                        fn lessThan(_: void, lhs: []const u8, rhs: []const u8) bool {
                            return std.mem.order(u8, lhs, rhs) == .lt;
                        }
                    }.lessThan);
                    
                    // Output sorted lines
                    var output_buffer = ArrayList(u8).init(allocator);
                    defer output_buffer.deinit();
                    
                    for (lines.items) |line| {
                        try output_buffer.writer().print("{s}\n", .{line});
                    }
                    
                    if (output_capture) |capture| {
                        try capture.write(output_buffer.items);
                    } else {
                        print("{s}", .{output_buffer.items});
                    }
                    
                    return CommandStatus{ .Code = 0 };
                },
                else => {
                    const error_msg = try std.fmt.allocPrint(allocator, "Command not implemented: {any}\n", .{builtin_cmd});
                    defer allocator.free(error_msg);
                    if (output_capture) |capture| {
                        try capture.write(error_msg);
                    } else {
                        print("{s}", .{error_msg});
                    }
                    return CommandStatus{ .Code = 1 };
                },
            }
        },
        
        .External => |external| {
            // Try to execute external command
            var child_args = ArrayList([]const u8).init(allocator);
            defer child_args.deinit();
            
            try child_args.append(external.program);
            for (external.args.items) |arg| {
                try child_args.append(arg);
            }
            
            var child = std.process.Child.init(child_args.items, allocator);
            
            // Set up pipes for capturing output
            child.stdin_behavior = if (input_source != null) .Pipe else .Inherit;
            child.stdout_behavior = if (output_capture != null) .Pipe else .Inherit;
            child.stderr_behavior = if (output_capture != null) .Pipe else .Inherit;
            
            const spawn_result = child.spawn();
            if (spawn_result) |_| {
                // Spawn succeeded, continue with execution
            } else |err| switch (err) {
                error.FileNotFound => {
                    const error_msg = try std.fmt.allocPrint(allocator, "'{s}' is not recognized as an internal or external command,\noperable program or batch file.\n", .{external.program});
                    defer allocator.free(error_msg);
                    
                    if (output_capture) |capture| {
                        try capture.write(error_msg);
                    } else {
                        print("{s}", .{error_msg});
                    }
                    return CommandStatus{ .Code = 1 };
                },
                error.AccessDenied => {
                    const error_msg = "Access is denied.\n";
                    if (output_capture) |capture| {
                        try capture.write(error_msg);
                    } else {
                        print("{s}", .{error_msg});
                    }
                    return CommandStatus{ .Code = 1 };
                },
                else => {
                    const error_msg = try std.fmt.allocPrint(allocator, "Cannot execute '{s}': {}\n", .{ external.program, err });
                    defer allocator.free(error_msg);
                    
                    if (output_capture) |capture| {
                        try capture.write(error_msg);
                    } else {
                        print("{s}", .{error_msg});
                    }
                    return CommandStatus{ .Code = 1 };
                }
            }
            
            // Handle input redirection
            if (input_source) |source| {
                if (child.stdin) |stdin| {
                    const writer = stdin.writer();
                    
                    // Reset source position for reading
                    var temp_source = source.*;
                    temp_source.position = 0;
                    
                    while (try temp_source.readLine(allocator)) |line| {
                        defer allocator.free(line);
                        try writer.print("{s}\n", .{line});
                    }
                    child.stdin.?.close();
                    child.stdin = null;
                }
            }
            
            // Handle output capture
            if (output_capture) |capture| {
                // Read stdout
                if (child.stdout) |stdout| {
                    var buffer: [4096]u8 = undefined;
                    while (true) {
                        const bytes_read = stdout.read(&buffer) catch break;
                        if (bytes_read == 0) break;
                        try capture.write(buffer[0..bytes_read]);
                    }
                }
                
                // Read stderr 
                if (child.stderr) |stderr| {
                    var buffer: [4096]u8 = undefined;
                    while (true) {
                        const bytes_read = stderr.read(&buffer) catch break;
                        if (bytes_read == 0) break;
                        try capture.write(buffer[0..bytes_read]);
                    }
                }
            }
            
            // Wait for process to complete
            const term = child.wait() catch |err| {
                const error_msg = switch (err) {
                    error.FileNotFound => try std.fmt.allocPrint(allocator, "'{s}' is not recognized as an internal or external command,\noperable program or batch file.\n", .{external.program}),
                    else => try std.fmt.allocPrint(allocator, "Error waiting for command: {}\n", .{err}),
                };
                defer allocator.free(error_msg);
                
                if (output_capture) |capture| {
                    try capture.write(error_msg);
                } else {
                    print("{s}", .{error_msg});
                }
                return CommandStatus{ .Code = 1 };
            };
            
            // Return exit code
            switch (term) {
                .Exited => |code| return CommandStatus{ .Code = @intCast(code) },
                .Signal => |_| return CommandStatus{ .Code = 1 },
                .Stopped => |_| return CommandStatus{ .Code = 1 },
                .Unknown => |_| return CommandStatus{ .Code = 1 },
            }
        },
        
        .Redirect => |redirect| {
            var captured_output = OutputCapture.init(allocator);
            defer captured_output.deinit();
            
            // Prepare input redirection if needed
            var input_data: ?[]const u8 = null;
            var redirect_input_source: ?InputSource = null;
            defer if (input_data) |data| allocator.free(data);
            
            // Process input redirections first
            for (redirect.redirects.items) |redir| {
                if (redir.redirect_type == .InputFrom) {
                    const file_path = switch (redir.target) {
                        .Con => {
                            print("Input redirection from CON not supported\n", .{});
                            return CommandStatus{ .Code = 1 };
                        },
                        .Lpt1, .Lpt2, .Lpt3, .Prn => {
                            print("Cannot redirect input from device\n", .{});
                            return CommandStatus{ .Code = 1 };
                        },
                        .Path => |path| path,
                    };
                    
                    // Read input file
                    const file = std.fs.cwd().openFile(file_path, .{}) catch |err| {
                        switch (err) {
                            error.FileNotFound => print("The system cannot find the file specified.\n", .{}),
                            error.AccessDenied => print("Access is denied.\n", .{}),
                            else => print("Cannot open input file.\n", .{}),
                        }
                        return CommandStatus{ .Code = 1 };
                    };
                    defer file.close();
                    
                    input_data = file.readToEndAlloc(allocator, std.math.maxInt(usize)) catch |err| {
                        switch (err) {
                            error.AccessDenied => print("Access is denied.\n", .{}),
                            else => print("Cannot read input file.\n", .{}),
                        }
                        return CommandStatus{ .Code = 1 };
                    };
                    
                    redirect_input_source = InputSource.init(input_data.?);
                    break; // Only handle first input redirection
                }
            }
            
            // Execute the command with input and output capture
            const status = try executeCommandWithOutput(redirect.command.*, allocator, &captured_output, if (redirect_input_source) |*source| source else null);
            
            // Handle output redirections
            for (redirect.redirects.items) |redir| {
                if (redir.redirect_type == .InputFrom) continue; // Already handled
                const file_path = switch (redir.target) {
                    .Con => {
                        // Redirect to console - just print normally
                        print("{s}", .{captured_output.getContents()});
                        continue;
                    },
                    .Lpt1, .Lpt2, .Lpt3, .Prn => {
                        print("Cannot redirect to device\n", .{});
                        return CommandStatus{ .Code = 1 };
                    },
                    .Path => |path| path,
                };
                
                // Handle different redirect types
                switch (redir.redirect_type) {
                    .OutputOverwrite => {
                        // Write to file, overwriting existing content
                        const file = std.fs.cwd().createFile(file_path, .{}) catch |err| {
                            switch (err) {
                                error.AccessDenied => print("Access is denied.\n", .{}),
                                else => print("Cannot create file.\n", .{}),
                            }
                            return CommandStatus{ .Code = 1 };
                        };
                        defer file.close();
                        
                        file.writeAll(captured_output.getContents()) catch |err| {
                            switch (err) {
                                error.AccessDenied => print("Access is denied.\n", .{}),
                                else => print("Cannot write to file.\n", .{}),
                            }
                            return CommandStatus{ .Code = 1 };
                        };
                    },
                    .OutputAppend => {
                        // Append to file
                        const file = std.fs.cwd().openFile(file_path, .{ .mode = .write_only }) catch |err| {
                            switch (err) {
                                error.FileNotFound => {
                                    // Create new file if it doesn't exist
                                    const new_file = std.fs.cwd().createFile(file_path, .{}) catch |create_err| {
                                        switch (create_err) {
                                            error.AccessDenied => print("Access is denied.\n", .{}),
                                            else => print("Cannot create file.\n", .{}),
                                        }
                                        return CommandStatus{ .Code = 1 };
                                    };
                                    defer new_file.close();
                                    
                                    new_file.writeAll(captured_output.getContents()) catch {
                                        print("Cannot write to file.\n", .{});
                                        return CommandStatus{ .Code = 1 };
                                    };
                                    continue;
                                },
                                error.AccessDenied => {
                                    print("Access is denied.\n", .{});
                                    return CommandStatus{ .Code = 1 };
                                },
                                else => {
                                    print("Cannot open file.\n", .{});
                                    return CommandStatus{ .Code = 1 };
                                },
                            }
                        };
                        defer file.close();
                        
                        // Seek to end for append
                        file.seekFromEnd(0) catch {
                            print("Cannot seek to end of file.\n", .{});
                            return CommandStatus{ .Code = 1 };
                        };
                        
                        file.writeAll(captured_output.getContents()) catch |err| {
                            switch (err) {
                                error.AccessDenied => print("Access is denied.\n", .{}),
                                else => print("Cannot write to file.\n", .{}),
                            }
                            return CommandStatus{ .Code = 1 };
                        };
                    },
                    .InputFrom => {
                        // Input redirection already handled above
                        continue;
                    },
                }
            }
            
            return status;
        },
        
        else => {
            const error_msg = "Command type not implemented\n";
            if (output_capture) |capture| {
                try capture.write(error_msg);
            } else {
                print("{s}", .{error_msg});
            }
            return CommandStatus{ .Code = 1 };
        },
    }
}

fn executeCommand(command: Command, allocator: Allocator) !CommandStatus {
    return executeCommandWithOutput(command, allocator, null, null);
}

fn readLine(allocator: Allocator, prompt_text: []const u8) !?[]const u8 {
    const stdin = std.io.getStdIn().reader();
    print("{s}", .{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();

    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 => {
                        print("Bad command or file name\n", .{});
                        continue;
                    },
                    else => return err,
                }
            };

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