/// A requirement that must be tested
pub struct Requirement {
    pub id: String,           // e.g., "REQ-1.3"
    pub title: String,
    pub description: String,
    pub kubo_source: String,  // e.g., "kubo/config/config.go:45-120"
    pub verification_steps: Vec<String>,
}

/// Result of testing a requirement
pub struct RequirementResult {
    pub requirement: Requirement,
    pub test_name: String,
    pub status: TestStatus,
    pub evidence: String,
    pub duration: Duration,
}

/// Generate human-readable compliance report
pub fn generate_compliance_report(phase: u8, results: Vec<RequirementResult>) -> String;

#[test]
fn req_1_2_license_mit_matches_kubo() {
    let req = Requirement {
        id: "REQ-1.2".into(),
        title: "LICENSE-MIT matches Kubo".into(),
        description: "The LICENSE-MIT file must be byte-for-byte identical to Kubo's LICENSE-MIT".into(),
        kubo_source: "LICENSE-MIT".into(),
        verification_steps: vec![
            "Read ferripfs/LICENSE-MIT".into(),
            "Read kubo/LICENSE-MIT".into(),
            "Compare byte-for-byte".into(),
            "Files must be identical".into(),
        ],
    };

    let ferripfs_license = fs::read_to_string("LICENSE-MIT").unwrap();
    let kubo_license = fs::read_to_string("../kubo/LICENSE-MIT").unwrap();

    let status = if ferripfs_license == kubo_license {
        TestStatus::Pass
    } else {
        TestStatus::Fail
    };

    let evidence = format!(
        "ferripfs LICENSE-MIT length: {} bytes\n\
         kubo LICENSE-MIT length: {} bytes\n\
         Match: {}",
        ferripfs_license.len(),
        kubo_license.len(),
        ferripfs_license == kubo_license
    );

    record_result(RequirementResult {
        requirement: req,
        test_name: "req_1_2_license_mit_matches_kubo".into(),
        status,
        evidence,
        duration: elapsed,
    });
}

#[test]
fn req_1_7_parity_lists_all_commands() {
    let req = Requirement {
        id: "REQ-1.7".into(),
        title: "PARITY.md lists all Kubo commands".into(),
        description: "PARITY.md must list all 131 Kubo CLI commands with tracking status".into(),
        kubo_source: "core/commands/root.go".into(),
        verification_steps: vec![
            "Parse Kubo core/commands/root.go for command list".into(),
            "Parse PARITY.md for listed commands".into(),
            "Every Kubo command must appear in PARITY.md".into(),
            "Each entry must have status indicator (not started/in progress/complete)".into(),
        ],
    };

    let kubo_commands = extract_kubo_commands("../kubo/core/commands/");
    let parity_commands = parse_parity_md("PARITY.md");

    let missing: Vec<_> = kubo_commands.iter()
        .filter(|c| !parity_commands.contains(c))
        .collect();

    let status = if missing.is_empty() { TestStatus::Pass } else { TestStatus::Fail };

    let evidence = format!(
        "Kubo commands found: {}\n\
         PARITY.md entries: {}\n\
         Missing commands: {:?}",
        kubo_commands.len(),
        parity_commands.len(),
        missing
    );

    // ... record result
}

#[test]
fn req_1_9_version_command() {
    let req = Requirement {
        id: "REQ-1.9".into(),
        title: "Version command outputs version string".into(),
        description: "ferripfs --version must output version in format 'ferripfs version X.Y.Z (kubo v0.39.0 port)'".into(),
        kubo_source: "cmd/ipfs/kubo/version.go".into(),
        verification_steps: vec![
            "Run: ferripfs --version".into(),
            "Output must contain 'ferripfs version'".into(),
            "Output must contain 'kubo v0.39.0 port'".into(),
            "Exit code must be 0".into(),
        ],
    };

    let output = Command::new("./target/debug/ferripfs")
        .arg("--version")
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&output.stdout);
    let has_version = stdout.contains("ferripfs version");
    let has_kubo_ref = stdout.contains("kubo v0.39.0 port");
    let exit_ok = output.status.success();

    let status = if has_version && has_kubo_ref && exit_ok {
        TestStatus::Pass
    } else {
        TestStatus::Fail
    };

    let evidence = format!(
        "Command: ferripfs --version\n\
         Exit code: {}\n\
         stdout:\n{}\n\
         Contains 'ferripfs version': {}\n\
         Contains 'kubo v0.39.0 port': {}",
        output.status.code().unwrap_or(-1),
        stdout,
        has_version,
        has_kubo_ref
    );

    // ... record result
}

#[test]
fn req_2_1_deserialize_kubo_config() {
    let req = Requirement {
        id: "REQ-2.1".into(),
        title: "Config struct deserializes Kubo config.json".into(),
        description: "ferripfs Config must successfully parse a config.json generated by Kubo".into(),
        kubo_source: "config/config.go".into(),
        verification_steps: vec![
            "Generate config.json using: kubo init --repo=/tmp/kubo-test".into(),
            "Read /tmp/kubo-test/config".into(),
            "Deserialize using ferripfs_config::Config::from_reader()".into(),
            "All fields must parse without error".into(),
            "Identity.PeerID must be valid PeerId".into(),
            "Addresses.Swarm must contain at least one multiaddr".into(),
        ],
    };

    // Generate Kubo config
    let kubo_repo = tempdir().unwrap();
    Command::new("ipfs")
        .args(["init", "--repo", kubo_repo.path().to_str().unwrap()])
        .output()
        .expect("Kubo must be installed for interop tests");

    let config_path = kubo_repo.path().join("config");
    let config_json = fs::read_to_string(&config_path).unwrap();

    let result = Config::from_str(&config_json);

    let status = match &result {
        Ok(config) => {
            let peer_id_valid = config.identity.peer_id.parse::<PeerId>().is_ok();
            let has_swarm_addr = !config.addresses.swarm.is_empty();
            if peer_id_valid && has_swarm_addr {
                TestStatus::Pass
            } else {
                TestStatus::Fail
            }
        }
        Err(_) => TestStatus::Fail,
    };

    let evidence = match &result {
        Ok(config) => format!(
            "Kubo config parsed successfully\n\
             Config file size: {} bytes\n\
             PeerID: {}\n\
             Swarm addresses: {:?}\n\
             API address: {:?}\n\
             Gateway address: {:?}\n\
             Bootstrap peers: {} entries",
            config_json.len(),
            config.identity.peer_id,
            config.addresses.swarm,
            config.addresses.api,
            config.addresses.gateway,
            config.bootstrap.len()
        ),
        Err(e) => format!("Parse error: {}", e),
    };

    // ... record result
}

#[test]
fn req_2_17_init_creates_valid_repo() {
    let req = Requirement {
        id: "REQ-2.17".into(),
        title: "ferripfs init creates valid repository".into(),
        description: "Running 'ferripfs init' must create a complete, valid IPFS repository".into(),
        kubo_source: "cmd/ipfs/kubo/init.go".into(),
        verification_steps: vec![
            "Create empty temp directory".into(),
            "Run: IPFS_PATH=/tmp/test ferripfs init".into(),
            "Verify exit code is 0".into(),
            "Verify /tmp/test/config exists and is valid JSON".into(),
            "Verify /tmp/test/datastore directory exists".into(),
            "Verify /tmp/test/blocks directory exists".into(),
            "Verify /tmp/test/version contains '18'".into(),
            "Verify config contains valid Identity.PeerID".into(),
            "Verify generated PeerID matches Identity.PrivKey".into(),
        ],
    };

    let repo_path = tempdir().unwrap();
    let repo_str = repo_path.path().to_str().unwrap();

    let output = Command::new("./target/debug/ferripfs")
        .env("IPFS_PATH", repo_str)
        .arg("init")
        .output()
        .unwrap();

    let config_exists = repo_path.path().join("config").exists();
    let datastore_exists = repo_path.path().join("datastore").is_dir();
    let blocks_exists = repo_path.path().join("blocks").is_dir();
    let version_content = fs::read_to_string(repo_path.path().join("version"))
        .unwrap_or_default();

    let config_valid = if config_exists {
        let config_str = fs::read_to_string(repo_path.path().join("config")).unwrap();
        Config::from_str(&config_str).is_ok()
    } else {
        false
    };

    let all_pass = output.status.success()
        && config_exists
        && config_valid
        && datastore_exists
        && blocks_exists
        && version_content.trim() == "18";

    let status = if all_pass { TestStatus::Pass } else { TestStatus::Fail };

    let evidence = format!(
        "Command: IPFS_PATH={} ferripfs init\n\
         Exit code: {}\n\
         stdout: {}\n\
         stderr: {}\n\
         \n\
         Repository structure:\n\
         - config exists: {} (valid JSON: {})\n\
         - datastore/ exists: {}\n\
         - blocks/ exists: {}\n\
         - version content: '{}'",
        repo_str,
        output.status.code().unwrap_or(-1),
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr),
        config_exists,
        config_valid,
        datastore_exists,
        blocks_exists,
        version_content.trim()
    );

    // ... record result
}

#[test]
fn req_2_24_kubo_repo_migration() {
    let req = Requirement {
        id: "REQ-2.24".into(),
        title: "Config migration from existing Kubo repo".into(),
        description: "ferripfs must be able to use an existing Kubo-initialized repository".into(),
        kubo_source: "N/A".into(),
        verification_steps: vec![
            "Initialize repo with Kubo: ipfs init".into(),
            "Point ferripfs at same repo: IPFS_PATH=<kubo-repo>".into(),
            "Run: ferripfs config show".into(),
            "Config must parse and display correctly".into(),
            "Run: ferripfs id".into(),
            "PeerID must match Kubo's PeerID".into(),
        ],
    };

    // Initialize with Kubo
    let repo_path = tempdir().unwrap();
    let repo_str = repo_path.path().to_str().unwrap();

    Command::new("ipfs")
        .env("IPFS_PATH", repo_str)
        .arg("init")
        .output()
        .expect("Kubo required");

    // Get Kubo's peer ID
    let kubo_id = Command::new("ipfs")
        .env("IPFS_PATH", repo_str)
        .args(["config", "Identity.PeerID"])
        .output()
        .unwrap();
    let kubo_peer_id = String::from_utf8_lossy(&kubo_id.stdout).trim().to_string();

    // Use ferripfs with same repo
    let ferripfs_config = Command::new("./target/debug/ferripfs")
        .env("IPFS_PATH", repo_str)
        .args(["config", "show"])
        .output()
        .unwrap();

    let ferripfs_id = Command::new("./target/debug/ferripfs")
        .env("IPFS_PATH", repo_str)
        .arg("id")
        .output()
        .unwrap();

    let config_parsed = serde_json::from_slice::<serde_json::Value>(&ferripfs_config.stdout).is_ok();
    let id_output = String::from_utf8_lossy(&ferripfs_id.stdout);
    let id_matches = id_output.contains(&kubo_peer_id);

    let status = if config_parsed && id_matches && ferripfs_config.status.success() {
        TestStatus::Pass
    } else {
        TestStatus::Fail
    };

    let evidence = format!(
        "Kubo repository: {}\n\
         Kubo PeerID: {}\n\
         \n\
         ferripfs config show:\n\
         Exit code: {}\n\
         Valid JSON: {}\n\
         \n\
         ferripfs id:\n\
         Exit code: {}\n\
         Contains Kubo PeerID: {}\n\
         Output: {}",
        repo_str,
        kubo_peer_id,
        ferripfs_config.status.code().unwrap_or(-1),
        config_parsed,
        ferripfs_id.status.code().unwrap_or(-1),
        id_matches,
        id_output
    );

    // ... record result
}

#[test]
fn req_3_8_block_hash_matches_kubo() {
    let req = Requirement {
        id: "REQ-3.8".into(),
        title: "Block hashing matches Kubo".into(),
        description: "Given identical content, ferripfs must produce the same CID as Kubo".into(),
        kubo_source: "N/A (interoperability requirement)".into(),
        verification_steps: vec![
            "Create test file with known content".into(),
            "Add to Kubo: echo 'hello world' | ipfs block put".into(),
            "Add to ferripfs: echo 'hello world' | ferripfs block put".into(),
            "CIDs must be identical".into(),
            "Repeat with various content sizes: 0 bytes, 1 byte, 256KB, 1MB".into(),
        ],
    };

    let test_cases = vec![
        ("empty", b"".to_vec()),
        ("hello", b"hello world".to_vec()),
        ("newline", b"hello world\n".to_vec()),
        ("256kb", vec![0x42u8; 256 * 1024]),
        ("1mb", vec![0xFFu8; 1024 * 1024]),
    ];

    let mut results = Vec::new();

    for (name, content) in &test_cases {
        // Get CID from Kubo
        let kubo = Command::new("ipfs")
            .args(["block", "put", "--format=raw"])
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .spawn()
            .unwrap();
        kubo.stdin.unwrap().write_all(content).unwrap();
        let kubo_cid = String::from_utf8_lossy(&kubo.wait_with_output().unwrap().stdout)
            .trim().to_string();

        // Get CID from ferripfs
        let ferripfs = Command::new("./target/debug/ferripfs")
            .args(["block", "put", "--format=raw"])
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .spawn()
            .unwrap();
        ferripfs.stdin.unwrap().write_all(content).unwrap();
        let ferripfs_cid = String::from_utf8_lossy(&ferripfs.wait_with_output().unwrap().stdout)
            .trim().to_string();

        results.push((name, content.len(), kubo_cid.clone(), ferripfs_cid.clone(), kubo_cid == ferripfs_cid));
    }

    let all_match = results.iter().all(|(_, _, _, _, matches)| *matches);
    let status = if all_match { TestStatus::Pass } else { TestStatus::Fail };

    let evidence = results.iter()
        .map(|(name, size, kubo, ferripfs, matches)| {
            format!(
                "Test '{}' ({} bytes):\n  Kubo CID:     {}\n  ferripfs CID: {}\n  Match: {}",
                name, size, kubo, ferripfs, matches
            )
        })
        .collect::<Vec<_>>()
        .join("\n\n");

    // ... record result
}

#[test]
fn req_4_17_add_cid_matches_kubo() {
    let req = Requirement {
        id: "REQ-4.17".into(),
        title: "ferripfs add produces same CID as Kubo".into(),
        description: "Adding identical files must produce identical CIDs".into(),
        kubo_source: "core/commands/add.go".into(),
        verification_steps: vec![
            "Create test files of various sizes and types".into(),
            "Add each file to Kubo: ipfs add <file>".into(),
            "Add each file to ferripfs: ferripfs add <file>".into(),
            "Compare CIDs - must be identical".into(),
            "Test with: empty file, small text, binary, large file, directory".into(),
        ],
    };

    let test_cases = vec![
        ("empty.txt", vec![]),
        ("hello.txt", b"hello world\n".to_vec()),
        ("binary.bin", (0u8..=255).collect()),
        ("large.bin", vec![0x42u8; 1024 * 1024]),  // 1MB
    ];

    let kubo_repo = tempdir().unwrap();
    let ferripfs_repo = tempdir().unwrap();

    // Initialize repos
    init_kubo_repo(&kubo_repo);
    init_ferripfs_repo(&ferripfs_repo);

    let mut results = Vec::new();

    for (name, content) in &test_cases {
        let file_path = kubo_repo.path().join(name);
        fs::write(&file_path, content).unwrap();

        let kubo_output = Command::new("ipfs")
            .env("IPFS_PATH", kubo_repo.path())
            .args(["add", "-q", file_path.to_str().unwrap()])
            .output()
            .unwrap();
        let kubo_cid = String::from_utf8_lossy(&kubo_output.stdout).trim().to_string();

        let ferripfs_output = Command::new("./target/debug/ferripfs")
            .env("IPFS_PATH", ferripfs_repo.path())
            .args(["add", "-q", file_path.to_str().unwrap()])
            .output()
            .unwrap();
        let ferripfs_cid = String::from_utf8_lossy(&ferripfs_output.stdout).trim().to_string();

        results.push((name.to_string(), content.len(), kubo_cid.clone(), ferripfs_cid.clone(), kubo_cid == ferripfs_cid));
    }

    // Directory test
    let dir_path = kubo_repo.path().join("testdir");
    fs::create_dir(&dir_path).unwrap();
    fs::write(dir_path.join("a.txt"), b"file a").unwrap();
    fs::write(dir_path.join("b.txt"), b"file b").unwrap();

    let kubo_dir = Command::new("ipfs")
        .env("IPFS_PATH", kubo_repo.path())
        .args(["add", "-rq", dir_path.to_str().unwrap()])
        .output()
        .unwrap();
    let kubo_dir_cid = String::from_utf8_lossy(&kubo_dir.stdout)
        .lines().last().unwrap_or("").to_string();

    let ferripfs_dir = Command::new("./target/debug/ferripfs")
        .env("IPFS_PATH", ferripfs_repo.path())
        .args(["add", "-rq", dir_path.to_str().unwrap()])
        .output()
        .unwrap();
    let ferripfs_dir_cid = String::from_utf8_lossy(&ferripfs_dir.stdout)
        .lines().last().unwrap_or("").to_string();

    results.push(("directory".into(), 0, kubo_dir_cid.clone(), ferripfs_dir_cid.clone(), kubo_dir_cid == ferripfs_dir_cid));

    let all_match = results.iter().all(|(_, _, _, _, m)| *m);
    let status = if all_match { TestStatus::Pass } else { TestStatus::Fail };

    let evidence = format!(
        "CID Comparison Results:\n\n{}\n\nAll CIDs match: {}",
        results.iter()
            .map(|(name, size, kubo, ferripfs, matches)| {
                format!(
                    "{}:\n  Size: {} bytes\n  Kubo:     {}\n  ferripfs: {}\n  Match: {}",
                    name, size, kubo, ferripfs, if *matches { "YES" } else { "NO" }
                )
            })
            .collect::<Vec<_>>()
            .join("\n\n"),
        all_match
    );

    // ... record result
}

#[test]
fn req_4_26_27_cross_node_content_exchange() {
    let req = Requirement {
        id: "REQ-4.26/27".into(),
        title: "Cross-node content interoperability".into(),
        description: "Content added by one implementation must be readable by the other".into(),
        kubo_source: "N/A (interoperability requirement)".into(),
        verification_steps: vec![
            "Add file with Kubo, read with ferripfs (shared repo)".into(),
            "Add file with ferripfs, read with Kubo (shared repo)".into(),
            "Compare retrieved content with original".into(),
            "Test with various file sizes".into(),
        ],
    };

    let shared_repo = tempdir().unwrap();
    init_kubo_repo(&shared_repo);

    // Test 1: Kubo adds, ferripfs reads
    let content1 = b"Content added by Kubo\n";
    let file1 = shared_repo.path().join("kubo_file.txt");
    fs::write(&file1, content1).unwrap();

    let kubo_add = Command::new("ipfs")
        .env("IPFS_PATH", shared_repo.path())
        .args(["add", "-q", file1.to_str().unwrap()])
        .output()
        .unwrap();
    let cid1 = String::from_utf8_lossy(&kubo_add.stdout).trim().to_string();

    let ferripfs_cat = Command::new("./target/debug/ferripfs")
        .env("IPFS_PATH", shared_repo.path())
        .args(["cat", &cid1])
        .output()
        .unwrap();
    let retrieved1 = ferripfs_cat.stdout.clone();

    // Test 2: ferripfs adds, Kubo reads
    let content2 = b"Content added by ferripfs\n";
    let file2 = shared_repo.path().join("ferripfs_file.txt");
    fs::write(&file2, content2).unwrap();

    let ferripfs_add = Command::new("./target/debug/ferripfs")
        .env("IPFS_PATH", shared_repo.path())
        .args(["add", "-q", file2.to_str().unwrap()])
        .output()
        .unwrap();
    let cid2 = String::from_utf8_lossy(&ferripfs_add.stdout).trim().to_string();

    let kubo_cat = Command::new("ipfs")
        .env("IPFS_PATH", shared_repo.path())
        .args(["cat", &cid2])
        .output()
        .unwrap();
    let retrieved2 = kubo_cat.stdout.clone();

    let test1_pass = retrieved1 == content1;
    let test2_pass = retrieved2 == content2;

    let status = if test1_pass && test2_pass { TestStatus::Pass } else { TestStatus::Fail };

    let evidence = format!(
        "Test 1: Kubo adds, ferripfs reads\n\
         Original content: {:?}\n\
         CID: {}\n\
         Retrieved by ferripfs: {:?}\n\
         Match: {}\n\
         \n\
         Test 2: ferripfs adds, Kubo reads\n\
         Original content: {:?}\n\
         CID: {}\n\
         Retrieved by Kubo: {:?}\n\
         Match: {}",
        String::from_utf8_lossy(content1),
        cid1,
        String::from_utf8_lossy(&retrieved1),
        test1_pass,
        String::from_utf8_lossy(content2),
        cid2,
        String::from_utf8_lossy(&retrieved2),
        test2_pass
    );

    // ... record result
}

#[test]
fn req_9_9_10_cross_impl_content_exchange() {
    let req = Requirement {
        id: "REQ-9.9/10".into(),
        title: "Content exchange between ferripfs and Kubo over network".into(),
        description: "Nodes must be able to fetch content from each other over the network".into(),
        kubo_source: "N/A (interoperability requirement)".into(),
        verification_steps: vec![
            "Start Kubo daemon on port 4001".into(),
            "Start ferripfs daemon on port 4002".into(),
            "Add unique content to Kubo".into(),
            "Add unique content to ferripfs".into(),
            "Connect nodes via swarm connect".into(),
            "Fetch Kubo content from ferripfs using CID".into(),
            "Fetch ferripfs content from Kubo using CID".into(),
            "Verify fetched content matches original".into(),
        ],
    };

    // Start Kubo daemon
    let kubo_repo = tempdir().unwrap();
    init_kubo_repo(&kubo_repo);
    let kubo_daemon = Command::new("ipfs")
        .env("IPFS_PATH", kubo_repo.path())
        .args(["daemon", "--offline=false"])
        .spawn()
        .unwrap();
    wait_for_daemon(&kubo_repo, 4001);

    // Start ferripfs daemon
    let ferripfs_repo = tempdir().unwrap();
    init_ferripfs_repo(&ferripfs_repo);
    let ferripfs_daemon = Command::new("./target/debug/ferripfs")
        .env("IPFS_PATH", ferripfs_repo.path())
        .args(["daemon"])
        .spawn()
        .unwrap();
    wait_for_daemon(&ferripfs_repo, 4002);

    // Add content to each
    let kubo_content = b"Content from Kubo node for cross-exchange test";
    let kubo_cid = add_content_to_kubo(&kubo_repo, kubo_content);

    let ferripfs_content = b"Content from ferripfs node for cross-exchange test";
    let ferripfs_cid = add_content_to_ferripfs(&ferripfs_repo, ferripfs_content);

    // Get peer addresses and connect
    let kubo_addr = get_peer_addr(&kubo_repo, "kubo");
    let ferripfs_addr = get_peer_addr(&ferripfs_repo, "ferripfs");

    connect_peers(&ferripfs_repo, &kubo_addr);

    // Cross-fetch
    let fetched_from_kubo = Command::new("./target/debug/ferripfs")
        .env("IPFS_PATH", ferripfs_repo.path())
        .args(["cat", &kubo_cid])
        .output()
        .unwrap();

    let fetched_from_ferripfs = Command::new("ipfs")
        .env("IPFS_PATH", kubo_repo.path())
        .args(["cat", &ferripfs_cid])
        .output()
        .unwrap();

    // Cleanup
    kubo_daemon.kill();
    ferripfs_daemon.kill();

    let kubo_fetch_ok = fetched_from_kubo.stdout == kubo_content;
    let ferripfs_fetch_ok = fetched_from_ferripfs.stdout == ferripfs_content;

    let status = if kubo_fetch_ok && ferripfs_fetch_ok {
        TestStatus::Pass
    } else {
        TestStatus::Fail
    };

    let evidence = format!(
        "Network Content Exchange Test\n\
         ==============================\n\
         \n\
         Kubo node:\n\
         - Address: {}\n\
         - Added content: {:?}\n\
         - CID: {}\n\
         \n\
         ferripfs node:\n\
         - Address: {}\n\
         - Added content: {:?}\n\
         - CID: {}\n\
         \n\
         Cross-fetch results:\n\
         - ferripfs fetched from Kubo: {} bytes, match: {}\n\
         - Kubo fetched from ferripfs: {} bytes, match: {}\n\
         \n\
         Overall: {}",
        kubo_addr,
        String::from_utf8_lossy(kubo_content),
        kubo_cid,
        ferripfs_addr,
        String::from_utf8_lossy(ferripfs_content),
        ferripfs_cid,
        fetched_from_kubo.stdout.len(),
        kubo_fetch_ok,
        fetched_from_ferripfs.stdout.len(),
        ferripfs_fetch_ok,
        if kubo_fetch_ok && ferripfs_fetch_ok { "SUCCESS" } else { "FAILURE" }
    );

    // ... record result
}