use passport::{
    application::use_cases::*,
    Bip39MnemonicGenerator, Ed25519KeyDeriver, XChaCha20FileEncryptor, FileSystemStorage,
    FileStorage,
};
use std::fs;

fn main() {
    println!("Testing universe binding implementation...");

    let mnemonic_generator = Bip39MnemonicGenerator;
    let key_deriver = Ed25519KeyDeriver;
    let file_encryptor = XChaCha20FileEncryptor;
    let file_storage = FileSystemStorage;

    let create_use_case = CreatePassportUseCase::new(
        mnemonic_generator.clone(),
        key_deriver.clone(),
        file_encryptor.clone(),
        file_storage.clone(),
    );

    // Test 1: Create passports for different universes
    println!("\nTest 1: Creating passports for different universes...");
    let univ1 = "univ:test:alpha";
    let univ2 = "univ:test:beta";
    let password = "test_password";

    let (passport1, recovery_phrase) = create_use_case
        .execute(univ1, password, "/tmp/test_passport1.spf")
        .expect("Failed to create passport 1");

    println!("✓ Passport 1 created for universe: {}", passport1.univ_id());
    println!("  DID: {}", passport1.did().as_str());

    let import_use_case = ImportFromRecoveryUseCase::new(
        mnemonic_generator,
        key_deriver,
        file_encryptor,
        file_storage,
    );

    let passport2 = import_use_case
        .execute(
            univ2,
            &recovery_phrase.words(),
            password,
            "/tmp/test_passport2.spf",
        )
        .expect("Failed to create passport 2");

    println!("✓ Passport 2 created for universe: {}", passport2.univ_id());
    println!("  DID: {}", passport2.did().as_str());

    // Verify universe binding
    assert_eq!(passport1.univ_id(), univ1);
    assert_eq!(passport2.univ_id(), univ2);
    assert_ne!(passport1.did().as_str(), passport2.did().as_str());
    assert_ne!(
        hex::encode(&passport1.public_key().0),
        hex::encode(&passport2.public_key().0)
    );

    println!("✓ Universe binding verified - different universes produce different identities");

    // Test 2: Universe-bound card signing
    println!("\nTest 2: Testing universe-bound card signing...");
    let sign_use_case = SignCardUseCase::new();
    let message = "Hello, universe!";
    let _signature = sign_use_case
        .execute(&passport1, message)
        .expect("Failed to sign message");

    println!("✓ Message signed successfully");

    // Test 3: Verify PassportFile stores univ_id
    println!("\nTest 3: Verifying PassportFile stores univ_id...");
    let loaded_file = FileSystemStorage
        .load("/tmp/test_passport1.spf")
        .expect("Failed to load passport file");

    assert_eq!(loaded_file.univ_id, univ1);
    println!("✓ PassportFile correctly stores univ_id: {}", loaded_file.univ_id);

    // Test 4: Import from file preserves univ_id
    println!("\nTest 4: Testing import from file preserves univ_id...");
    let import_file_use_case = ImportFromFileUseCase::new(XChaCha20FileEncryptor, FileSystemStorage);
    let imported_passport = import_file_use_case
        .execute("/tmp/test_passport1.spf", password, None)
        .expect("Failed to import passport");

    assert_eq!(imported_passport.univ_id(), univ1);
    println!("✓ Imported passport preserves univ_id: {}", imported_passport.univ_id());

    // Clean up
    let _ = fs::remove_file("/tmp/test_passport1.spf");
    let _ = fs::remove_file("/tmp/test_passport2.spf");

    println!("\n🎉 All universe binding tests passed successfully!");
    println!("\nSummary:");
    println!("- Passports are cryptographically bound to their universe");
    println!("- Same mnemonic + different universe = different identities");
    println!("- DIDs include universe identifier");
    println!("- Card signatures are universe-bound");
    println!("- Passport files store univ_id for verification");
}