//
//  WQPackages.m
//  FilzaSlop
//
//  In-process dpkg/apt for the normally signed build. Packages are unpacked
//  under Documents/.terminal/root; this is a plugin/utility prefix, not the
//  system root, because the app is sandboxed.
//

#import "WQPackages.h"

#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>
#import <errno.h>
#import <fcntl.h>
#import <sys/stat.h>
#import <unistd.h>

typedef struct archive WQArchive;
typedef struct archive_entry WQArchiveEntry;

#define WQ_ARCHIVE_OK 0
#define ARCHIVE_OK 0
#define WQ_AE_IFMT  0170000
#define WQ_AE_IFREG 0100000
#define WQ_AE_IFDIR 0040000
#define WQ_AE_IFLNK 0120000

extern WQArchive *archive_read_new(void);
extern int archive_read_support_filter_all(WQArchive *);
extern int archive_read_support_format_all(WQArchive *);
extern int archive_read_support_format_raw(WQArchive *);
extern int archive_read_open_memory(WQArchive *, const void *, size_t);
extern int archive_read_next_header(WQArchive *, WQArchiveEntry **);
extern const char *archive_entry_pathname(WQArchiveEntry *);
extern const char *archive_entry_symlink(WQArchiveEntry *);
extern mode_t archive_entry_perm(WQArchiveEntry *);
extern mode_t archive_entry_filetype(WQArchiveEntry *);
extern long long archive_entry_size(WQArchiveEntry *);
extern ssize_t archive_read_data(WQArchive *, void *, size_t);
extern int archive_read_data_skip(WQArchive *);
extern int archive_read_free(WQArchive *);
extern const char *archive_error_string(WQArchive *);

static NSString *WQPackageRoot(void)
{
    NSString *configured = NSProcessInfo.processInfo.environment[@"TERM_ROOT"];
    if (configured.length) return configured;
    NSString *documents = NSSearchPathForDirectoriesInDomains(
        NSDocumentDirectory, NSUserDomainMask, YES).firstObject;
    return [documents stringByAppendingPathComponent:@".terminal"];
}

static NSString *WQInstallRoot(void)
{
    return [WQPackageRoot() stringByAppendingPathComponent:@"root"];
}

static NSString *WQStatusPath(void)
{
    return [WQPackageRoot() stringByAppendingPathComponent:@"var/lib/dpkg/status"];
}

static NSString *WQInfoDirectory(void)
{
    return [WQPackageRoot() stringByAppendingPathComponent:@"var/lib/dpkg/info"];
}

static void WQEnsurePackageDirectories(void)
{
    NSFileManager *fm = NSFileManager.defaultManager;
    NSArray *directories = @[
        WQPackageRoot(),
        WQInstallRoot(),
        WQInfoDirectory(),
        [WQPackageRoot() stringByAppendingPathComponent:@"var/lib/apt/lists"],
        [WQPackageRoot() stringByAppendingPathComponent:@"var/cache/apt/archives"],
        [WQPackageRoot() stringByAppendingPathComponent:@"etc/apt"],
        [WQPackageRoot() stringByAppendingPathComponent:@"tmp"],
    ];
    for (NSString *directory in directories)
        [fm createDirectoryAtPath:directory withIntermediateDirectories:YES
                       attributes:nil error:nil];
    NSString *status = WQStatusPath();
    if (![fm fileExistsAtPath:status])
        [@"" writeToFile:status atomically:YES encoding:NSUTF8StringEncoding error:nil];
}

#pragma mark - ar / deb

static NSData *WQArMember(NSData *archive, NSString *namePrefix)
{
    const uint8_t *bytes = archive.bytes;
    NSUInteger length = archive.length;
    if (length < 8 || memcmp(bytes, "!<arch>\n", 8) != 0) return nil;
    NSUInteger offset = 8;
    while (offset + 60 <= length) {
        const uint8_t *header = bytes + offset;
        NSString *name = [[[NSString alloc] initWithBytes:header length:16
            encoding:NSASCIIStringEncoding] stringByTrimmingCharactersInSet:
            NSCharacterSet.whitespaceCharacterSet];
        name = [name stringByTrimmingCharactersInSet:
            [NSCharacterSet characterSetWithCharactersInString:@"/"]];
        NSString *sizeText = [[[NSString alloc] initWithBytes:header + 48 length:10
            encoding:NSASCIIStringEncoding] stringByTrimmingCharactersInSet:
            NSCharacterSet.whitespaceCharacterSet];
        NSUInteger size = (NSUInteger)sizeText.longLongValue;
        offset += 60;
        if (offset + size > length) break;
        if ([name hasPrefix:namePrefix])
            return [archive subdataWithRange:NSMakeRange(offset, size)];
        offset += size + (size & 1);
    }
    return nil;
}

static NSString *WQArchivePath(NSString *raw)
{
    NSString *path = raw;
    while ([path hasPrefix:@"./"]) path = [path substringFromIndex:2];
    while ([path hasPrefix:@"/"]) path = [path substringFromIndex:1];
    if ([path hasPrefix:@"var/jb/"]) path = [path substringFromIndex:7];
    if (path.length == 0 || [path containsString:@".."]) return nil;
    return path;
}

static BOOL WQExtractArchiveData(NSData *archiveData, NSString *destination,
                                 NSMutableArray<NSString *> *installedFiles)
{
    if (!archiveData.length) return NO;
    WQArchive *archive = archive_read_new();
    if (!archive) return NO;
    archive_read_support_filter_all(archive);
    archive_read_support_format_all(archive);
    if (archive_read_open_memory(archive, archiveData.bytes,
                                 archiveData.length) != ARCHIVE_OK) {
        archive_read_free(archive);
        return NO;
    }

    NSFileManager *fm = NSFileManager.defaultManager;
    struct archive_entry *entry;
    BOOL success = YES;
    while (archive_read_next_header(archive, &entry) == WQ_ARCHIVE_OK) {
        const char *rawName = archive_entry_pathname(entry);
        if (!rawName) { archive_read_data_skip(archive); continue; }
        NSString *relative = WQArchivePath([NSString stringWithUTF8String:rawName]);
        if (!relative.length) { archive_read_data_skip(archive); continue; }
        NSString *target = [destination stringByAppendingPathComponent:relative];
        mode_t filetype = archive_entry_filetype(entry);
        mode_t permissions = archive_entry_perm(entry);
        if (filetype == WQ_AE_IFDIR) {
            [fm createDirectoryAtPath:target withIntermediateDirectories:YES
                           attributes:@{ NSFilePosixPermissions: @(permissions ?: 0755) }
                                error:nil];
            continue;
        }
        [fm createDirectoryAtPath:target.stringByDeletingLastPathComponent
            withIntermediateDirectories:YES attributes:nil error:nil];
        if (filetype == WQ_AE_IFLNK) {
            const char *link = archive_entry_symlink(entry);
            [fm removeItemAtPath:target error:nil];
            if (link && symlink(link, target.fileSystemRepresentation) == 0)
                [installedFiles addObject:relative];
        } else if (filetype == WQ_AE_IFREG) {
            int descriptor = open(target.fileSystemRepresentation,
                O_WRONLY | O_CREAT | O_TRUNC, permissions ?: 0644);
            if (descriptor < 0) { success = NO; archive_read_data_skip(archive); continue; }
            uint8_t buffer[65536];
            ssize_t got;
            while ((got = archive_read_data(archive, buffer, sizeof(buffer))) > 0) {
                ssize_t written = 0;
                while (written < got) {
                    ssize_t step = write(descriptor, buffer + written,
                                         (size_t)(got - written));
                    if (step <= 0) break;
                    written += step;
                }
            }
            close(descriptor);
            chmod(target.fileSystemRepresentation, permissions ?: 0644);
            [installedFiles addObject:relative];
        } else {
            archive_read_data_skip(archive);
        }
    }
    archive_read_free(archive);
    return success;
}

static NSData *WQArchiveEntryNamed(NSData *archiveData, NSString *wanted)
{
    WQArchive *archive = archive_read_new();
    if (!archive) return nil;
    archive_read_support_filter_all(archive);
    archive_read_support_format_all(archive);
    if (archive_read_open_memory(archive, archiveData.bytes,
                                 archiveData.length) != ARCHIVE_OK) {
        archive_read_free(archive);
        return nil;
    }
    struct archive_entry *entry;
    NSData *result = nil;
    while (archive_read_next_header(archive, &entry) == WQ_ARCHIVE_OK) {
        const char *name = archive_entry_pathname(entry);
        if (name && (strcmp(name, wanted.UTF8String) == 0 ||
                     strcmp(name + (strlen(name) > 2 && name[0] == '.' &&
                                    name[1] == '/' ? 2 : 0), wanted.UTF8String) == 0)) {
            NSMutableData *data = [NSMutableData data];
            uint8_t buffer[65536];
            ssize_t got;
            while ((got = archive_read_data(archive, buffer, sizeof(buffer))) > 0)
                [data appendBytes:buffer length:(NSUInteger)got];
            result = data;
            break;
        }
        archive_read_data_skip(archive);
    }
    archive_read_free(archive);
    return result;
}

static NSDictionary *WQParseControl(NSString *control)
{
    NSMutableDictionary *fields = [NSMutableDictionary dictionary];
    NSString *currentKey = nil;
    NSMutableString *currentValue = nil;
    for (NSString *line in [control componentsSeparatedByString:@"\n"]) {
        if (line.length == 0) continue;
        if ([line hasPrefix:@" "] || [line hasPrefix:@"\t"]) {
            if (currentKey && currentValue)
                [currentValue appendFormat:@"\n%@", [line stringByTrimmingCharactersInSet:
                    NSCharacterSet.whitespaceCharacterSet]];
            continue;
        }
        NSRange colon = [line rangeOfString:@":"];
        if (colon.location == NSNotFound) continue;
        if (currentKey && currentValue) fields[currentKey] = currentValue.copy;
        currentKey = [[line substringToIndex:colon.location]
            stringByTrimmingCharactersInSet:NSCharacterSet.whitespaceCharacterSet];
        currentValue = [[[line substringFromIndex:colon.location + 1]
            stringByTrimmingCharactersInSet:NSCharacterSet.whitespaceCharacterSet] mutableCopy];
    }
    if (currentKey && currentValue) fields[currentKey] = currentValue.copy;
    return fields;
}

NSString *WQDebInfoText(NSString *path)
{
    NSData *archive = [NSData dataWithContentsOfFile:path];
    if (!archive.length) return nil;
    NSData *controlArchive = WQArMember(archive, @"control.tar");
    if (!controlArchive.length) return nil;
    NSData *controlData = WQArchiveEntryNamed(controlArchive, @"control");
    if (!controlData.length) return nil;
    NSString *control = [[NSString alloc] initWithData:controlData
        encoding:NSUTF8StringEncoding];
    if (!control.length) return nil;
    NSMutableString *text = [NSMutableString stringWithFormat:
        @" new Debian package, version 2.0.\n"
        @" size %lu bytes: control archive %lu bytes.\n",
        (unsigned long)archive.length, (unsigned long)controlArchive.length];
    [text appendString:control];
    if (![text hasSuffix:@"\n"]) [text appendString:@"\n"];
    return text;
}

static NSString *WQStanzaForKey(NSString *text, NSString *key, NSString *value)
{
    NSArray *stanzas = [text componentsSeparatedByString:@"\n\n"];
    for (NSString *stanza in stanzas) {
        BOOL match = NO;
        for (NSString *line in [stanza componentsSeparatedByString:@"\n"]) {
            if ([line hasPrefix:[key stringByAppendingString:@": "]]) {
                match = [[line substringFromIndex:key.length + 2]
                    isEqualToString:value];
                break;
            }
        }
        if (match) return stanza;
    }
    return nil;
}

static NSString *WQFieldFromStanza(NSString *stanza, NSString *key)
{
    for (NSString *line in [stanza componentsSeparatedByString:@"\n"])
        if ([line hasPrefix:[key stringByAppendingString:@": "]])
            return [line substringFromIndex:key.length + 2];
    return nil;
}

static void WQRemoveStatusStanza(NSString *package)
{
    NSString *text = [NSString stringWithContentsOfFile:WQStatusPath()
        encoding:NSUTF8StringEncoding error:nil] ?: @"";
    NSMutableArray *keep = [NSMutableArray array];
    for (NSString *stanza in [text componentsSeparatedByString:@"\n\n"]) {
        if (stanza.length == 0) continue;
        NSString *name = WQFieldFromStanza(stanza, @"Package");
        if (![name isEqualToString:package]) [keep addObject:stanza];
    }
    [[keep componentsJoinedByString:@"\n\n"] writeToFile:WQStatusPath()
        atomically:YES encoding:NSUTF8StringEncoding error:nil];
}

static BOOL WQInstallDeb(NSString *path, FILE *out, FILE *err,
                         NSDictionary *options)
{
    WQEnsurePackageDirectories();
    NSData *archive = [NSData dataWithContentsOfFile:path];
    if (!archive.length) {
        fprintf(err, "dpkg: cannot open %s\n", path.UTF8String);
        return NO;
    }
    NSData *controlArchive = WQArMember(archive, @"control.tar");
    NSData *dataArchive = WQArMember(archive, @"data.tar");
    if (!controlArchive || !dataArchive) {
        fprintf(err, "dpkg: %s is not a Debian archive\n", path.UTF8String);
        return NO;
    }
    NSData *controlData = WQArchiveEntryNamed(controlArchive, @"control");
    if (!controlData) {
        fprintf(err, "dpkg: missing control file in %s\n", path.UTF8String);
        return NO;
    }
    NSString *control = [[NSString alloc] initWithData:controlData
        encoding:NSUTF8StringEncoding];
    NSDictionary *fields = WQParseControl(control ?: @"");
    NSString *package = fields[@"Package"] ?: @"unknown";
    NSString *version = fields[@"Version"] ?: @"0";
    NSString *architecture = fields[@"Architecture"] ?: @"iphoneos-arm64";
    BOOL force = options[@"force"] != nil;
    if (!force &&
        ![architecture isEqualToString:@"iphoneos-arm64"] &&
        ![architecture isEqualToString:@"iphoneos-arm"] &&
        ![architecture isEqualToString:@"darwin-arm64"] &&
        ![architecture isEqualToString:@"all"]) {
        fprintf(err, "dpkg: package architecture %s is not native "
                "(use --force-architecture)\n", architecture.UTF8String);
        return NO;
    }

    fprintf(out, "Selecting previously unselected package %s.\n",
            package.UTF8String);
    NSMutableArray<NSString *> *installedFiles = [NSMutableArray array];
    if (!WQExtractArchiveData(dataArchive, WQInstallRoot(), installedFiles)) {
        fprintf(err, "dpkg: failed to unpack %s\n", path.UTF8String);
        return NO;
    }

    WQRemoveStatusStanza(package);
    NSMutableString *status = [NSMutableString stringWithContentsOfFile:WQStatusPath()
        encoding:NSUTF8StringEncoding error:nil] ?: [NSMutableString string];
    if (status.length && ![status hasSuffix:@"\n\n"]) [status appendString:@"\n\n"];
    [status appendFormat:
        @"Package: %@\n"
        @"Status: install ok installed\n"
        @"Priority: %@\n"
        @"Section: %@\n"
        @"Installed-Size: %@\n"
        @"Maintainer: %@\n"
        @"Architecture: %@\n"
        @"Version: %@\n"
        @"Description: %@\n\n",
        package,
        fields[@"Priority"] ?: @"optional",
        fields[@"Section"] ?: @"utility",
        fields[@"Installed-Size"] ?: @"0",
        fields[@"Maintainer"] ?: @"unknown",
        architecture,
        version,
        fields[@"Description"] ?: package];
    [status writeToFile:WQStatusPath() atomically:YES
               encoding:NSUTF8StringEncoding error:nil];
    NSString *listPath = [WQInfoDirectory()
        stringByAppendingPathComponent:[package stringByAppendingString:@".list"]];
    [[installedFiles componentsJoinedByString:@"\n"] writeToFile:listPath
        atomically:YES encoding:NSUTF8StringEncoding error:nil];
    fprintf(out, "Unpacking %s (%s) ...\n", package.UTF8String, version.UTF8String);
    fprintf(out, "Setting up %s (%s) ...\n", package.UTF8String, version.UTF8String);
    fprintf(out, "Installed to %s\n", WQInstallRoot().UTF8String);
    return YES;
}

#pragma mark - dpkg

static void WQDPKGUsage(FILE *out)
{
    fprintf(out,
        "Usage: dpkg <action>\n"
        "  -i, --install <file.deb>   Install a package\n"
        "  -r, --remove <package>     Remove a package\n"
        "  -P, --purge <package>      Remove a package\n"
        "  -l, --list                 List installed packages\n"
        "  -s, --status <package>     Show package status\n"
        "  -L, --listfiles <package>  List package files\n"
        "  -x, --extract <deb> <dir>  Extract data archive\n"
        "  --contents <deb>           List .deb contents\n"
        "  --print-architecture       Print iphoneos-arm64\n"
        "  --force-architecture       Allow non-native packages\n"
        "  --version                  Show version\n");
}

int WQDPKGMain(int argc, char **argv, FILE *out, FILE *err)
{
    WQEnsurePackageDirectories();
    if (argc < 2) { WQDPKGUsage(out); return 1; }
    NSString *action = [NSString stringWithUTF8String:argv[1]];
    BOOL force = NO;
    int index = 2;
    for (int i = 2; i < argc; i++) {
        NSString *arg = [NSString stringWithUTF8String:argv[i]];
        if ([arg isEqualToString:@"--force-architecture"]) force = YES;
    }
    NSDictionary *options = force ? @{ @"force": @YES } : @{};

    if ([action isEqualToString:@"--version"]) {
        fprintf(out, "dpkg 1.22 (FilzaSlop in-process)\n");
        return 0;
    }
    if ([action isEqualToString:@"--print-architecture"]) {
        fprintf(out, "iphoneos-arm64\n");
        return 0;
    }
    if ([action isEqualToString:@"-l"] || [action isEqualToString:@"--list"]) {
        NSString *text = [NSString stringWithContentsOfFile:WQStatusPath()
            encoding:NSUTF8StringEncoding error:nil] ?: @"";
        fprintf(out, "Desired=Unknown/Install/Remove/Purge/Hold\n"
                     "||/ Name                 Version        Architecture Description\n");
        for (NSString *stanza in [text componentsSeparatedByString:@"\n\n"]) {
            if (stanza.length == 0) continue;
            NSString *name = WQFieldFromStanza(stanza, @"Package");
            NSString *version = WQFieldFromStanza(stanza, @"Version") ?: @"";
            NSString *arch = WQFieldFromStanza(stanza, @"Architecture") ?: @"";
            NSString *description = WQFieldFromStanza(stanza, @"Description") ?: @"";
            fprintf(out, "ii  %-20s %-14s %-14s %s\n",
                (name ?: @"").UTF8String, version.UTF8String,
                arch.UTF8String, description.UTF8String);
        }
        return 0;
    }
    if ([action isEqualToString:@"-s"] || [action isEqualToString:@"--status"]) {
        if (index >= argc) { fprintf(err, "dpkg: missing package\n"); return 1; }
        NSString *package = [NSString stringWithUTF8String:argv[index]];
        NSString *text = [NSString stringWithContentsOfFile:WQStatusPath()
            encoding:NSUTF8StringEncoding error:nil] ?: @"";
        NSString *stanza = WQStanzaForKey(text, @"Package", package);
        if (!stanza) { fprintf(err, "dpkg: package %s is not installed\n",
                                package.UTF8String); return 1; }
        fprintf(out, "%s\n", stanza.UTF8String);
        return 0;
    }
    if ([action isEqualToString:@"-L"] || [action isEqualToString:@"--listfiles"]) {
        if (index >= argc) { fprintf(err, "dpkg: missing package\n"); return 1; }
        NSString *package = [NSString stringWithUTF8String:argv[index]];
        NSString *list = [NSString stringWithContentsOfFile:
            [WQInfoDirectory() stringByAppendingPathComponent:
                [package stringByAppendingString:@".list"]]
            encoding:NSUTF8StringEncoding error:nil];
        if (!list) { fprintf(err, "dpkg: package %s has no file list\n",
                              package.UTF8String); return 1; }
        fprintf(out, "%s\n", list.UTF8String);
        return 0;
    }
    if ([action isEqualToString:@"-r"] || [action isEqualToString:@"--remove"] ||
        [action isEqualToString:@"-P"] || [action isEqualToString:@"--purge"]) {
        if (index >= argc) { fprintf(err, "dpkg: missing package\n"); return 1; }
        NSString *package = [NSString stringWithUTF8String:argv[index]];
        NSString *listPath = [WQInfoDirectory()
            stringByAppendingPathComponent:[package stringByAppendingString:@".list"]];
        NSString *list = [NSString stringWithContentsOfFile:listPath
            encoding:NSUTF8StringEncoding error:nil];
        NSFileManager *fm = NSFileManager.defaultManager;
        for (NSString *relative in [list componentsSeparatedByString:@"\n"]) {
            if (!relative.length) continue;
            NSString *target = [WQInstallRoot() stringByAppendingPathComponent:relative];
            [fm removeItemAtPath:target error:nil];
        }
        [fm removeItemAtPath:listPath error:nil];
        WQRemoveStatusStanza(package);
        fprintf(out, "Removing %s ...\n", package.UTF8String);
        return 0;
    }
    if ([action isEqualToString:@"-x"] || [action isEqualToString:@"--extract"] ||
        [action isEqualToString:@"--contents"]) {
        if (index >= argc) { fprintf(err, "dpkg: missing .deb\n"); return 1; }
        NSString *path = [NSString stringWithUTF8String:argv[index]];
        NSData *archive = [NSData dataWithContentsOfFile:path];
        NSData *data = WQArMember(archive, @"data.tar");
        if (!data) { fprintf(err, "dpkg: no data archive\n"); return 1; }
        if ([action isEqualToString:@"--contents"]) {
            NSMutableArray<NSString *> *files = [NSMutableArray array];
            WQExtractArchiveData(data, NSTemporaryDirectory(), files);
            for (NSString *file in files) fprintf(out, "%s\n", file.UTF8String);
            return 0;
        }
        NSString *destination = index + 1 < argc
            ? [NSString stringWithUTF8String:argv[index + 1]]
            : WQInstallRoot();
        NSMutableArray *files = [NSMutableArray array];
        return WQExtractArchiveData(data, destination, files) ? 0 : 1;
    }
    if ([action isEqualToString:@"-i"] || [action isEqualToString:@"--install"]) {
        if (index >= argc) { fprintf(err, "dpkg: missing .deb\n"); return 1; }
        BOOL all = YES;
        for (; index < argc; index++) {
            NSString *path = [NSString stringWithUTF8String:argv[index]];
            if ([path isEqualToString:@"--force-architecture"]) continue;
            if (!WQInstallDeb(path, out, err, options)) all = NO;
        }
        return all ? 0 : 1;
    }
    WQDPKGUsage(out);
    return 1;
}

#pragma mark - apt

static NSString *WQAptIndexPath(void)
{
    return [WQPackageRoot() stringByAppendingPathComponent:
        @"var/lib/apt/lists/Packages"];
}

static NSString *WQAptSourcesPath(void)
{
    return [WQPackageRoot() stringByAppendingPathComponent:@"etc/apt/sources.list"];
}

static NSArray<NSString *> *WQAptStanzas(void)
{
    NSString *text = [NSString stringWithContentsOfFile:WQAptIndexPath()
        encoding:NSUTF8StringEncoding error:nil] ?: @"";
    NSMutableArray *stanzas = [NSMutableArray array];
    for (NSString *stanza in [text componentsSeparatedByString:@"\n\n"])
        if (stanza.length) [stanzas addObject:stanza];
    return stanzas;
}

static NSData *WQDownloadURL(NSString *urlString)
{
    NSURL *url = [NSURL URLWithString:urlString];
    if (!url) return nil;
    if ([url isFileURL]) return [NSData dataWithContentsOfURL:url];
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    __block NSData *result = nil;
    NSURLSessionDataTask *task = [NSURLSession.sharedSession dataTaskWithURL:url
        completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
            if (!error && [(NSHTTPURLResponse *)response statusCode] / 100 == 2)
                result = data;
            dispatch_semaphore_signal(semaphore);
        }];
    [task resume];
    dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, 30 * NSEC_PER_SEC));
    return result;
}

static void WQEnsureSources(void)
{
    NSString *path = WQAptSourcesPath();
    if ([[NSFileManager defaultManager] fileExistsAtPath:path]) return;
    NSString *root = WQPackageRoot();
    NSString *line = [NSString stringWithFormat:@"deb [trusted=yes] file://%@/repo ./\n", root];
    [line writeToFile:path atomically:YES encoding:NSUTF8StringEncoding error:nil];
}

static void WQAptUsage(FILE *out)
{
    fprintf(out,
        "Usage: apt <command>\n"
        "  update                  Refresh package indexes\n"
        "  list                    List packages in the index\n"
        "  search <text>           Search package names/descriptions\n"
        "  show <package>          Show package details\n"
        "  install <package|deb>   Install a package\n"
        "  remove|purge <package>  Remove a package\n"
        "  clean                   Clear downloaded archives\n"
        "  --version               Show version\n"
        "Root: %s\n", WQPackageRoot().UTF8String);
}

int WQAptMain(int argc, char **argv, FILE *out, FILE *err)
{
    WQEnsurePackageDirectories();
    WQEnsureSources();
    if (argc < 2) { WQAptUsage(out); return 1; }
    NSString *action = [NSString stringWithUTF8String:argv[1]];
    if ([action isEqualToString:@"--version"]) {
        fprintf(out, "apt 2.7 (FilzaSlop in-process)\n");
        return 0;
    }
    if ([action isEqualToString:@"update"]) {
        fprintf(out, "apt: updating package lists...\n");
        NSString *sources = [NSString stringWithContentsOfFile:WQAptSourcesPath()
            encoding:NSUTF8StringEncoding error:nil] ?: @"";
        NSMutableString *index = [NSMutableString string];
        for (NSString *line in [sources componentsSeparatedByString:@"\n"]) {
            if (![line hasPrefix:@"deb "]) continue;
            NSArray *parts = [line componentsSeparatedByString:@" "];
            NSString *uri = nil;
            for (NSString *part in parts) {
                if ([part hasPrefix:@"http://"] || [part hasPrefix:@"https://"] ||
                    [part hasPrefix:@"file://"]) { uri = part; break; }
            }
            if (!uri.length) continue;
            NSArray *names = @[@"Packages", @"Packages.gz"];
            BOOL loaded = NO;
            for (NSString *name in names) {
                NSString *url = [uri stringByAppendingPathComponent:name];
                NSData *data = WQDownloadURL(url);
                if (!data.length) continue;
                if ([name hasSuffix:@".gz"]) {
                    // Decompress gzip through libarchive's raw reader.
                    WQArchive *archive = archive_read_new();
                    archive_read_support_filter_all(archive);
                    archive_read_support_format_raw(archive);
                    if (archive_read_open_memory(archive, data.bytes, data.length) != ARCHIVE_OK) {
                        archive_read_free(archive);
                        continue;
                    }
                    struct archive_entry *entry;
                    NSMutableData *plain = [NSMutableData data];
                    if (archive_read_next_header(archive, &entry) == WQ_ARCHIVE_OK) {
                        uint8_t buffer[65536];
                        ssize_t got;
                        while ((got = archive_read_data(archive, buffer, sizeof(buffer))) > 0)
                            [plain appendBytes:buffer length:(NSUInteger)got];
                    }
                    archive_read_free(archive);
                    data = plain;
                }
                NSString *text = [[NSString alloc] initWithData:data
                    encoding:NSUTF8StringEncoding];
                if (text.length) {
                    [index appendString:text];
                    if (![index hasSuffix:@"\n"]) [index appendString:@"\n"];
                    loaded = YES;
                    break;
                }
            }
            fprintf(out, "%s: %s\n", loaded ? "Get" : "Err", uri.UTF8String);
        }
        [index writeToFile:WQAptIndexPath() atomically:YES
                  encoding:NSUTF8StringEncoding error:nil];
        fprintf(out, "Reading package lists... Done\n");
        return 0;
    }
    if ([action isEqualToString:@"list"]) {
        for (NSString *stanza in WQAptStanzas()) {
            NSString *name = WQFieldFromStanza(stanza, @"Package") ?: @"";
            NSString *version = WQFieldFromStanza(stanza, @"Version") ?: @"";
            NSString *description = WQFieldFromStanza(stanza, @"Description") ?: @"";
            fprintf(out, "%s/%s %s %s\n", name.UTF8String,
                (WQFieldFromStanza(stanza, @"Architecture") ?: @"iphoneos-arm64").UTF8String,
                version.UTF8String, description.UTF8String);
        }
        return 0;
    }
    if ([action isEqualToString:@"search"]) {
        NSString *text = argc > 2 ? [NSString stringWithUTF8String:argv[2]] : @"";
        for (NSString *stanza in WQAptStanzas())
            if (text.length == 0 || [stanza.lowercaseString containsString:text.lowercaseString]) {
                NSString *name = WQFieldFromStanza(stanza, @"Package") ?: @"";
                NSString *description = WQFieldFromStanza(stanza, @"Description") ?: @"";
                fprintf(out, "%s - %s\n", name.UTF8String, description.UTF8String);
            }
        return 0;
    }
    if ([action isEqualToString:@"show"]) {
        if (argc < 3) { fprintf(err, "apt: missing package\n"); return 1; }
        NSString *package = [NSString stringWithUTF8String:argv[2]];
        for (NSString *stanza in WQAptStanzas())
            if ([WQFieldFromStanza(stanza, @"Package") isEqualToString:package]) {
                fprintf(out, "%s\n", stanza.UTF8String);
                return 0;
            }
        fprintf(err, "apt: package %s not found\n", package.UTF8String);
        return 1;
    }
    if ([action isEqualToString:@"install"]) {
        if (argc < 3) { fprintf(err, "apt: missing package\n"); return 1; }
        NSString *target = [NSString stringWithUTF8String:argv[2]];
        if ([[NSFileManager defaultManager] fileExistsAtPath:target] ||
            [target hasSuffix:@".deb"])
            return WQDPKGMain(3, (char *[]){(char *)"dpkg", (char *)"-i",
                (char *)target.UTF8String}, out, err) ? 0 : 1;
        for (NSString *stanza in WQAptStanzas()) {
            if (![WQFieldFromStanza(stanza, @"Package") isEqualToString:target]) continue;
            NSString *filename = WQFieldFromStanza(stanza, @"Filename");
            NSString *source = @"";
            NSString *sources = [NSString stringWithContentsOfFile:WQAptSourcesPath()
                encoding:NSUTF8StringEncoding error:nil] ?: @"";
            for (NSString *line in [sources componentsSeparatedByString:@"\n"])
                for (NSString *part in [line componentsSeparatedByString:@" "])
                    if ([part hasPrefix:@"http"] || [part hasPrefix:@"file://"]) {
                        source = part; break;
                    }
            NSString *url = [source stringByAppendingPathComponent:filename ?: @""];
            NSData *deb = WQDownloadURL(url);
            NSString *cache = [[WQPackageRoot()
                stringByAppendingPathComponent:@"var/cache/apt/archives"]
                stringByAppendingPathComponent:filename.lastPathComponent ?: @"package.deb"];
            if (!deb.length || ![deb writeToFile:cache atomically:YES]) {
                fprintf(err, "apt: unable to download %s\n", url.UTF8String);
                return 1;
            }
            return WQDPKGMain(3, (char *[]){(char *)"dpkg", (char *)"-i",
                (char *)cache.UTF8String}, out, err) ? 0 : 1;
        }
        fprintf(err, "apt: package %s not found; run 'apt update'\n", target.UTF8String);
        return 1;
    }
    if ([action isEqualToString:@"remove"] || [action isEqualToString:@"purge"]) {
        if (argc < 3) { fprintf(err, "apt: missing package\n"); return 1; }
        return WQDPKGMain(argc, (char *[]){(char *)"dpkg", (char *)"-r",
            argv[2], NULL}, out, err) ? 0 : 1;
    }
    if ([action isEqualToString:@"clean"]) {
        NSString *archives = [WQPackageRoot()
            stringByAppendingPathComponent:@"var/cache/apt/archives"];
        for (NSString *name in [NSFileManager.defaultManager
                contentsOfDirectoryAtPath:archives error:nil])
            [NSFileManager.defaultManager removeItemAtPath:
                [archives stringByAppendingPathComponent:name] error:nil];
        fprintf(out, "apt: cache cleaned\n");
        return 0;
    }
    WQAptUsage(out);
    return 1;
}

BOOL WQInstallDebPackage(NSString *path, NSString **message)
{
    FILE *out = tmpfile();
    FILE *err = tmpfile();
    BOOL result = WQInstallDeb(path, out, err, @{});
    NSMutableString *text = [NSMutableString string];
    if (out) {
        fflush(out); rewind(out);
        char buffer[4096]; size_t got;
        while ((got = fread(buffer, 1, sizeof(buffer), out)) > 0)
            [text appendString:[[NSString alloc] initWithBytes:buffer
                length:got encoding:NSUTF8StringEncoding] ?: @""];
        fclose(out);
    }
    if (err) {
        fflush(err); rewind(err);
        char buffer[4096]; size_t got;
        while ((got = fread(buffer, 1, sizeof(buffer), err)) > 0)
            [text appendString:[[NSString alloc] initWithBytes:buffer
                length:got encoding:NSUTF8StringEncoding] ?: @""];
        fclose(err);
    }
    if (message) *message = text;
    return result;
}