const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const math = std.math;
const Allocator = mem.Allocator;
const ArrayListAligned = std.ArrayListAligned;
const StringHashMap = std.StringHashMap;
const fieldInfo = std.meta.fieldInfo;

const validate = @import("validate.zig");
const compress = @import("compress.zig");
const ShellReader = @import("shell.zig").ShellReader;
const InvalidRecord = validate.InvalidRecord;
const User = @import("User.zig");

const PackedUser = @This();
pub const alignment_bits = 3;

const Inner = packed struct {
    uid: u32,
    gid: u32,
    shell_len_or_idx: u8,
    shell_here: bool,
    name_is_a_suffix: bool,
    home_len: u6,
    name_len: u5,
    gecos_len: u11,

    fn homeLen(self: *const Inner) usize {
        return @as(u32, self.home_len) + 1;
    }

    fn nameStart(self: *const Inner) usize {
        const name_len = self.nameLen();
        if (self.name_is_a_suffix) {
            return self.homeLen() - name_len;
        } else return self.homeLen();
    }

    fn nameLen(self: *const Inner) usize {
        return @as(u32, self.name_len) + 1;
    }

    fn gecosStart(self: *const Inner) usize {
        if (self.name_is_a_suffix) {
            return self.homeLen();
        } else return self.homeLen() + self.nameLen();
    }

    fn gecosLen(self: *const Inner) usize {
        return self.gecos_len;
    }

    fn maybeShellStart(self: *const Inner) usize {
        assert(self.shell_here);
        return self.gecosStart() + self.gecosLen();
    }

    fn shellLen(self: *const Inner) usize {
        return @as(u32, self.shell_len_or_idx) + 1;
    }

    // stringLength returns the length of the blob storing string values.
    fn stringLength(self: *const Inner) usize {
        var result: usize = self.homeLen() + self.gecosLen();
        if (!self.name_is_a_suffix)
            result += self.nameLen();
        if (self.shell_here)
            result += self.shellLen();
        return result;
    }
};

// PackedUser does not allocate; it re-interprets the var_payload
// field. Both of those fields are pointers to "our representation" of
// that field.
inner: *align(8) const Inner,
var_payload: []const u8,
additional_gids_offset: u64,

pub const Entry = struct {
    user: PackedUser,
    end: usize,
};

pub fn fromBytes(blob: []align(8) const u8) error{Overflow}!Entry {
    const start_var_payload = @bitSizeOf(Inner) / 8;
    const inner = @ptrCast(*align(8) const Inner, blob[0..start_var_payload]);
    const end_strings = start_var_payload + inner.stringLength();
    const gids_offset = try compress.uvarint(blob[end_strings..]);
    const end_payload = end_strings + gids_offset.bytes_read;

    return Entry{
        .user = PackedUser{
            .inner = inner,
            .var_payload = blob[start_var_payload..end_payload],
            .additional_gids_offset = gids_offset.value,
        },
        .end = mem.alignForward(usize, end_payload, 8),
    };
}

pub const Iterator = struct {
    section: []align(8) const u8,
    next_start: usize = 0,
    shell_reader: ShellReader,
    idx: u32 = 0,
    total: u32,
    advanced_by: usize = 0,

    pub fn next(it: *Iterator) error{Overflow}!?PackedUser {
        if (it.idx == it.total) return null;
        const entry = try fromBytes(@alignCast(8, it.section[it.next_start..]));
        it.idx += 1;
        it.next_start += entry.end;
        it.advanced_by = entry.end;
        return entry.user;
    }

    pub fn rollback(it: *Iterator) void {
        assert(it.advanced_by > 0);
        it.idx -= 1;
        it.next_start -= it.advanced_by;
        it.advanced_by = 0;
    }
};

pub fn iterator(section: []align(8) const u8, total: u32, shell_reader: ShellReader) Iterator {
    return Iterator{
        .section = section,
        .total = total,
        .shell_reader = shell_reader,
    };
}

// packTo packs the User record and copies it to the given arraylist.
pub fn packTo(
    arr: *ArrayListAligned(u8, 8),
    user: User,
    additional_gids_offset: u64,
    idxFn: StringHashMap(u8),
) error{ InvalidRecord, OutOfMemory }!void {
    std.debug.assert(arr.items.len & 7 == 0);
    // function arguments are consts. We need to mutate the underlying
    // slice, so passing it via pointer instead.
    const home_len = try validate.downCast(fieldInfo(Inner, .home_len).type, user.home.len - 1);
    const name_len = try validate.downCast(fieldInfo(Inner, .name_len).type, user.name.len - 1);
    const shell_len = try validate.downCast(fieldInfo(Inner, .shell_len_or_idx).type, user.shell.len - 1);
    const gecos_len = try validate.downCast(fieldInfo(Inner, .gecos_len).type, user.gecos.len);

    try validate.utf8(user.home);
    try validate.utf8(user.name);
    try validate.utf8(user.shell);
    try validate.utf8(user.gecos);

    const inner = Inner{
        .uid = user.uid,
        .gid = user.gid,
        .shell_here = idxFn.get(user.shell) == null,
        .shell_len_or_idx = idxFn.get(user.shell) orelse shell_len,
        .home_len = home_len,
        .name_is_a_suffix = mem.endsWith(u8, user.home, user.name),
        .name_len = name_len,
        .gecos_len = gecos_len,
    };
    try arr.*.appendSlice(mem.asBytes(&inner)[0 .. @bitSizeOf(Inner) / 8]);
    try arr.*.appendSlice(user.home);

    if (!inner.name_is_a_suffix)
        try arr.*.appendSlice(user.name);
    try arr.*.appendSlice(user.gecos);
    if (inner.shell_here)
        try arr.*.appendSlice(user.shell);
    try compress.appendUvarint(arr, additional_gids_offset);
}

pub fn uid(self: PackedUser) u32 {
    return self.inner.uid;
}

pub fn gid(self: PackedUser) u32 {
    return self.inner.gid;
}

pub fn additionalGidsOffset(self: PackedUser) u64 {
    return self.additional_gids_offset;
}

pub fn home(self: PackedUser) []const u8 {
    return self.var_payload[0..self.inner.homeLen()];
}

pub fn name(self: PackedUser) []const u8 {
    const name_pos = self.inner.nameStart();
    const name_len = self.inner.nameLen();
    return self.var_payload[name_pos .. name_pos + name_len];
}

pub fn gecos(self: PackedUser) []const u8 {
    const gecos_pos = self.inner.gecosStart();
    const gecos_len = self.inner.gecosLen();
    return self.var_payload[gecos_pos .. gecos_pos + gecos_len];
}

pub fn shell(self: PackedUser, shell_reader: ShellReader) []const u8 {
    if (self.inner.shell_here) {
        const shell_pos = self.inner.maybeShellStart();
        const shell_len = self.inner.shellLen();
        return self.var_payload[shell_pos .. shell_pos + shell_len];
    }
    return shell_reader.get(self.inner.shell_len_or_idx);
}

// returns a User representation of the PackedUser.
pub fn toUser(self: *const PackedUser, shell_reader: ShellReader) User {
    return User{
        .uid = self.uid(),
        .gid = self.gid(),
        .name = self.name(),
        .gecos = self.gecos(),
        .home = self.home(),
        .shell = self.shell(shell_reader),
    };
}

pub const max_home_len = math.maxInt(fieldInfo(Inner, .home_len).type) + 1;
pub const max_name_len = math.maxInt(fieldInfo(Inner, .name_len).type) + 1;
pub const max_gecos_len = math.maxInt(fieldInfo(Inner, .gecos_len).type);

pub const max_str_len =
    math.maxInt(fieldInfo(Inner, .shell_len_or_idx).type) + 1 +
    max_home_len +
    max_name_len +
    max_gecos_len;

const testing = std.testing;

fn testShellIndex(allocator: Allocator) StringHashMap(u8) {
    var result = StringHashMap(u8).init(allocator);
    result.put("/bin/bash", 0) catch unreachable;
    result.put("/bin/zsh", 1) catch unreachable;
    return result;
}

const test_shell_reader_index: [3]u16 align(8) = .{ 0, 9, 17 };
const test_shell_reader = ShellReader{
    .blob = "/bin/bash/bin/zsh",
    .index = &test_shell_reader_index,
};

test "PackedUser pack max_user" {
    var arr = ArrayListAligned(u8, 8).init(testing.allocator);
    defer arr.deinit();

    var idx_noop = StringHashMap(u8).init(testing.allocator);
    defer idx_noop.deinit();

    try packTo(&arr, User.max_user, 0, idx_noop);
}

test "PackedUser construct section" {
    var buf = ArrayListAligned(u8, 8).init(testing.allocator);
    defer buf.deinit();

    const users = [_]User{ User{
        .uid = 1000,
        .gid = 1000,
        .name = "vidmantas",
        .gecos = "Vidmantas Kaminskas",
        .home = "/home/vidmantas",
        .shell = "/bin/bash",
    }, User{
        .uid = 1001,
        .gid = 1001,
        .name = "svc-foo",
        .gecos = "Service Account",
        .home = "/home/service1",
        .shell = "/usr/bin/nologin",
    }, User.max_user, User{
        .uid = 1002,
        .gid = 1002,
        .name = "svc-bar",
        .gecos = "",
        .home = "/",
        .shell = "/bin/zsh",
    } };
    var shellIndex = testShellIndex(testing.allocator);
    const additional_gids = math.maxInt(u64);
    defer shellIndex.deinit();
    for (users) |user| {
        try PackedUser.packTo(&buf, user, additional_gids, shellIndex);
        try buf.appendNTimes(0, mem.alignForward(usize, buf.items.len, 8) - buf.items.len);
    }

    var i: u29 = 0;
    var it1 = PackedUser.iterator(buf.items, users.len, test_shell_reader);
    while (try it1.next()) |user| : (i += 1) {
        try testing.expectEqual(users[i].uid, user.uid());
        try testing.expectEqual(users[i].gid, user.gid());
        try testing.expectEqual(user.additionalGidsOffset(), additional_gids);
        try testing.expectEqualStrings(users[i].name, user.name());
        try testing.expectEqualStrings(users[i].gecos, user.gecos());
        try testing.expectEqualStrings(users[i].home, user.home());
        try testing.expectEqualStrings(users[i].shell, user.shell(test_shell_reader));
    }
    try testing.expectEqual(users.len, i);
}
