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

//! 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_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,
    ];
    assert_eq!(codes.len(), 14);
    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(());
}