path: root/src/cmd/dir.zig

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

const c = @cImport({
    @cInclude("errno.h");
    @cInclude("stdio.h");
});

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

const types = @import("./lib/types.zig");
const CommandStatus = types.CommandStatus;
const CommandContext = types.CommandContext;
const OutputCapture = types.OutputCapture;
const InputSource = types.InputSource;

fn formatDosDateTime(allocator: Allocator, timestamp_secs: i64) ![]const u8 {
    const epoch_seconds = @as(u64, @intCast(@max(timestamp_secs, 0)));
    const epoch_day = @divFloor(epoch_seconds, std.time.s_per_day);
    const day_seconds = epoch_seconds % std.time.s_per_day;

    // Calculate date (simplified)
    var year: u32 = 1970; // Start from Unix epoch year
    var remaining_days = epoch_day;

    // Simple year calculation
    while (remaining_days >= 365) {
        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;
    }

    // Simple month/day calculation (approximate)
    const month = @min(@divFloor(remaining_days, 30) + 1, 12);
    const day = @min(remaining_days % 30 + 1, 31);

    // Calculate time
    const hours = day_seconds / std.time.s_per_hour;
    const minutes = (day_seconds % std.time.s_per_hour) / std.time.s_per_min;

    // Format as MM-DD-YY HH:MMa (DOS style)
    const am_pm = if (hours < 12) "a" else "p";
    const display_hour = if (hours == 0) 12 else if (hours > 12) hours - 12 else hours;

    return try std.fmt.allocPrint(allocator, "{d:0>2}-{d:0>2}-{d:0>2}  {d:>2}:{d:0>2}{s}", .{ @as(u32, @intCast(month)), @as(u32, @intCast(day)), @as(u32, @intCast(year % 100)), @as(u32, @intCast(display_hour)), @as(u32, @intCast(minutes)), am_pm });
}

fn formatWithCommas(allocator: Allocator, number: u64) ![]const u8 {
    // Convert number to string first
    const num_str = try std.fmt.allocPrint(allocator, "{d}", .{number});
    defer allocator.free(num_str);

    // Calculate how many commas we need
    const digits = num_str.len;
    const comma_count = if (digits <= 3) 0 else @divFloor(digits - 1, 3);

    if (comma_count == 0) {
        return try allocator.dupe(u8, num_str);
    }

    // Allocate space for number + commas
    const result = try allocator.alloc(u8, digits + comma_count);

    var result_idx: usize = result.len;
    var num_idx: usize = num_str.len;
    var digit_count: usize = 0;

    // Work backwards, adding commas every 3 digits
    while (num_idx > 0) {
        num_idx -= 1;
        result_idx -= 1;
        result[result_idx] = num_str[num_idx];
        digit_count += 1;

        // Add comma every 3 digits (but not at the beginning)
        if (digit_count % 3 == 0 and num_idx > 0) {
            result_idx -= 1;
            result[result_idx] = ',';
        }
    }

    return result;
}

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

const GetFreeDiskSpaceError = error{ NotImplemented, AccessDenied, OutOfMemory };

fn getFreeDiskSpace(path: []const u8) GetFreeDiskSpaceError!u64 {
    if (@import("builtin").os.tag == .windows) {
        return error.NotImplemented;
    }

    // Create null-terminated path for C function
    const allocator = std.heap.page_allocator;
    const null_terminated_path = try allocator.dupeZ(u8, path);
    defer allocator.free(null_terminated_path);

    const free_space = get_statvfs_free_space(null_terminated_path.ptr);
    if (free_space == 0) {
        return error.AccessDenied;
    }

    return free_space;
}

extern fn statvfs_get_free_space_impl(path: [*:0]const u8) u64;

fn get_statvfs_free_space(path: [*:0]const u8) u64 {
    // Call the C function that uses statvfs internally to avoid struct issues
    return statvfs_get_free_space_impl(path);
}

pub const Dir = struct {
    path: []const u8,
    wide_format: bool = false, // /w flag
    bare_format: bool = false, // /b flag
    subdirs: bool = false, // /s flag

    pub fn eval(dir: Dir, ctx: CommandContext) !CommandStatus {
        var output_buffer = ArrayList(u8).init(ctx.allocator);
        defer output_buffer.deinit();

        // Format path in DOS style with backslashes and uppercase drive letter
        const formatted_path = try formatDosPath(ctx.allocator, dir.path);
        defer ctx.allocator.free(formatted_path);

        // Only show header for non-bare format
        if (!dir.bare_format) {
            // Get volume label (simplified - just show drive)
            const drive_letter = if (formatted_path.len >= 2 and formatted_path[1] == ':')
                formatted_path[0]
            else
                'C';
            try output_buffer.writer().print(" Volume in drive {c} has no label\n", .{drive_letter});
            try output_buffer.writer().print(" Volume Serial Number is 1234-5678\n", .{});
            try output_buffer.writer().print("\n Directory of {s}\n\n", .{formatted_path});
        }

        var dir_iterator = std.fs.cwd().openDir(dir.path, .{ .iterate = true }) catch {
            const error_msg = "File not found\n";
            var writer = ctx.output_writer;
            try writer.write(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;
        var total_file_bytes: u64 = 0;

        while (try iterator.next()) |entry| {
            const stat = dir_iterator.statFile(entry.name) catch continue;

            // Convert timestamp to DOS date/time format
            const mtime_secs = @divFloor(stat.mtime, std.time.ns_per_s);
            const date_time = try formatDosDateTime(ctx.allocator, @intCast(mtime_secs));
            defer ctx.allocator.free(date_time);

            // Convert filename to 8.3 format
            const short_name = try convertTo83(ctx.allocator, entry.name);
            defer ctx.allocator.free(short_name.name);
            defer ctx.allocator.free(short_name.ext);

            // Format the output.
            const name = short_name.name;
            const ext = short_name.ext;

            switch (entry.kind) {
                .directory => {
                    if (dir.bare_format) {
                        try output_buffer.writer().print("{s}\n", .{entry.name});
                    } else if (dir.wide_format) {
                        try output_buffer.writer().print("{s:<12} ", .{entry.name});
                    } else {
                        try output_buffer.writer().print("{s:<8} {s:<3} <DIR>           {s}\n", .{ name, ext, date_time });
                    }
                    dir_count += 1;
                },
                .file => {
                    if (dir.bare_format) {
                        try output_buffer.writer().print("{s}\n", .{entry.name});
                    } else if (dir.wide_format) {
                        try output_buffer.writer().print("{s:<12} ", .{entry.name});
                    } else {
                        const formatted_size = try formatWithCommas(ctx.allocator, stat.size);
                        defer ctx.allocator.free(formatted_size);
                        try output_buffer.writer().print("{s:<8} {s:<3}  {s:>14} {s}\n", .{ name, ext, formatted_size, date_time });
                    }
                    file_count += 1;
                    total_file_bytes += stat.size;
                },
                else => {},
            }
        }

        // Add newline after wide format listing
        if (dir.wide_format and !dir.bare_format) {
            try output_buffer.writer().print("\n", .{});
        }

        // Only show footer for non-bare format
        if (!dir.bare_format) {
            // Get free disk space using statvfs
            const path = try std.fs.cwd().realpathAlloc(ctx.allocator, dir.path);
            defer ctx.allocator.free(path);
            const bytes_free = getFreeDiskSpace(path) catch |err| switch (err) {
                error.AccessDenied => 0,
                error.NotImplemented => 0,
                error.OutOfMemory => 0,
            };

            const formatted_total_bytes = try formatWithCommas(ctx.allocator, total_file_bytes);
            defer ctx.allocator.free(formatted_total_bytes);
            const formatted_free_bytes = try formatWithCommas(ctx.allocator, bytes_free);
            defer ctx.allocator.free(formatted_free_bytes);

            try output_buffer.writer().print("        {d} File(s) {s:>14} bytes\n", .{ file_count, formatted_total_bytes });
            try output_buffer.writer().print("        {d} Dir(s)  {s:>14} bytes free\n", .{ dir_count, formatted_free_bytes });
        }

        var writer = ctx.output_writer;
        try writer.write(output_buffer.items);
        return CommandStatus{ .Code = 0 };
    }
};