// file: crates/ksp-store-api/unit_tests/model/raw_inspection.rs
// version: 3

//! Unit tests for backend-neutral RAW inspection contracts.

fn network() -> std::option::Option<crate::RawNetworkId> {
    return match crate::RawNetworkId::new("mainnet".to_owned()) {
        std::result::Result::Ok(value) => std::option::Option::Some(value),
        std::result::Result::Err(_) => std::option::Option::None,
    };
}

fn format_id() -> std::option::Option<crate::RawFormatId> {
    return match crate::RawFormatId::new("ksp.solana.raw_transaction".to_owned()) {
        std::result::Result::Ok(value) => std::option::Option::Some(value),
        std::result::Result::Err(_) => std::option::Option::None,
    };
}

#[test]
fn inspection_page_request_preserves_large_offset_and_caller_limit_without_cursor_semantics() {
    let limit = match crate::RawPageLimit::new(100) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let request = crate::RawInspectionPageRequest::new(u64::MAX, limit);
    assert_eq!(request.offset(), u64::MAX);
    assert_eq!(request.limit().get(), 100);
    return;
}

#[test]
fn inspection_page_rejects_inconsistent_exact_counts() {
    assert!(crate::RawInspectionPage::<u64>::try_new(std::vec![1], 0, 0).is_err());
    assert!(crate::RawInspectionPage::<u64>::try_new(std::vec::Vec::new(), 4, 5).is_err());
    let page = crate::RawInspectionPage::<u64>::try_new(std::vec![1, 2], 5, 3);
    assert!(page.is_ok());
    let page = match page {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_eq!(page.total_items(), 5);
    assert_eq!(page.filtered_items(), 3);
    assert_eq!(page.items(), &[1, 2]);
    return;
}

#[test]
fn inspection_queries_keep_backend_neutral_filters_and_random_access_page() {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let slots = match crate::RawSlotRange::new(std::option::Option::Some(10), std::option::Option::Some(20)) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let limit = match crate::RawPageLimit::new(25) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let transaction =
        crate::RawTransactionInspectionQuery::new(network.clone(), slots, crate::RawSortDirection::Descending, crate::RawInspectionPageRequest::new(50, limit));
    assert_eq!(transaction.network().as_str(), "mainnet");
    assert_eq!(transaction.page().offset(), 50);
    assert_eq!(transaction.slots().end_inclusive(), std::option::Option::Some(20));
    assert_eq!(transaction.direction(), crate::RawSortDirection::Descending);
    let pubkey = crate::Pubkey::new_from_array([0x21_u8; 32]);
    let account = crate::RawAccountStateInspectionQuery::new(
        network,
        std::option::Option::Some(pubkey),
        slots,
        crate::RawSortDirection::Ascending,
        crate::RawInspectionPageRequest::new(75, limit),
    );
    assert_eq!(account.page().offset(), 75);
    assert_eq!(account.pubkey(), std::option::Option::Some(&pubkey));
    return;
}

#[test]
fn transaction_summary_is_payload_free_and_retention_consistent() {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let format_id = match format_id() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let reference = crate::RawTransactionReference::new(network, crate::RawTransactionSignature::new([0x31_u8; 64]));
    let full = crate::RawTransactionSummary::try_new(
        reference.clone(),
        42,
        std::option::Option::None,
        format_id.clone(),
        1,
        crate::RawContentHash::new([0x32_u8; 32]),
        std::option::Option::Some(123),
        crate::RawRetentionState::Full,
    );
    assert!(full.is_ok());
    let full = match full {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_eq!(full.slot(), 42);
    assert_eq!(full.payload_size_bytes(), std::option::Option::Some(123));
    assert_eq!(full.retention_state(), crate::RawRetentionState::Full);
    assert!(
        crate::RawTransactionSummary::try_new(
            reference.clone(),
            42,
            std::option::Option::None,
            format_id.clone(),
            1,
            crate::RawContentHash::new([0x32_u8; 32]),
            std::option::Option::None,
            crate::RawRetentionState::Full,
        )
        .is_err()
    );
    assert!(
        crate::RawTransactionSummary::try_new(
            reference,
            42,
            std::option::Option::None,
            format_id,
            1,
            crate::RawContentHash::new([0x32_u8; 32]),
            std::option::Option::Some(123),
            crate::RawRetentionState::Purged,
        )
        .is_err()
    );
    return;
}

#[test]
fn account_summary_exposes_length_only_and_enforces_raw_account_bound() {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let reference = crate::RawAccountStateReference::new(network, crate::Pubkey::new_from_array([0x41_u8; 32]), 88, crate::RawContentHash::new([0x42_u8; 32]));
    let summary = crate::RawAccountStateSummary::try_new(reference.clone(), 1000, crate::Pubkey::new_from_array([0x43_u8; 32]), false, 9, 512);
    assert!(summary.is_ok());
    let summary = match summary {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_eq!(summary.reference().slot(), 88);
    assert_eq!(summary.data_length_bytes(), 512);
    assert!(crate::RawAccountStateSummary::try_new(reference, 1000, crate::Pubkey::new_from_array([0x43_u8; 32]), false, 9, 16_777_217,).is_err());
    return;
}

#[test]
fn observation_inspection_queries_require_network_coherence_and_exact_entity_filters() {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let other_network = match crate::RawNetworkId::new("devnet".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let limit = match crate::RawPageLimit::new(25) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let page = crate::RawInspectionPageRequest::new(125, limit);
    let transaction_reference = crate::RawTransactionReference::new(network.clone(), crate::RawTransactionSignature::new([0x51_u8; 64]));
    let transaction = crate::RawTransactionObservationInspectionQuery::try_new(
        network.clone(),
        std::option::Option::Some(transaction_reference.clone()),
        crate::RawSortDirection::Descending,
        page,
    );
    assert!(transaction.is_ok());
    let transaction = match transaction {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_eq!(transaction.page().offset(), 125);
    assert_eq!(transaction.transaction(), std::option::Option::Some(&transaction_reference));
    assert!(
        crate::RawTransactionObservationInspectionQuery::try_new(
            other_network.clone(),
            std::option::Option::Some(transaction_reference),
            crate::RawSortDirection::Ascending,
            page,
        )
        .is_err()
    );
    let account_reference =
        crate::RawAccountStateReference::new(network.clone(), crate::Pubkey::new_from_array([0x52_u8; 32]), 99, crate::RawContentHash::new([0x53_u8; 32]));
    let account = crate::RawAccountObservationInspectionQuery::try_new(
        network,
        std::option::Option::Some(account_reference.clone()),
        crate::RawSortDirection::Ascending,
        page,
    );
    assert!(account.is_ok());
    let account = match account {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_eq!(account.account(), std::option::Option::Some(&account_reference));
    let mismatched_account = crate::RawAccountStateReference::new(
        other_network.clone(),
        crate::Pubkey::new_from_array([0x54_u8; 32]),
        100,
        crate::RawContentHash::new([0x55_u8; 32]),
    );
    assert!(
        crate::RawAccountObservationInspectionQuery::try_new(
            other_network,
            std::option::Option::Some(account_reference),
            crate::RawSortDirection::Ascending,
            page,
        )
        .is_err()
    );
    let _ = mismatched_account;
    return;
}

#[test]
fn observation_summaries_expose_safe_provenance_without_raw_entity_bytes() {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let provider = match crate::RawProvenanceCode::new("publicnode".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let protocol = match crate::RawProvenanceCode::new("solana-json-rpc".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let method = match crate::RawProvenanceCode::new("getTransaction".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let received_at = match crate::RawTimestamp::from_unix_millis(1_750_000_000_000) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let provenance = crate::RawAcquisitionProvenance::new(provider, protocol, method, crate::RawAcquisitionOrigin::Backfill, received_at);
    let transaction_reference = crate::RawTransactionReference::new(network.clone(), crate::RawTransactionSignature::new([0x61_u8; 64]));
    let transaction =
        crate::RawTransactionObservationSummary::new(crate::RawObservationKey::new([0x62_u8; 32]), transaction_reference.clone(), provenance.clone());
    assert_eq!(transaction.transaction(), &transaction_reference);
    assert_eq!(transaction.provenance().received_at(), received_at);
    let account_reference =
        crate::RawAccountStateReference::new(network, crate::Pubkey::new_from_array([0x63_u8; 32]), 700, crate::RawContentHash::new([0x64_u8; 32]));
    let account = crate::RawAccountObservationSummary::new(
        crate::RawObservationKey::new([0x65_u8; 32]),
        account_reference.clone(),
        provenance,
        std::option::Option::Some(true),
        std::option::Option::Some(crate::RawTransactionSignature::new([0x66_u8; 64])),
        std::option::Option::Some(u64::MAX),
    );
    assert_eq!(account.account(), &account_reference);
    assert_eq!(account.is_startup(), std::option::Option::Some(true));
    assert_eq!(account.write_version(), std::option::Option::Some(u64::MAX));
    return;
}