// file: crates/ksp-store-api/unit_tests/model/raw_account.rs
// version: 2

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 provenance() -> std::option::Option<crate::RawAcquisitionProvenance> {
    let provider = match crate::RawProvenanceCode::new("publicnode".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    let protocol = match crate::RawProvenanceCode::new("yellowstone_grpc".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    let method = match crate::RawProvenanceCode::new("accounts".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    let received_at = match crate::RawTimestamp::from_unix_millis(1_000) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    return std::option::Option::Some(crate::RawAcquisitionProvenance::new(provider, protocol, method, crate::RawAcquisitionOrigin::Live, received_at));
}

#[test]
fn raw_account_state_preserves_complete_common_fields_and_redacts_data_debug() {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let pubkey = ksp_core_lib::Pubkey::new_from_array([1_u8; 32]);
    let owner = ksp_core_lib::Pubkey::new_from_array([2_u8; 32]);
    let reference = crate::RawAccountStateReference::new(network, pubkey, 42, crate::RawContentHash::new([3_u8; 32]));
    let data = b"ACCOUNT_DATA_SENTINEL_NEVER_RENDER".to_vec().into_boxed_slice();
    let state_result = crate::RawAccountState::try_new(reference.clone(), 500, owner, false, 7, data);
    assert!(state_result.is_ok());
    let state = match state_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_eq!(state.reference(), &reference);
    assert_eq!(state.lamports(), 500);
    assert!(!state.executable());
    assert_eq!(state.rent_epoch(), 7);
    assert_eq!(state.data(), b"ACCOUNT_DATA_SENTINEL_NEVER_RENDER");
    let debug = format!("{state:?}");
    assert!(!debug.contains("ACCOUNT_DATA_SENTINEL_NEVER_RENDER"));
    assert!(debug.contains("data_len"));
    return;
}

#[test]
fn raw_account_state_rejects_only_oversized_data_and_allows_empty_accounts() {
    let first_network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let first_reference =
        crate::RawAccountStateReference::new(first_network, ksp_core_lib::Pubkey::new_from_array([4_u8; 32]), 1, crate::RawContentHash::new([5_u8; 32]));
    let empty = crate::RawAccountState::try_new(
        first_reference,
        0,
        ksp_core_lib::Pubkey::new_from_array([6_u8; 32]),
        false,
        0,
        std::vec::Vec::new().into_boxed_slice(),
    );
    assert!(empty.is_ok());
    let second_network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let second_reference =
        crate::RawAccountStateReference::new(second_network, ksp_core_lib::Pubkey::new_from_array([7_u8; 32]), 2, crate::RawContentHash::new([8_u8; 32]));
    let oversized = vec![0_u8; crate::MAX_RAW_ACCOUNT_DATA_BYTES + 1].into_boxed_slice();
    let rejected = crate::RawAccountState::try_new(second_reference, 0, ksp_core_lib::Pubkey::new_from_array([9_u8; 32]), false, 0, oversized);
    assert!(rejected.is_err());
    return;
}

#[test]
fn raw_account_observation_keeps_yellowstone_specific_metadata_optional() {
    let network = match network() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let reference =
        crate::RawAccountStateReference::new(network, ksp_core_lib::Pubkey::new_from_array([10_u8; 32]), 99, crate::RawContentHash::new([11_u8; 32]));
    let provenance = match provenance() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let observation = crate::RawAccountObservation::new(crate::RawObservationKey::new([12_u8; 32]), reference.clone(), provenance)
        .with_write_version(17)
        .with_transaction_signature(crate::RawTransactionSignature::new([13_u8; 64]))
        .with_is_startup(false);
    assert_eq!(observation.account(), &reference);
    assert_eq!(observation.write_version(), std::option::Option::Some(17));
    assert_eq!(observation.is_startup(), std::option::Option::Some(false));
    assert_eq!(observation.transaction_signature(), std::option::Option::Some(crate::RawTransactionSignature::new([13_u8; 64])));
    return;
}