// file: crates/ksp-wallet-lib/tests/public_api.rs
// version: 8

//! Public API canaries for the Wallet foundation.

fn accepts_view_handle(_: std::option::Option<&ksp_wallet_lib::WalletView>) {}

fn accepts_owner_handle(_: std::option::Option<&ksp_wallet_lib::WalletOwner>) {}

#[test]
fn capability_and_handle_types_are_available_from_crate_root() {
    assert_eq!(ksp_wallet_lib::WalletCapability::View, ksp_wallet_lib::WalletCapability::View);
    assert_ne!(ksp_wallet_lib::WalletCapability::View, ksp_wallet_lib::WalletCapability::Owner);
    accepts_view_handle(std::option::Option::None);
    accepts_owner_handle(std::option::Option::None);
}

#[test]
fn password_types_redact_public_debug_output() {
    let view = ksp_wallet_lib::ViewPassword::new(std::string::String::from("PUBLIC-VIEW-CANARY"));
    let owner = ksp_wallet_lib::OwnerPassword::new(std::string::String::from("PUBLIC-OWNER-CANARY"));
    let view_debug = format!("{view:?}");
    let owner_debug = format!("{owner:?}");
    assert!(!view_debug.contains("PUBLIC-VIEW-CANARY"));
    assert!(!owner_debug.contains("PUBLIC-OWNER-CANARY"));
    assert!(std::mem::needs_drop::<ksp_wallet_lib::ViewPassword>());
    assert!(std::mem::needs_drop::<ksp_wallet_lib::OwnerPassword>());
}

#[test]
fn metadata_projection_methods_use_core_pubkey_contract() {
    let pubkey_method: fn(&ksp_wallet_lib::WalletInfo) -> &ksp_core_lib::Pubkey = ksp_wallet_lib::WalletInfo::pubkey;
    let view_pubkey_method: fn(&ksp_wallet_lib::WalletView) -> &ksp_core_lib::Pubkey = ksp_wallet_lib::WalletView::pubkey;
    let owner_pubkey_method: fn(&ksp_wallet_lib::WalletOwner) -> &ksp_core_lib::Pubkey = ksp_wallet_lib::WalletOwner::pubkey;
    let _ = pubkey_method;
    let _ = view_pubkey_method;
    let _ = owner_pubkey_method;
}

#[test]
fn wallet_error_codes_are_available_from_crate_root() {
    let codes = [
        ksp_wallet_lib::ERROR_CODE_FORMAT_INVALID,
        ksp_wallet_lib::ERROR_CODE_FORMAT_VERSION_UNSUPPORTED,
        ksp_wallet_lib::ERROR_CODE_CRYPTO_PARAMETERS_INVALID,
        ksp_wallet_lib::ERROR_CODE_CRYPTO_OPERATION_FAILED,
        ksp_wallet_lib::ERROR_CODE_RANDOMNESS_FAILED,
        ksp_wallet_lib::ERROR_CODE_AUTHENTICATION_FAILED,
        ksp_wallet_lib::ERROR_CODE_VIEW_UNLOCK_FAILED,
        ksp_wallet_lib::ERROR_CODE_OWNER_UNLOCK_FAILED,
        ksp_wallet_lib::ERROR_CODE_CAPABILITY_INSUFFICIENT,
        ksp_wallet_lib::ERROR_CODE_IO_FAILED,
        ksp_wallet_lib::ERROR_CODE_DESTINATION_EXISTS,
        ksp_wallet_lib::ERROR_CODE_ATOMIC_PERSISTENCE_FAILED,
        ksp_wallet_lib::ERROR_CODE_TRANSFER_FORMAT_UNSUPPORTED,
        ksp_wallet_lib::ERROR_CODE_KEY_MATERIAL_INVALID,
        ksp_wallet_lib::ERROR_CODE_SIGNATURE_FAILED,
        ksp_wallet_lib::ERROR_CODE_NOTE_NOT_FOUND,
        ksp_wallet_lib::ERROR_CODE_STATE_CONFLICT,
    ];
    assert_eq!(codes.len(), 17);
    for code in codes {
        assert_eq!(code.domain(), "wallet");
    }
}

#[test]
fn strict_v1_envelope_and_transcript_are_available_from_crate_root() -> ksp_core_lib::Result<()> {
    let source = include_bytes!("fixtures/kspwallet_v1_wire_only.json");
    let envelope = match ksp_wallet_lib::KspWalletEnvelopeV1::parse_json(source) {
        std::result::Result::Ok(envelope) => envelope,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    assert_eq!(envelope.format_version(), ksp_wallet_lib::KSPWALLET_FORMAT_VERSION_V1);
    assert_eq!(envelope.owner_slot().role(), ksp_wallet_lib::WalletKeySlotRoleV1::Owner);
    assert!(envelope.view_descriptor().enabled());
    assert!(!envelope.state_transcript().is_empty());
    assert!(!envelope.owner_slot_aad().is_empty());
    assert!(envelope.view_slot_aad().is_some());
    assert!(!envelope.compartment_aad(ksp_wallet_lib::WalletCompartmentKindV1::Metadata).is_empty());
    return std::result::Result::Ok(());
}

#[test]
fn public_pre_005_create_open_and_calibrated_defaults_are_available_from_crate_root() {
    let _ = ksp_wallet_lib::create_wallet_v1;
    let _ = ksp_wallet_lib::open_wallet_view_v1;
    let _ = ksp_wallet_lib::open_wallet_owner_v1;
    let _ = ksp_wallet_lib::inspect_locked_wallet_v1;
    let metadata = ksp_wallet_lib::WalletCreateMetadataV1::default();
    assert_eq!(format!("{metadata:?}"), "WalletCreateMetadataV1 { alias: None, note_count: 0 }");
    assert_eq!(ksp_wallet_lib::KSPWALLET_V1_DEFAULT_ARGON2_MEMORY_KIB, 65_536);
    assert_eq!(ksp_wallet_lib::KSPWALLET_V1_DEFAULT_ARGON2_ITERATIONS, 3);
    assert_eq!(ksp_wallet_lib::KSPWALLET_V1_DEFAULT_ARGON2_PARALLELISM, 1);
    assert_eq!(ksp_wallet_lib::KSPWALLET_V1_DEFAULT_KDF_SALT_BYTES, 32);
}

#[test]
fn public_pre_006_file_persistence_surface_is_available_from_crate_root() {
    let path = std::path::Path::new("not-polled.kspwallet");
    let owner_password = ksp_wallet_lib::OwnerPassword::new(std::string::String::from("public-pre006-owner-password"));
    let create_future =
        ksp_wallet_lib::create_wallet_file_v1(path, owner_password, std::option::Option::None, ksp_wallet_lib::WalletCreateMetadataV1::default());
    drop(create_future);

    let view_password = ksp_wallet_lib::ViewPassword::new(std::string::String::from("public-pre006-view-password"));
    let view_future = ksp_wallet_lib::open_wallet_view_file_v1(path, view_password);
    drop(view_future);

    let owner_password = ksp_wallet_lib::OwnerPassword::new(std::string::String::from("public-pre006-owner-password"));
    let owner_future = ksp_wallet_lib::open_wallet_owner_file_v1(path, owner_password);
    drop(owner_future);

    let inspect_future = ksp_wallet_lib::inspect_locked_wallet_file_v1(path);
    drop(inspect_future);
}

#[test]
fn public_pre_007_owner_signing_and_administration_surface_is_available() {
    let sign_method: fn(&ksp_wallet_lib::WalletOwner, &[u8]) -> ksp_core_lib::Result<[u8; ksp_wallet_lib::KSPWALLET_SOLANA_SIGNATURE_BYTES]> =
        ksp_wallet_lib::WalletOwner::sign;
    let _ = sign_method;
    assert_eq!(ksp_wallet_lib::KSPWALLET_SOLANA_SIGNATURE_BYTES, 64);
}

#[test]
fn public_pre_008_transfer_adapters_are_available_from_crate_root() {
    let formats = ksp_wallet_lib::WalletTransferFormat::supported();
    assert_eq!(formats.len(), 2);
    assert_eq!(formats[0].code(), "solana_cli_json");
    assert_eq!(formats[1].code(), "solana_keypair_base58");
    assert_eq!(ksp_wallet_lib::KSPWALLET_TRANSFER_MAX_SOLANA_CLI_JSON_BYTES, 1024);
    assert_eq!(ksp_wallet_lib::KSPWALLET_TRANSFER_MAX_BASE58_BYTES, 128);
    let export_method: fn(&ksp_wallet_lib::WalletOwner, ksp_wallet_lib::WalletTransferFormat) -> ksp_core_lib::Result<std::vec::Vec<u8>> =
        ksp_wallet_lib::WalletOwner::export_transfer;
    let _ = export_method;
    let inspect_method: fn(&[u8], ksp_wallet_lib::WalletTransferFormat) -> ksp_core_lib::Result<ksp_wallet_lib::WalletTransferInspection> =
        ksp_wallet_lib::inspect_wallet_transfer;
    let _ = inspect_method;

    let path = std::path::Path::new("not-polled-transfer");
    let inspect_file_future = ksp_wallet_lib::inspect_wallet_transfer_file(path, formats[0]);
    drop(inspect_file_future);
    let owner_password = ksp_wallet_lib::OwnerPassword::new(std::string::String::from("public-pre008-owner-password"));
    let import_future = ksp_wallet_lib::import_wallet_transfer_v1(
        path,
        b"[1,2,3]",
        formats[0],
        owner_password,
        std::option::Option::None,
        ksp_wallet_lib::WalletCreateMetadataV1::default(),
    );
    drop(import_future);
    let owner_password = ksp_wallet_lib::OwnerPassword::new(std::string::String::from("public-pre008-owner-password"));
    let import_file_future = ksp_wallet_lib::import_wallet_transfer_file_v1(
        path,
        path,
        formats[0],
        owner_password,
        std::option::Option::None,
        ksp_wallet_lib::WalletCreateMetadataV1::default(),
    );
    drop(import_file_future);
}