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

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

fn network() -> std::option::Option<crate::RawNetworkId> {
    return match crate::RawNetworkId::new("mainnet-beta".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-beta");
    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;
}