// file: crates/ksp-store-api/tests/public_api.rs
// version: 8

//! Integration canaries for the public `ksp-store-api` surface.

fn consume_result(value: ksp_store_api::Result<ksp_store_api::Pubkey>) -> ksp_store_api::Result<ksp_store_api::Pubkey> {
    return value;
}

fn code(value: &str) -> std::option::Option<ksp_store_api::RawProvenanceCode> {
    return match ksp_store_api::RawProvenanceCode::new(value.to_owned()) {
        std::result::Result::Ok(value) => std::option::Option::Some(value),
        std::result::Result::Err(_) => std::option::Option::None,
    };
}

#[test]
fn public_pre_002_core_facade_remains_available_from_crate_root() {
    let pubkey = ksp_store_api::Pubkey::new_from_array([0x31_u8; 32]);
    let forwarded = consume_result(std::result::Result::Ok(pubkey));
    assert!(forwarded.is_ok());
    let error_code_type: std::option::Option<ksp_store_api::ErrorCode> = std::option::Option::None;
    let error_context_type: std::option::Option<ksp_store_api::ErrorContext> = std::option::Option::None;
    let error_type: std::option::Option<ksp_store_api::Error> = std::option::Option::None;
    assert!(error_code_type.is_none());
    assert!(error_context_type.is_none());
    assert!(error_type.is_none());
    return;
}

#[test]
fn public_pre_003_raw_transaction_and_observation_are_constructible_from_crate_root() {
    let network = match ksp_store_api::RawNetworkId::new("mainnet-beta".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let reference = ksp_store_api::RawTransactionReference::new(network, ksp_store_api::RawTransactionSignature::new([1_u8; 64]));
    let format = match ksp_store_api::RawFormatId::new("ksp.solana.raw_transaction".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let payload = match ksp_store_api::RawPayload::try_new(format, 1, vec![1_u8, 2_u8, 3_u8].into_boxed_slice(), ksp_store_api::RawContentHash::new([2_u8; 32]))
    {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let transaction = ksp_store_api::RawTransaction::new(reference.clone(), 123, std::option::Option::None, payload);
    let received_at = match ksp_store_api::RawTimestamp::from_unix_millis(1_000) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let provider = match code("provider") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let protocol = match code("solana_http") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let method = match code("getTransaction") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let provenance = ksp_store_api::RawAcquisitionProvenance::new(provider, protocol, method, ksp_store_api::RawAcquisitionOrigin::Backfill, received_at);
    let observation = ksp_store_api::RawTransactionObservation::new(ksp_store_api::RawObservationKey::new([3_u8; 32]), reference, provenance);
    assert_eq!(transaction.slot(), 123);
    assert_eq!(transaction.payload().bytes(), &[1_u8, 2_u8, 3_u8]);
    assert_eq!(observation.transaction().network().as_str(), "mainnet-beta");
    assert_eq!(observation.provenance().acquisition_method().as_str(), "getTransaction");
    assert_eq!(ksp_store_api::ERROR_CODE_RAW_PAYLOAD_INVALID.domain(), "store_api");
    return;
}

#[test]
fn public_pre_003_surface_keeps_backend_and_structural_types_out() {
    let source = include_str!("../src/lib.rs");
    assert!(!source.contains("pub mod "));
    for forbidden in ["Postgres", "Sql", "Migration", "StructuralTransaction", "RawLog", "ProgramInstruction"] {
        assert!(!source.contains(forbidden), "forbidden pre.003 Store API public concept detected: {forbidden}");
    }
    return;
}

#[test]
fn public_pre_004_raw_account_state_and_observation_are_constructible_from_crate_root() {
    let network = match ksp_store_api::RawNetworkId::new("mainnet-beta".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let reference = ksp_store_api::RawAccountStateReference::new(
        network,
        ksp_store_api::Pubkey::new_from_array([21_u8; 32]),
        55,
        ksp_store_api::RawContentHash::new([22_u8; 32]),
    );
    let state = ksp_store_api::RawAccountState::try_new(
        reference.clone(),
        123,
        ksp_store_api::Pubkey::new_from_array([23_u8; 32]),
        false,
        9,
        vec![1_u8, 2_u8].into_boxed_slice(),
    );
    assert!(state.is_ok());
    let received_at = match ksp_store_api::RawTimestamp::from_unix_millis(2_000) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let provider = match code("provider") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let protocol = match code("solana_http") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let method = match code("getAccountInfo") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let provenance = ksp_store_api::RawAcquisitionProvenance::new(provider, protocol, method, ksp_store_api::RawAcquisitionOrigin::Backfill, received_at);
    let observation = ksp_store_api::RawAccountObservation::new(ksp_store_api::RawObservationKey::new([24_u8; 32]), reference, provenance);
    assert_eq!(observation.account().slot(), 55);
    assert!(observation.write_version().is_none());
    assert_eq!(ksp_store_api::MAX_RAW_ACCOUNT_DATA_BYTES, 16 * 1024 * 1024);
    return;
}

#[test]
fn public_pre_005_capabilities_are_available_from_crate_root_and_dyn_compatible() {
    let transaction_read: std::option::Option<&dyn ksp_store_api::RawTransactionRead> = std::option::Option::None;
    let transaction_write: std::option::Option<&dyn ksp_store_api::RawTransactionWrite> = std::option::Option::None;
    let transaction_observation_read: std::option::Option<&dyn ksp_store_api::RawTransactionObservationRead> = std::option::Option::None;
    let transaction_observation_write: std::option::Option<&dyn ksp_store_api::RawTransactionObservationWrite> = std::option::Option::None;
    let account_read: std::option::Option<&dyn ksp_store_api::RawAccountStateRead> = std::option::Option::None;
    let account_write: std::option::Option<&dyn ksp_store_api::RawAccountStateWrite> = std::option::Option::None;
    let account_observation_read: std::option::Option<&dyn ksp_store_api::RawAccountObservationRead> = std::option::Option::None;
    let account_observation_write: std::option::Option<&dyn ksp_store_api::RawAccountObservationWrite> = std::option::Option::None;
    assert!(transaction_read.is_none());
    assert!(transaction_write.is_none());
    assert!(transaction_observation_read.is_none());
    assert!(transaction_observation_write.is_none());
    assert!(account_read.is_none());
    assert!(account_write.is_none());
    assert!(account_observation_read.is_none());
    assert!(account_observation_write.is_none());
    return;
}

#[test]
fn public_pre_006_query_outcome_and_retention_contracts_are_available_from_crate_root() {
    let limit = match ksp_store_api::RawPageLimit::new(5_000_000) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_eq!(limit.get(), 5_000_000);
    assert!(ksp_store_api::RawPageLimit::new(u64::MAX).is_ok());
    let slots = match ksp_store_api::RawSlotRange::new(std::option::Option::Some(1), std::option::Option::Some(2)) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let network = match ksp_store_api::RawNetworkId::new("mainnet-beta".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let query =
        ksp_store_api::RawTransactionQuery::new(network, slots, ksp_store_api::RawSortDirection::Ascending, ksp_store_api::RawPageRequest::first(limit));
    assert_eq!(query.page().limit().get(), 5_000_000);
    let outcome =
        ksp_store_api::RawAcquisitionWriteOutcome::new(ksp_store_api::RawEntityWriteOutcome::Inserted, ksp_store_api::RawObservationWriteOutcome::Inserted);
    assert_eq!(outcome.entity(), ksp_store_api::RawEntityWriteOutcome::Inserted);
    assert_eq!(outcome.observation(), ksp_store_api::RawObservationWriteOutcome::Inserted);
    let retention_read: std::option::Option<&dyn ksp_store_api::RawTransactionRetentionRead> = std::option::Option::None;
    let retention_write: std::option::Option<&dyn ksp_store_api::RawTransactionRetentionWrite> = std::option::Option::None;
    assert!(retention_read.is_none());
    assert!(retention_write.is_none());
    assert_eq!(ksp_store_api::ERROR_CODE_RAW_CONFLICT.domain(), "store_api");
    assert_eq!(ksp_store_api::ERROR_CODE_RAW_QUERY_INVALID.domain(), "store_api");
    assert_eq!(ksp_store_api::ERROR_CODE_RAW_RETENTION_INVALID.domain(), "store_api");
    return;
}

#[test]
fn public_pre_007_retention_race_outcome_is_available_from_crate_root() {
    assert_ne!(ksp_store_api::RawRetentionWriteOutcome::Applied, ksp_store_api::RawRetentionWriteOutcome::ExpectedStateMismatch);
    assert_ne!(ksp_store_api::RawRetentionWriteOutcome::AlreadyAtTarget, ksp_store_api::RawRetentionWriteOutcome::ExpectedStateMismatch);
    return;
}

#[test]
fn public_v0_3_8_pre_003_inspection_contracts_are_backend_neutral_and_dyn_compatible() {
    let limit = match ksp_store_api::RawPageLimit::new(25) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let request = ksp_store_api::RawInspectionPageRequest::new(50, limit);
    assert_eq!(request.offset(), 50);
    assert_eq!(request.limit().get(), 25);
    let page = ksp_store_api::RawInspectionPage::<u64>::try_new(std::vec![1, 2], 10, 5);
    assert!(page.is_ok());
    let transaction_inspection: std::option::Option<&dyn ksp_store_api::RawTransactionInspectionRead> = std::option::Option::None;
    let transaction_observation_inspection: std::option::Option<&dyn ksp_store_api::RawTransactionObservationInspectionRead> = std::option::Option::None;
    let account_inspection: std::option::Option<&dyn ksp_store_api::RawAccountStateInspectionRead> = std::option::Option::None;
    let account_observation_inspection: std::option::Option<&dyn ksp_store_api::RawAccountObservationInspectionRead> = std::option::Option::None;
    assert!(transaction_inspection.is_none());
    assert!(transaction_observation_inspection.is_none());
    assert!(account_inspection.is_none());
    assert!(account_observation_inspection.is_none());
    return;
}