#include "native_report.h"
#include "nintendo_disc_header.h"
#include "xbox_region.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifdef WIN32
#include <direct.h>
#define PATH_SEP "\\"
#define TEST_GETCWD _getcwd
#define TEST_CHDIR _chdir
#else
#include <unistd.h>
#define PATH_SEP "/"
#define TEST_GETCWD getcwd
#define TEST_CHDIR chdir
#endif

static int nintendo_disc_header_tests(void) {
    unsigned char gamecube_header[0x20] = {0};
    unsigned char wii_header[0x20] = {0};
    unsigned char unknown_header[0x20] = {0};

    memcpy(gamecube_header, "GALE01", 6);
    gamecube_header[0x1c] = 0xc2;
    gamecube_header[0x1d] = 0x33;
    gamecube_header[0x1e] = 0x9f;
    gamecube_header[0x1f] = 0x3d;

    memcpy(wii_header, "RSBE01", 6);
    wii_header[0x18] = 0x5d;
    wii_header[0x19] = 0x1c;
    wii_header[0x1a] = 0x9e;
    wii_header[0x1b] = 0xa3;

    if (nintendo_disc_header_detect(
            gamecube_header,
            sizeof(gamecube_header)) != NINTENDO_DISC_HEADER_GAMECUBE) {
        fprintf(stderr, "GALE01 GameCube header classification failed\n");
        return 0;
    }

    if (nintendo_disc_header_detect(
            wii_header,
            sizeof(wii_header)) != NINTENDO_DISC_HEADER_WII) {
        fprintf(stderr, "RSBE01 Wii header classification failed\n");
        return 0;
    }

    if (nintendo_disc_header_detect(
            unknown_header,
            sizeof(unknown_header)) != NINTENDO_DISC_HEADER_UNKNOWN) {
        fprintf(stderr, "Unknown Nintendo header classification failed\n");
        return 0;
    }

    if (nintendo_disc_header_detect(
            gamecube_header,
            0x1f) != NINTENDO_DISC_HEADER_UNKNOWN) {
        fprintf(stderr, "Truncated Nintendo header classification failed\n");
        return 0;
    }

    printf("Nintendo disc-header classification: PASS\n");
    return 1;
}

static int xbox_region_tests(void) {
    char region[128];

    if (!xbox_region_format(XB_REGION_US_CANADA, region, sizeof(region)) ||
        strcmp(region, "North America") != 0) {
        fprintf(stderr, "Xbox North America region formatting failed: %s\n", region);
        return 0;
    }

    if (!xbox_region_format(XB_REGION_JAPAN, region, sizeof(region)) ||
        strcmp(region, "Japan") != 0) {
        fprintf(stderr, "Xbox Japan region formatting failed: %s\n", region);
        return 0;
    }

    if (!xbox_region_format(XB_REGION_EUROPE_AU_NZ, region, sizeof(region)) ||
        strcmp(region, "Europe/Australia/New Zealand") != 0) {
        fprintf(stderr, "Xbox Europe/Australia/New Zealand formatting failed: %s\n", region);
        return 0;
    }

    if (!xbox_region_format(
            XB_REGION_US_CANADA | XB_REGION_JAPAN,
            region, sizeof(region)) ||
        strcmp(region, "North America; Japan") != 0) {
        fprintf(stderr, "Xbox multi-region formatting failed: %s\n", region);
        return 0;
    }

    if (!xbox_region_format(0U, region, sizeof(region)) ||
        strcmp(region, "None (Locked)") != 0) {
        fprintf(stderr, "Xbox locked-region formatting failed: %s\n", region);
        return 0;
    }

    if (!xbox_region_format(0x7fffffffU, region, sizeof(region)) ||
        strcmp(region, "Region Free") != 0) {
        fprintf(stderr, "Xbox region-free formatting failed: %s\n", region);
        return 0;
    }

    printf("Xbox XBE GameRegion formatting: PASS\n");
    return 1;
}

static int write_report(friidump_native_report *report,
                        const char *directory,
                        const char *filename) {
    char path[FRIIDUMP_REPORT_PATH_MAX];
    char written[FRIIDUMP_REPORT_PATH_MAX];
    char error_text[256];

    snprintf(path, sizeof(path), "%s%s%s", directory, PATH_SEP, filename);
    if (!friidump_native_report_enable_path(report, path)) {
        fprintf(stderr, "Could not configure fixture path: %s\n", path);
        return 0;
    }
    if (!friidump_native_report_write(report, written, sizeof(written),
                                      error_text, sizeof(error_text))) {
        fprintf(stderr, "Could not write fixture %s: %s\n", path, error_text);
        return 0;
    }
    printf("fixture: %s\n", written);
    return 1;
}

static void base_drive(friidump_native_report *r,
                       const char *model,
                       const char *firmware) {
    friidump_native_report_set_drive(
        r, "HL-DT-ST", model, firmware, "ATAPI", "fixture-device");
    friidump_native_report_set_profile(
        r, "known_supported_profile_hardening", 0x5e0, 0x90024ff7);
}

static int success_gamecube(const char *dir) {
    friidump_native_report r;
    friidump_native_report_init(&r, "0.5.3.16-native-report-test");
    base_drive(&r, "DVD-ROM GDR8163B", "0M26");
    friidump_native_report_set_media(
        &r, "gamecube", "Sonic Mega Collection", "USA", "GUPP8P");
    friidump_native_report_set_seed(&r, true, "pass", true, 6.0);
    friidump_native_report_set_dump(
        &r, true, "pass", true, 712880, true, 1459978240ULL,
        true, 7241.31, NULL, false, 0, "Sonic Mega Collection.iso");
    friidump_native_report_set_hashes(
        &r,
        "01b52739",
        "85a525df1481d0ad67d8761f832dca12",
        "06eb6d15b4d7f90ec0fed9cea9a77db41358d74ed",
        "2c0da8b5cb1f615d68562ae0f731f28bc82ac59136c70eb57aecbb4fe4b63882");
    friidump_native_report_add_artifact(
        &r, "dump_output", "Sonic Mega Collection.iso", true,
        1459978240ULL,
        "2c0da8b5cb1f615d68562ae0f731f28bc82ac59136c70eb57aecbb4fe4b63882");
    friidump_native_report_set_reference(
        &r, "redump", "match", "Sonic Mega Collection (USA).iso");
    friidump_native_report_set_outcome(&r, "full_dump", "pass");
    friidump_native_report_add_note(&r, "Measurement scope: full_optical_payload.");
    return write_report(&r, dir, "success-gamecube.friidump.json");
}

static int success_xbox(const char *dir) {
    friidump_native_report r;
    friidump_native_report_init(&r, "0.5.3.16-native-report-test");
    base_drive(&r, "DVD-ROM GDR8050L", "0012");
    friidump_native_report_set_firmware_modified(
        &r, true, "Modified firmware with HIT 0xE7 memdump support.");
    friidump_native_report_set_media(
        &r, "xbox", "Red Faction II", "North America", "TQ00501A");
    friidump_native_report_set_seed(&r, false, "not_applicable", false, 0.0);
    friidump_native_report_set_dump(
        &r, true, "pass", true, 3820880, true, 7825162240ULL,
        true, 14000.0, NULL, false, 0, "Red Faction II [TQ00501A].iso");
    friidump_native_report_set_hashes(
        &r,
        "12345678",
        "0123456789abcdef0123456789abcdef",
        "0123456789abcdef0123456789abcdef01234567",
        "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
    friidump_native_report_add_artifact(
        &r, "dump_output", "Red Faction II [TQ00501A].iso", true,
        7825162240ULL,
        "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
    friidump_native_report_set_reference(&r, "redump", "mismatch", NULL);
    friidump_native_report_set_outcome(&r, "full_dump", "pass");
    friidump_native_report_add_note(&r, "Measurement scope: assembled_output.");
    friidump_native_report_add_note(
        &r,
        "Xbox output throughput describes the produced assembled output and is not directly comparable to a full optical-payload read.");
    return write_report(&r, dir, "success-xbox-assembled.friidump.json");
}

static int partial_gamecube(const char *dir) {
    friidump_native_report r;
    friidump_native_report_init(&r, "0.5.3.16-native-report-test");
    base_drive(&r, "DVD-ROM GDR8163B", "0M26");
    friidump_native_report_set_media(
        &r, "gamecube", "Sonic Mega Collection", "USA", "GUPP8P");
    friidump_native_report_set_seed(&r, true, "pass", true, 6.0);
    friidump_native_report_set_dump(
        &r, true, "partial", true, 100000, true, 204800000ULL,
        true, 1000.0, "raw_sector_read_or_output_write", true, 100000,
        "Sonic Mega Collection.partial.iso");
    friidump_native_report_set_hashes(&r, NULL, NULL, NULL, NULL);
    friidump_native_report_add_artifact(
        &r, "dump_output", "Sonic Mega Collection.partial.iso", true,
        204800000ULL, NULL);
    friidump_native_report_set_reference(&r, NULL, "not_checked", NULL);
    friidump_native_report_set_outcome(&r, "partial_dump", "partial");
    friidump_native_report_add_note(&r, "Measurement scope: partial_progress.");
    return write_report(&r, dir, "partial-gamecube.friidump.json");
}

static int partial_cancelled(const char *dir) {
    friidump_native_report r;
    friidump_native_report_init(&r, "0.5.3.16-native-report-test");
    base_drive(&r, "DVD-ROM GDR8163B", "0M26");
    friidump_native_report_set_media(
        &r, "gamecube", "Sonic Mega Collection", "USA", "GUPP8P");
    friidump_native_report_set_seed(&r, true, "pass", true, 6.0);
    friidump_native_report_set_dump(
        &r, true, "partial", true, 25000, true, 51200000ULL,
        true, 250.0, "user_cancelled", true, 25000,
        "Sonic Mega Collection.cancelled.iso");
    friidump_native_report_set_hashes(&r, NULL, NULL, NULL, NULL);
    friidump_native_report_add_artifact(
        &r, "dump_output", "Sonic Mega Collection.cancelled.iso", true,
        51200000ULL, NULL);
    friidump_native_report_set_reference(&r, NULL, "not_checked", NULL);
    friidump_native_report_set_outcome(&r, "partial_dump", "partial");
    friidump_native_report_add_note(&r, "Measurement scope: partial_progress.");
    friidump_native_report_add_note(
        &r,
        "The invocation was cancelled by the user; only completed output bytes are represented.");
    return write_report(&r, dir, "partial-cancelled.friidump.json");
}

static int partial_xbox_cancelled(const char *dir) {
    friidump_native_report r;
    friidump_native_report_init(&r, "0.5.3.16-native-report-test");
    base_drive(&r, "DVD-ROM GDR8050L", "0012");
    friidump_native_report_set_firmware_modified(
        &r, true,
        "GDR-8163B cross-flashed with modified GDR-8050L firmware; patched to allow 0xE7 memory dumps");
    friidump_native_report_set_media(
        &r, "xbox", "Red Faction II", "North America", "TQ00501A");
    friidump_native_report_set_seed(
        &r, false, "not_applicable", false, 0.0);
    friidump_native_report_set_dump(
        &r, true, "partial", true, 22273, true, 45615104ULL,
        true, 14.0, "user_cancelled", true, 22273,
        "Red Faction II [TQ00501A].partial.xiso");
    friidump_native_report_set_hashes(
        &r,
        "89abcdef",
        "0123456789abcdef0123456789abcdef",
        "0123456789abcdef0123456789abcdef01234567",
        "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
    friidump_native_report_add_artifact(
        &r, "dump_output",
        "Red Faction II [TQ00501A].partial.xiso", true,
        45615104ULL,
        "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
    friidump_native_report_set_reference(
        &r, NULL, "not_checked", NULL);
    friidump_native_report_set_outcome(
        &r, "partial_dump", "partial");
    friidump_native_report_add_note(
        &r, "Measurement scope: partial_progress.");
    friidump_native_report_add_note(
        &r,
        "The invocation was cancelled by the user; only completed output bytes are represented.");
    friidump_native_report_add_note(
        &r, "Xbox XBE GameRegion mask: 0x00000001.");
    return write_report(
        &r, dir, "partial-xbox-cancelled.friidump.json");
}

static int seed_failure(const char *dir) {
    friidump_native_report r;
    friidump_native_report_init(&r, "0.5.3.16-native-report-test");
    base_drive(&r, "DVD-ROM GDR8163B", "0M26");
    friidump_native_report_set_media(&r, "gamecube", NULL, NULL, NULL);
    friidump_native_report_set_seed(&r, true, "fail", true, 15.0);
    friidump_native_report_set_dump(
        &r, false, "not_attempted", false, 0, false, 0,
        false, 0.0, NULL, false, 0, NULL);
    friidump_native_report_set_reference(&r, NULL, "not_checked", NULL);
    friidump_native_report_set_outcome(&r, "seed_only", "fail");
    friidump_native_report_add_note(&r, "Disc initialization or seed retrieval failed.");
    return write_report(&r, dir, "seed-failure.friidump.json");
}

static int no_media(const char *dir) {
    friidump_native_report r;
    friidump_native_report_init(&r, "0.5.3.16-native-report-test");
    base_drive(&r, "DVD-ROM GDR8163B", "0M26");
    friidump_native_report_set_media(&r, "unknown", NULL, NULL, NULL);
    friidump_native_report_set_seed(&r, false, "not_attempted", false, 0.0);
    friidump_native_report_set_dump(
        &r, false, "not_attempted", false, 0, false, 0,
        false, 0.0, NULL, false, 0, NULL);
    friidump_native_report_set_reference(&r, NULL, "not_applicable", NULL);
    friidump_native_report_set_outcome(
        &r, "diagnostic_no_media", "not_applicable");
    friidump_native_report_add_note(
        &r, "Media preflight found no readable disc (sense 02/3A/00).");
    return write_report(&r, dir, "no-media.friidump.json");
}

static int modified_firmware(const char *dir) {
    friidump_native_report r;
    friidump_native_report_init(&r, "0.5.3.16-native-report-test");
    base_drive(&r, "DVD-ROM GDR8050L", "0L23");
    friidump_native_report_set_firmware_modified(
        &r, true, "Cross-flashed firmware with added HIT 0xE7 memdump support.");
    friidump_native_report_set_media(
        &r, "gamecube", "Sonic Mega Collection", "USA", "GUPP8P");
    friidump_native_report_set_seed(&r, true, "pass", true, 6.0);
    friidump_native_report_set_dump(
        &r, true, "pass", true, 712880, true, 1459978240ULL,
        true, 9000.0, NULL, false, 0, "modified-drive-test.iso");
    friidump_native_report_set_hashes(
        &r,
        "01b52739",
        "85a525df1481d0ad67d8761f832dca12",
        "06eb6d15b4d7f90ec0fed9cea9a77db41358d74ed",
        NULL);
    friidump_native_report_add_artifact(
        &r, "dump_output", "modified-drive-test.iso", true,
        1459978240ULL, NULL);
    friidump_native_report_set_reference(&r, "redump", "match", "fixture");
    friidump_native_report_set_outcome(&r, "full_dump", "pass");
    friidump_native_report_add_note(&r, "Measurement scope: full_optical_payload.");
    friidump_native_report_add_note(
        &r, "UTF-8 preservation fixture: Pok\xc3\xa9mon.");
    return write_report(&r, dir, "modified-firmware.friidump.json");
}

static int identity_tests(const char *dir) {
    friidump_native_report a;
    friidump_native_report b;
    char path[FRIIDUMP_REPORT_PATH_MAX];
    char written[FRIIDUMP_REPORT_PATH_MAX];
    char error_text[256];

    friidump_native_report_init(&a, "0.5.3.16-native-report-test");
    friidump_native_report_init(&b, "0.5.3.16-native-report-test");
    if (strcmp(a.run_id, b.run_id) == 0) {
        fprintf(stderr, "Retry identity test failed: UUIDs are equal\n");
        return 0;
    }

    base_drive(&a, "DVD-ROM GDR8163B", "0M26");
    friidump_native_report_set_media(&a, "unknown", NULL, NULL, NULL);
    friidump_native_report_set_outcome(&a, "diagnostic_no_media", "not_applicable");
    friidump_native_report_set_reference(&a, NULL, "not_applicable", NULL);
    snprintf(path, sizeof(path), "%s%sidentity-no-overwrite.friidump.json", dir, PATH_SEP);
    if (!friidump_native_report_enable_path(&a, path))
        return 0;
    if (!friidump_native_report_write(&a, written, sizeof(written), error_text, sizeof(error_text)))
        return 0;
    if (friidump_native_report_write(&a, written, sizeof(written), error_text, sizeof(error_text))) {
        fprintf(stderr, "No-overwrite test failed: second publish succeeded\n");
        return 0;
    }
    if (strstr(error_text, "overwrite") == NULL) {
        fprintf(stderr, "No-overwrite test failed with unexpected error: %s\n", error_text);
        return 0;
    }
    printf("identity: unique retry UUIDs and no-overwrite policy PASS\n");
    return 1;
}

static int report_directory_test(const char *dir) {
    friidump_native_report r;
    char nested[FRIIDUMP_REPORT_PATH_MAX];
    char written[FRIIDUMP_REPORT_PATH_MAX];
    char error_text[256];
    FILE *f;

    snprintf(nested, sizeof(nested), "%s%snested%sreports", dir, PATH_SEP, PATH_SEP);
    friidump_native_report_init(&r, "0.5.3.16-native-report-test");
    base_drive(&r, "DVD-ROM GDR8163B", "0M26");
    friidump_native_report_set_media(
        &r, "gamecube", "Directory Fixture", "USA", "DIR001");
    friidump_native_report_set_seed(&r, false, "not_applicable", false, 0.0);
    friidump_native_report_set_dump(
        &r, false, "not_attempted", false, 0, false, 0,
        false, 0.0, NULL, false, 0, NULL);
    friidump_native_report_set_reference(&r, NULL, "not_applicable", NULL);
    friidump_native_report_set_outcome(&r, "other", "not_applicable");

    if (!friidump_native_report_enable_default(&r) ||
        !friidump_native_report_set_name_basis(
            &r, "logs/directory-fixture.log") ||
        !friidump_native_report_enable_dir(&r, nested)) {
        fprintf(stderr, "Could not configure nested report directory\n");
        return 0;
    }
    if (!friidump_native_report_write(
            &r, written, sizeof(written), error_text, sizeof(error_text))) {
        fprintf(stderr, "Nested report-directory write failed: %s\n", error_text);
        return 0;
    }
    if (strstr(written, "directory-fixture.friidump.json") == NULL ||
        strstr(written, r.run_id) != NULL) {
        fprintf(stderr, "Generated report path did not retain the log-derived name: %s\n", written);
        return 0;
    }
    f = fopen(written, "rb");
    if (!f) {
        fprintf(stderr, "Generated report path is not readable: %s\n", written);
        return 0;
    }
    fclose(f);
    printf("report directory: nested creation and log-derived filename PASS\n");
    return 1;
}

static int expect_write_failure(friidump_native_report *r,
                                const char *dir,
                                const char *filename,
                                const char *expected_error) {
    char path[FRIIDUMP_REPORT_PATH_MAX];
    char written[FRIIDUMP_REPORT_PATH_MAX];
    char error_text[256];
    FILE *f;

    snprintf(path, sizeof(path), "%s%s%s", dir, PATH_SEP, filename);
    remove(path);
    if (!friidump_native_report_enable_path(r, path))
        return 0;
    if (friidump_native_report_write(
            r, written, sizeof(written), error_text, sizeof(error_text))) {
        fprintf(stderr, "Invalid report unexpectedly wrote %s\n", path);
        remove(path);
        return 0;
    }
    if (!strstr(error_text, expected_error)) {
        fprintf(stderr, "Invalid report error mismatch: expected '%s', got '%s'\n",
                expected_error, error_text);
        return 0;
    }
    f = fopen(path, "rb");
    if (f) {
        fclose(f);
        fprintf(stderr, "Invalid report left a published file: %s\n", path);
        remove(path);
        return 0;
    }
    return 1;
}

static void valid_no_media_report(friidump_native_report *r) {
    friidump_native_report_init(r, "0.5.3.16-native-report-test");
    base_drive(r, "DVD-ROM GDR8163B", "0M26");
    friidump_native_report_set_media(r, "unknown", NULL, NULL, NULL);
    friidump_native_report_set_seed(r, false, "not_attempted", false, 0.0);
    friidump_native_report_set_dump(
        r, false, "not_attempted", false, 0, false, 0,
        false, 0.0, NULL, false, 0, NULL);
    friidump_native_report_set_reference(r, NULL, "not_applicable", NULL);
    friidump_native_report_set_outcome(
        r, "diagnostic_no_media", "not_applicable");
}

static int path_override_tests(const char *dir) {
    friidump_native_report first;
    friidump_native_report second;
    friidump_native_report working;
    friidump_native_report combined;
    char nested[FRIIDUMP_REPORT_PATH_MAX];
    char explicit_path[FRIIDUMP_REPORT_PATH_MAX];
    char expected_path[FRIIDUMP_REPORT_PATH_MAX];
    char written[FRIIDUMP_REPORT_PATH_MAX];
    char error_text[256];
    FILE *f;

    snprintf(nested, sizeof(nested), "%s%spath-overrides", dir, PATH_SEP);

    valid_no_media_report(&first);
    if (!friidump_native_report_enable_default(&first) ||
        !friidump_native_report_set_name_basis(
            &first, "logs/default-session.log") ||
        !friidump_native_report_enable_dir(&first, nested)) {
        fprintf(stderr, "Could not configure derived path fixture\n");
        return 0;
    }
    if (!friidump_native_report_write(
            &first, written, sizeof(written), error_text, sizeof(error_text))) {
        fprintf(stderr, "Could not write derived path fixture: %s\n", error_text);
        return 0;
    }
    snprintf(expected_path, sizeof(expected_path),
             "%s%sdefault-session.friidump.json", nested, PATH_SEP);
    if (strcmp(written, expected_path) != 0) {
        fprintf(stderr, "Derived path mismatch: expected %s, got %s\n",
                expected_path, written);
        return 0;
    }

    valid_no_media_report(&second);
    if (!friidump_native_report_enable_default(&second) ||
        !friidump_native_report_set_name_basis(
            &second, "logs/default-session.log") ||
        !friidump_native_report_enable_dir(&second, nested)) {
        fprintf(stderr, "Could not configure collision fixture\n");
        return 0;
    }
    if (!friidump_native_report_write(
            &second, written, sizeof(written), error_text, sizeof(error_text))) {
        fprintf(stderr, "Could not write collision fixture: %s\n", error_text);
        return 0;
    }
    if (strstr(written, second.run_id) == NULL ||
        strstr(written, "default-session-") == NULL) {
        fprintf(stderr, "Collision-safe path did not use the run UUID: %s\n", written);
        return 0;
    }

    valid_no_media_report(&working);
    snprintf(explicit_path, sizeof(explicit_path),
             "%s%sworking-directory.log", nested, PATH_SEP);
    if (!friidump_native_report_enable_default(&working) ||
        !friidump_native_report_set_name_basis(&working, explicit_path)) {
        fprintf(stderr, "Could not configure default beside-log fixture\n");
        return 0;
    }
    if (!friidump_native_report_write(
            &working, written, sizeof(written), error_text, sizeof(error_text))) {
        fprintf(stderr, "Could not write default beside-log fixture: %s\n",
                error_text);
        return 0;
    }
    snprintf(expected_path, sizeof(expected_path),
             "%s%sworking-directory.friidump.json", nested, PATH_SEP);
    if (strcmp(written, expected_path) != 0) {
        fprintf(stderr, "Beside-log path mismatch: expected %s, got %s\n",
                expected_path, written);
        return 0;
    }
    f = fopen(written, "rb");
    if (!f) {
        fprintf(stderr, "Default beside-log report is not readable: %s\n", written);
        return 0;
    }
    fclose(f);

    valid_no_media_report(&combined);
    snprintf(explicit_path, sizeof(explicit_path),
             "ignored%sparent%scustom-evidence.json", PATH_SEP, PATH_SEP);
    if (!friidump_native_report_enable_default(&combined) ||
        !friidump_native_report_enable_path(&combined, explicit_path) ||
        !friidump_native_report_enable_dir(&combined, nested)) {
        fprintf(stderr, "Could not configure combined pathname/directory fixture\n");
        return 0;
    }
    if (!friidump_native_report_write(
            &combined, written, sizeof(written), error_text, sizeof(error_text))) {
        fprintf(stderr, "Could not write combined override fixture: %s\n", error_text);
        return 0;
    }
    snprintf(expected_path, sizeof(expected_path),
             "%s%scustom-evidence.json", nested, PATH_SEP);
    if (strcmp(written, expected_path) != 0) {
        fprintf(stderr, "Combined override mismatch: expected %s, got %s\n",
                expected_path, written);
        return 0;
    }
    f = fopen(written, "rb");
    if (!f) {
        fprintf(stderr, "Combined override report is not readable: %s\n", written);
        return 0;
    }
    fclose(f);

    printf("path overrides: default beside-log, derived name, collision handling, and combined overrides PASS\n");
    return 1;
}

static int invalid_report_tests(const char *dir) {
    friidump_native_report r;

    valid_no_media_report(&r);
    friidump_native_report_set_firmware_modified(&r, true, NULL);
    if (!expect_write_failure(
            &r, dir, "invalid-modified-without-note.friidump.json",
            "Modified firmware requires"))
        return 0;

    valid_no_media_report(&r);
    snprintf(r.run_id, sizeof(r.run_id),
             "00000000-0000-0000-0000-000000000000");
    if (!expect_write_failure(
            &r, dir, "invalid-zero-uuid.friidump.json",
            "Run UUID"))
        return 0;

    valid_no_media_report(&r);
    friidump_native_report_set_dump(
        &r, true, "pass", false, 0, false, 0,
        true, 1.0, NULL, false, 0, "invalid.iso");
    friidump_native_report_set_outcome(&r, "full_dump", "pass");
    if (!expect_write_failure(
            &r, dir, "invalid-success-without-counts.friidump.json",
            "requires sector and byte counts"))
        return 0;

    valid_no_media_report(&r);
    friidump_native_report_set_seed(&r, false, "pass", false, 0.0);
    if (!expect_write_failure(
            &r, dir, "invalid-nonattempted-seed-pass.friidump.json",
            "non-attempted seed stage"))
        return 0;

    valid_no_media_report(&r);
    friidump_native_report_set_media(
        &r, "gamecube", "Artifact Fixture", "USA", "ART001");
    friidump_native_report_set_seed(&r, true, "pass", true, 1.0);
    friidump_native_report_set_dump(
        &r, true, "pass", true, 1, true, 2048,
        true, 1.0, NULL, false, 0, "missing-artifact.iso");
    friidump_native_report_set_hashes(
        &r, NULL, NULL, NULL,
        "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
    friidump_native_report_set_outcome(&r, "full_dump", "pass");
    friidump_native_report_add_note(&r, "Measurement scope: full_optical_payload.");
    if (!expect_write_failure(
            &r, dir, "invalid-missing-output-artifact.friidump.json",
            "exactly one dump_output artifact"))
        return 0;

    valid_no_media_report(&r);
    friidump_native_report_set_media(
        &r, "gamecube", "Artifact Fixture", "USA", "ART002");
    friidump_native_report_set_seed(&r, true, "pass", true, 1.0);
    friidump_native_report_set_dump(
        &r, true, "pass", true, 1, true, 2048,
        true, 1.0, NULL, false, 0, "artifact-mismatch.iso");
    friidump_native_report_set_hashes(
        &r, NULL, NULL, NULL,
        "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
    friidump_native_report_add_artifact(
        &r, "dump_output", "artifact-mismatch.iso", true, 4096,
        "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
    friidump_native_report_set_outcome(&r, "full_dump", "pass");
    friidump_native_report_add_note(&r, "Measurement scope: full_optical_payload.");
    if (!expect_write_failure(
            &r, dir, "invalid-output-artifact-mismatch.friidump.json",
            "does not match"))
        return 0;

    printf("invalid reports: semantic rejection and no publication PASS\n");
    return 1;
}

int main(int argc, char **argv) {
    int ok;
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <fixture-directory>\n", argv[0]);
        return 2;
    }

    ok = nintendo_disc_header_tests() &&
         xbox_region_tests() &&
         success_gamecube(argv[1]) &&
         success_xbox(argv[1]) &&
         partial_gamecube(argv[1]) &&
         partial_cancelled(argv[1]) &&
         partial_xbox_cancelled(argv[1]) &&
         seed_failure(argv[1]) &&
         no_media(argv[1]) &&
         modified_firmware(argv[1]) &&
         identity_tests(argv[1]) &&
         report_directory_test(argv[1]) &&
         path_override_tests(argv[1]) &&
         invalid_report_tests(argv[1]);

    return ok ? 0 : 1;
}