//! A file-system object. Represents a File or directory.

const std = @import("std");
const Reader = std.Io.Reader;
const WaitGroup = std.Thread.WaitGroup;
const Pool = std.Thread.Pool;
const Mutex = std.Thread.Mutex;

const Archive = @import("archive.zig");
const DirEntry = @import("dir_entry.zig");
const ExtractionOptions = @import("options.zig");
const dir = @import("inode_data/dir.zig");
const file = @import("inode_data/file.zig");
const misc = @import("inode_data/misc.zig");
const DataReader = @import("util/data.zig");
const ThreadedDataReader = @import("util/data_threaded.zig");
const MetadataReader = @import("util/metadata.zig");

pub const Ref = packed struct {
    block_offset: u16,
    block_start: u32,
    _: u16,
};

pub const InodeType = enum(u16) {
    dir = 1,
    file,
    symlink,
    block_dev,
    char_dev,
    fifo,
    socket,
    ext_dir,
    ext_file,
    ext_symlink,
    ext_block_dev,
    ext_char_dev,
    ext_fifo,
    ext_socket,
};

pub const InodeData = union(InodeType) {
    dir: dir.Dir,
    file: file.File,
    symlink: misc.Symlink,
    block_dev: misc.Dev,
    char_dev: misc.Dev,
    fifo: misc.IPC,
    socket: misc.IPC,
    ext_dir: dir.ExtDir,
    ext_file: file.ExtFile,
    ext_symlink: misc.ExtSymlink,
    ext_block_dev: misc.ExtDev,
    ext_char_dev: misc.ExtDev,
    ext_fifo: misc.ExtIPC,
    ext_socket: misc.ExtIPC,
};

pub const Header = packed struct {
    inode_type: InodeType,
    permissions: u16,
    uid_idx: u16,
    gid_idx: u16,
    mod_time: u32,
    num: u32,
};

const Inode = @This();

hdr: Header,
data: InodeData,

pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !Inode {
    var hdr: Header = undefined;
    try rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
    return .{
        .hdr = hdr,
        .data = switch (hdr.inode_type) {
            .dir => .{ .dir = try .read(rdr) },
            .file => .{ .file = try .read(alloc, rdr, block_size) },
            .symlink => .{ .symlink = try .read(alloc, rdr) },
            .block_dev => .{ .block_dev = try .read(rdr) },
            .char_dev => .{ .char_dev = try .read(rdr) },
            .fifo => .{ .fifo = try .read(rdr) },
            .socket => .{ .socket = try .read(rdr) },
            .ext_dir => .{ .ext_dir = try .read(rdr) },
            .ext_file => .{ .ext_file = try .read(alloc, rdr, block_size) },
            .ext_symlink => .{ .ext_symlink = try .read(alloc, rdr) },
            .ext_block_dev => .{ .ext_block_dev = try .read(rdr) },
            .ext_char_dev => .{ .ext_char_dev = try .read(rdr) },
            .ext_fifo => .{ .ext_fifo = try .read(rdr) },
            .ext_socket => .{ .ext_socket = try .read(rdr) },
        },
    };
}
pub fn readFromEntry(alloc: std.mem.Allocator, archive: *Archive, entry: DirEntry) !Inode {
    var rdr = try archive.fil.readerAt(archive.super.inode_start + entry.block_start, &[0]u8{});
    var meta: MetadataReader = .init(alloc, &rdr.interface, archive.decomp);
    try meta.interface.discardAll(entry.block_offset);
    return read(alloc, &meta.interface, archive.super.block_size);
}

pub fn deinit(self: Inode, alloc: std.mem.Allocator) void {
    switch (self.data) {
        .file => |f| alloc.free(f.block_sizes),
        .ext_file => |f| alloc.free(f.block_sizes),
        .symlink => |s| alloc.free(s.target),
        .ext_symlink => |s| alloc.free(s.target),
        else => {},
    }
}

/// Get the data reader for a file inode.
pub fn dataReader(self: Inode, alloc: std.mem.Allocator, archive: *Archive) !DataReader {
    return switch (self.hdr.inode_type) {
        .file => readerFromData(alloc, archive, self.data.file),
        .ext_file => readerFromData(alloc, archive, self.data.ext_file),
        else => error.NotRegularFile,
    };
}
fn readerFromData(alloc: std.mem.Allocator, archive: *Archive, data: anytype) !DataReader {
    var out: DataReader = .init(alloc, archive.*, data.block_sizes, data.block_start, data.size);
    if (data.frag_idx != 0xFFFFFFFF)
        out.addFragment(try archive.frag_table.get(data.frag_idx), data.frag_block_offset);
    return out;
}
/// Get a threaded data reader for a file inode.
pub fn threadedDataReader(self: Inode, alloc: std.mem.Allocator, archive: *Archive) !ThreadedDataReader {
    return switch (self.hdr.inode_type) {
        .file => threadedReaderFromData(alloc, archive, self.data.file),
        .ext_file => threadedReaderFromData(alloc, archive, self.data.ext_file),
        else => error.NotRegularFile,
    };
}
fn threadedReaderFromData(alloc: std.mem.Allocator, archive: *Archive, data: anytype) !ThreadedDataReader {
    var out: ThreadedDataReader = .init(alloc, archive.*, data.block_sizes, data.block_start, data.size);
    if (data.frag_idx != 0xFFFFFFFF)
        out.addFragment(try archive.frag_table.get(data.frag_idx), data.frag_block_offset);
    return out;
}

/// Get the directory entries for a directory inode.
pub fn dirEntries(self: Inode, alloc: std.mem.Allocator, archive: Archive) ![]DirEntry {
    return switch (self.hdr.inode_type) {
        .dir => entriesFromData(alloc, archive, self.data.dir),
        .ext_dir => entriesFromData(alloc, archive, self.data.ext_dir),
        else => error.NotDirectory,
    };
}
fn entriesFromData(alloc: std.mem.Allocator, archive: Archive, data: anytype) ![]DirEntry {
    var rdr = try archive.fil.readerAt(archive.super.dir_start + data.block_start, &[0]u8{});
    var meta: MetadataReader = .init(alloc, &rdr.interface, archive.decomp);
    try meta.interface.discardAll(data.block_offset);
    return DirEntry.readDir(alloc, &meta.interface, data.size);
}

/// Extract the inode to the given path. Single threaded.
pub fn extractTo(self: Inode, alloc: std.mem.Allocator, archive: *Archive, path: []const u8, options: ExtractionOptions) !void {
    if (options.threads > 1) return self.extractToThreaded(alloc, archive, path, options);
    switch (self.hdr.inode_type) {
        .dir, .ext_dir => {
            // Removing any trailing separators since that's the easiest path forward.
            if (path[path.len - 1] == '/') return self.extractTo(alloc, archive, path[0 .. path.len - 1], options);
            std.fs.cwd().makeDir(path) catch |err| {
                if (err != std.fs.Dir.MakeError.PathAlreadyExists) return err;
            };
            const entries = try self.dirEntries(alloc, archive.*);
            defer {
                for (entries) |entry| entry.deinit(alloc);
                alloc.free(entries);
            }
            for (entries) |entry| {
                var new_path = try alloc.alloc(u8, path.len + 1 + entry.name.len);
                @memcpy(new_path[0..path.len], path);
                @memcpy(new_path[path.len + 1 ..], entry.name);
                new_path[path.len] = '/';
                defer alloc.free(new_path);

                var inode: Inode = try readFromEntry(alloc, archive, entry);
                defer inode.deinit(alloc);
                try inode.extractTo(alloc, archive, new_path, options);
            }
        },
        .file, .ext_file => try self.extractRegFile(alloc, archive, path, options),
        .symlink, .ext_symlink => try self.extractSymlink(path),
        else => try self.extractDevice(archive, path, options),
    }
}

const Parent = struct {
    alloc: std.mem.Allocator,

    path: []const u8,
    uid: u16,
    gid: u16,
    perm: u16,
    mod_time: u32,

    ignore_permissions: bool,
    ignore_xattr: bool,

    wg: WaitGroup = .{},
    mut: Mutex = .{},

    fn create(alloc: std.mem.Allocator, hdr: Header, archive: *Archive, path: []const u8, options: ExtractionOptions, dir_size: usize) !*Parent {
        const out = try alloc.create(Parent);
        errdefer alloc.destroy(out);
        out.* = .{
            .alloc = alloc,

            .path = path,
            .uid = try archive.id_table.get(hdr.uid_idx),
            .gid = try archive.id_table.get(hdr.gid_idx),
            .perm = hdr.permissions,
            .mod_time = hdr.mod_time,

            .ignore_permissions = options.ignore_permissions,
            .ignore_xattr = options.ignore_xattr,
        };
        out.wg.startMany(dir_size);
        return out;
    }

    fn finish(p: *Parent) !void {
        p.mut.lock();
        {
            defer p.mut.unlock();
            p.wg.finish();
            if (!p.wg.isDone()) return;
        }
        defer p.alloc.destroy(p);
        var fil = try std.fs.cwd().openFile(p.path, .{});
        defer fil.close();
        const time = @as(i128, p.mod_time) * 1000000000;
        try fil.updateTimes(time, time);
        if (p.ignore_permissions) {
            try fil.chmod(p.perm);
            try fil.chown(p.uid, p.gid);
        }
    }
};

/// Extract the inode to the given path. Multi-threaded.
/// Functions identically to extractTo on all but regular files and directories.
///
/// If threads <= 1, then this just calls extractTo.
fn extractToThreaded(self: Inode, allocator: std.mem.Allocator, archive: *Archive, path: []const u8, options: ExtractionOptions) !void {
    switch (self.hdr.inode_type) {
        .dir, .ext_dir => {
            // Removing any trailing separators since that's the easiest path forward.
            if (path[path.len - 1] == '/') return self.extractToThreaded(allocator, archive, path[0 .. path.len - 1], options);

            // Fixed Allocator
            // const mem_buf = archive.allocator().alloc(u8, 2 * 1024 * 1024 * 1024);
            // defer archive.allocator().free(mem_buf);
            // var fixed_alloc: std.heap.FixedBufferAllocator = .init(mem_buf);
            // const alloc = fixed_alloc.threadSafeAllocator();

            // Arena Allocator
            var arena_alloc: std.heap.ArenaAllocator = .init(allocator);
            defer arena_alloc.deinit();
            var thread_alloc: std.heap.ThreadSafeAllocator = .{ .child_allocator = arena_alloc.allocator() };
            const alloc = thread_alloc.allocator();

            var wg: WaitGroup = .{};
            // defer if(!options.ignore_permissions) perms.?.deinit(alloc); We don't need to do this due to ArenaAllocator
            var pool: Pool = undefined;
            try pool.init(.{ .allocator = allocator, .n_jobs = options.threads - 1 });
            defer pool.deinit();
            var out_err: ?anyerror = null;

            wg.start();
            self.extractThread(alloc, archive, path, options, &wg, &pool, &out_err, null);
            pool.waitAndWork(&wg);
            if (out_err != null) return out_err.?;

            var fil = try std.fs.cwd().openFile(path, .{});
            defer fil.close();
            const time = @as(i128, self.hdr.mod_time) * 1000000000;
            try fil.updateTimes(time, time);
            if (options.ignore_permissions) {
                try fil.chmod(self.hdr.permissions);
                try fil.chown(try archive.id_table.get(self.hdr.uid_idx), try archive.id_table.get(self.hdr.gid_idx));
            }
        },
        .file, .ext_file => {
            var pool: Pool = undefined;
            try pool.init(.{ .allocator = allocator, .n_jobs = options.threads - 1 });
            defer pool.deinit();

            var arena_alloc: std.heap.ArenaAllocator = .init(allocator);
            defer arena_alloc.deinit();
            var thread_alloc: std.heap.ThreadSafeAllocator = .{ .child_allocator = arena_alloc.allocator() };
            const alloc = thread_alloc.allocator();

            try self.extractRegFileThreaded(alloc, archive, path, options, &pool);

            var fil = try std.fs.cwd().openFile(path, .{});
            defer fil.close();
            const time = @as(i128, self.hdr.mod_time) * 1000000000;
            try fil.updateTimes(time, time);
            if (!options.ignore_permissions) {
                try fil.chmod(self.hdr.permissions);
                try fil.chown(try archive.id_table.get(self.hdr.uid_idx), try archive.id_table.get(self.hdr.gid_idx));
            }
        },
        .symlink, .ext_symlink => try self.extractSymlink(path),
        else => try self.extractDevice(archive, path, options),
    }
}

fn extractThreadEntry(
    entry: DirEntry,
    alloc: std.mem.Allocator,
    archive: *Archive,
    path: []const u8,
    options: ExtractionOptions,
    wg: *WaitGroup,
    pool: *Pool,
    out_err: *?anyerror,
    parent: ?*Parent,
) void {
    var new_path = alloc.alloc(u8, path.len + entry.name.len + 1) catch |err| {
        wg.finish();
        out_err.* = err;
        return;
    };
    @memcpy(new_path[0..path.len], path);
    @memcpy(new_path[path.len + 1 ..], entry.name);
    new_path[path.len] = '/';
    var inode = readFromEntry(alloc, archive, entry) catch |err| {
        out_err.* = err;
        wg.finish();
        return;
    };
    inode.extractThread(alloc, archive, new_path, options, wg, pool, out_err, parent);
}

/// Extract threadedly the inode to the path.
fn extractThread(
    self: Inode,
    alloc: std.mem.Allocator,
    archive: *Archive,
    path: []const u8,
    options: ExtractionOptions,
    wg: *WaitGroup,
    pool: *Pool,
    out_err: *?anyerror,
    parent: ?*Parent,
) void {
    if (options.verbose)
        options.verbose_writer.?.print("Extracting inode #{} to {s}\n", .{ self.hdr.num, path }) catch {};
    defer {
        if (parent != null) parent.?.finish() catch |err| {
            if (options.verbose)
                options.verbose_writer.?.print("Error setting folder permission to {s}: {}\n", .{ path, err }) catch {};
            out_err.* = err;
        };
        wg.finish();
    }
    if (out_err.* != null) return;
    switch (self.hdr.inode_type) {
        .dir, .ext_dir => {
            _ = std.fs.cwd().makePathStatus(path) catch |err| {
                if (options.verbose)
                    options.verbose_writer.?.print("Error creating {s}: {}\n", .{ path, err }) catch {};
                out_err.* = err;
                return;
            };

            const entries = self.dirEntries(alloc, archive.*) catch |err| {
                if (options.verbose)
                    options.verbose_writer.?.print("Error getting directory entries for inode #{} (extracting to {s}): {}\n", .{ self.hdr.num, path, err }) catch {};
                out_err.* = err;
                return;
            };
            const p = Parent.create(alloc, self.hdr, archive, path, options, entries.len) catch |err| {
                out_err.* = err;
                return;
            };
            wg.startMany(entries.len);
            // defer files.deinit(alloc); We don't need to do this due to ArenaAllocator
            for (entries) |entry| {
                if (entry.inode_type == .dir) {
                    extractThreadEntry(entry, alloc, archive, path, options, wg, pool, out_err, p);
                    continue;
                }
                pool.spawn(
                    extractThreadEntry,
                    .{
                        entry,
                        alloc,
                        archive,
                        path,
                        options,
                        wg,
                        pool,
                        out_err,
                        p,
                    },
                ) catch |err| {
                    wg.finish();
                    if (options.verbose)
                        options.verbose_writer.?.print("Error starting extraction thread: {}\n", .{err}) catch {};
                    out_err.* = err;
                    continue;
                };
            }
        },
        .file, .ext_file => {
            self.extractRegFileThreaded(alloc, archive, path, options, pool) catch |err| {
                if (options.verbose)
                    options.verbose_writer.?.print("Error extracting file inode #{} to {s}: {}\n", .{ self.hdr.num, path, err }) catch {};
                out_err.* = err;
            };
        },
        .symlink, .ext_symlink => {
            self.extractSymlink(path) catch |err| {
                if (options.verbose)
                    options.verbose_writer.?.print("Error extracting symlink inode #{} to {s}: {}\n", .{ self.hdr.num, path, err }) catch {};
                out_err.* = err;
            };
        },
        else => {
            self.extractDevice(archive, path, options) catch |err| {
                if (options.verbose)
                    options.verbose_writer.?.print("Error extracting device/IPC inode #{} to {s}: {}\n", .{ self.hdr.num, path, err }) catch {};
                out_err.* = err;
            };
        },
    }
}
/// Creates and writes the inode file contents to the given path.
/// Optionally set owner & permissions.
///
/// Assumes the inode is a file or ext_file type.
fn extractRegFile(self: Inode, alloc: std.mem.Allocator, archive: *Archive, path: []const u8, options: ExtractionOptions) !void {
    var fil = try std.fs.cwd().createFile(path, .{ .exclusive = true });
    defer fil.close();
    var wrt = fil.writer(&[0]u8{});
    var dat_rdr = try self.dataReader(alloc, archive);
    defer dat_rdr.deinit();
    _ = try dat_rdr.interface.streamRemaining(&wrt.interface);
    try wrt.interface.flush();

    const time = @as(i128, self.hdr.mod_time) * 1000000000;
    try fil.updateTimes(time, time);
    if (!options.ignore_permissions) {
        try fil.chmod(self.hdr.permissions);
        try fil.chown(try archive.id_table.get(self.hdr.uid_idx), try archive.id_table.get(self.hdr.gid_idx));
    }
}
/// Extract the inode file contents to the given path threadedly.
/// pool is used to spawn threads.
///
/// Assumes the inode is a file or ext_file type.
fn extractRegFileThreaded(self: Inode, alloc: std.mem.Allocator, archive: *Archive, path: []const u8, options: ExtractionOptions, pool: *Pool) !void {
    var fil = try std.fs.cwd().createFile(path, .{});
    defer fil.close();
    var data = try self.threadedDataReader(alloc, archive);
    try data.extractThreaded(fil, pool);

    const time = @as(i128, self.hdr.mod_time) * 1000000000;
    try fil.updateTimes(time, time);
    if (!options.ignore_permissions) {
        try fil.chmod(self.hdr.permissions);
        try fil.chown(try archive.id_table.get(self.hdr.uid_idx), try archive.id_table.get(self.hdr.gid_idx));
    }
}
/// Creates the symlink described by the inode.
///
/// Assumes the inode is a symlink or ext_symlink type.
fn extractSymlink(self: Inode, path: []const u8) !void {
    const target = switch (self.data) {
        .symlink => |s| s.target,
        .ext_symlink => |s| s.target,
        else => unreachable,
    };
    try std.fs.cwd().symLink(target, path, .{});
}
/// Creates the device described by the inode.
///
/// Optionally set owner & permissions.
/// Assumes the inode is a char_dev, block_dev, fifo, socket, or their extended counterparts.
fn extractDevice(self: Inode, archive: *Archive, path: []const u8, options: ExtractionOptions) !void {
    var mode: u32 = undefined;
    var dev: u32 = 0;
    switch (self.data) {
        .char_dev => |d| {
            mode = std.posix.S.IFCHR;
            dev = d.dev;
        },
        .ext_char_dev => |d| {
            mode = std.posix.S.IFCHR;
            dev = d.dev;
        },
        .block_dev => |d| {
            mode = std.posix.S.IFBLK;
            dev = d.dev;
        },
        .ext_block_dev => |d| {
            mode = std.posix.S.IFBLK;
            dev = d.dev;
        },
        .fifo, .ext_fifo => mode = std.posix.S.IFIFO,
        .socket, .ext_socket => mode = std.posix.S.IFSOCK,
        else => unreachable,
    }
    const res: std.os.linux.E = @enumFromInt(std.os.linux.mknod(@ptrCast(path), mode, dev));
    switch (res) {
        .SUCCESS => {},
        .ACCES => return std.fs.Dir.MakeError.AccessDenied,
        .DQUOT => return std.fs.Dir.MakeError.DiskQuota,
        .EXIST => return std.fs.Dir.MakeError.PathAlreadyExists,
        .FAULT, .NOENT => return std.fs.Dir.MakeError.BadPathName,
        .LOOP => return std.fs.Dir.MakeError.SymLinkLoop,
        .NAMETOOLONG => return std.fs.Dir.MakeError.NameTooLong,
        .NOMEM => return std.fs.Dir.MakeError.SystemResources,
        .NOSPC => return std.fs.Dir.MakeError.NoSpaceLeft,
        .NOTDIR => return std.fs.Dir.MakeError.NotDir,
        .PERM => return std.fs.Dir.MakeError.PermissionDenied,
        .ROFS => return std.fs.Dir.MakeError.ReadOnlyFileSystem,
        else => return blk: {
            std.debug.print("unhandled mknod result: {}\n", .{res});
            break :blk std.fs.Dir.MakeError.Unexpected;
        },
    }
    var fil = try std.fs.cwd().openFile(path, .{});
    defer fil.close();
    const time = @as(i128, self.hdr.mod_time) * 1000000000;
    try fil.updateTimes(time, time);
    if (!options.ignore_permissions) {
        try fil.chmod(self.hdr.permissions);
        try fil.chown(try archive.id_table.get(self.hdr.uid_idx), try archive.id_table.get(self.hdr.gid_idx));
    }
    if (!options.ignore_xattr) {
        // TODO
    }
}