// file: crates/ksp-job-backfill-lib/tests/public_api.rs
// version: 7

//! Public API canaries through the concrete Backfill cancellation and latest-value runtime tranche.

#[test]
fn pre_005_request_scope_and_discovery_contracts_are_available_from_crate_root() {
    let _discover = ksp_job_backfill_lib::discover_backfill_candidates;
    let address = ksp_core_lib::Pubkey::new_from_array([21_u8; 32]);
    let scope = ksp_job_backfill_lib::BackfillScope::latest_address(address);
    let network = ksp_store_lib::RawNetworkId::new("devnet");
    assert!(network.is_ok());
    let network = match network {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let job_id = ksp_job_api::JobId::new("backfill:public-api");
    assert!(job_id.is_ok());
    let job_id = match job_id {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let request = ksp_job_backfill_lib::BackfillRequest::new(
        job_id,
        network,
        ksp_onchain_transport_lib::HttpRoleName::new("history"),
        ksp_job_backfill_lib::BackfillCommitment::Confirmed,
        scope,
        100,
        10,
        500,
        8,
        std::option::Option::Some(100),
    );
    assert!(request.is_ok());
    let request = match request {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_eq!(request.scope().kind(), ksp_job_backfill_lib::BackfillScopeKind::LatestAddress);
    assert_eq!(request.page_size(), 100);
    return;
}

#[test]
fn pre_005_candidate_identity_is_network_plus_signature_not_transport_source() {
    let signature = ksp_job_backfill_lib::BackfillSignature::new("1".repeat(ksp_job_backfill_lib::MIN_BACKFILL_SIGNATURE_TEXT_BYTES));
    let signature = match signature {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let mainnet = ksp_store_lib::RawNetworkId::new("mainnet");
    let devnet = ksp_store_lib::RawNetworkId::new("devnet");
    let mainnet = match mainnet {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let devnet = match devnet {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let mainnet_identity = ksp_job_backfill_lib::BackfillCandidateIdentity::new(mainnet, signature.clone());
    let devnet_identity = ksp_job_backfill_lib::BackfillCandidateIdentity::new(devnet, signature);
    assert_ne!(mainnet_identity, devnet_identity);
    return;
}

#[test]
fn pre_006_raw_conversion_contract_is_available_from_crate_root() {
    assert_eq!(ksp_job_backfill_lib::RAW_TRANSACTION_FORMAT_ID, "ksp.solana.raw_transaction");
    assert_eq!(ksp_job_backfill_lib::RAW_TRANSACTION_FORMAT_VERSION, 1);
    let signature = ksp_job_backfill_lib::BackfillSignature::new("1".repeat(64));
    assert!(signature.is_ok());
    let signature = match signature {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let decoded = signature.to_raw_transaction_signature();
    assert!(decoded.is_ok());
    if let std::result::Result::Ok(decoded) = decoded {
        assert_eq!(decoded.as_bytes(), &[0_u8; 64]);
    }
    let _hydrate = ksp_job_backfill_lib::hydrate_backfill_candidate;
    let _outcome: std::option::Option<ksp_job_backfill_lib::BackfillHydrationOutcome> = std::option::Option::None;
    let _acquisition: std::option::Option<ksp_job_backfill_lib::BackfillRawAcquisition> = std::option::Option::None;
    assert_eq!(ksp_job_backfill_lib::ERROR_CODE_BACKFILL_RAW_CONVERSION_INVALID, ksp_core_lib::ErrorCode::new("job_backfill", "raw_conversion_invalid"));
    return;
}

#[test]
fn pre_007_store_persistence_contract_is_available_from_crate_root() {
    let _persist = ksp_job_backfill_lib::persist_backfill_hydration;
    let _outcome: std::option::Option<ksp_job_backfill_lib::BackfillPersistenceOutcome> = std::option::Option::None;
    let _entity = ksp_job_backfill_lib::BackfillEntityPersistence::AlreadyPresent;
    let _observation = ksp_job_backfill_lib::BackfillObservationPersistence::AlreadyPresent;
    assert_eq!(ksp_job_backfill_lib::ERROR_CODE_BACKFILL_PERSISTENCE_INVALID, ksp_core_lib::ErrorCode::new("job_backfill", "persistence_invalid"));
    return;
}

#[test]
fn pre_008_checkpoint_and_bounded_execution_contracts_are_available_from_crate_root() {
    let _execute = ksp_job_backfill_lib::execute_backfill_discovery;
    let _checkpoint: std::option::Option<ksp_job_backfill_lib::BackfillCheckpoint> = std::option::Option::None;
    let _batch: std::option::Option<ksp_job_backfill_lib::BackfillExecutionBatch> = std::option::Option::None;
    assert_eq!(ksp_job_backfill_lib::ERROR_CODE_BACKFILL_CHECKPOINT_INVALID, ksp_core_lib::ErrorCode::new("job_backfill", "checkpoint_invalid"));
    assert_eq!(ksp_job_backfill_lib::ERROR_CODE_BACKFILL_EXECUTION_INVALID, ksp_core_lib::ErrorCode::new("job_backfill", "execution_invalid"));
    return;
}

#[test]
fn pre_009_concrete_runtime_snapshot_and_control_contracts_are_available_from_crate_root() {
    fn assert_source<T>(_: std::marker::PhantomData<T>)
    where
        T: ksp_job_api::JobSnapshotSource<Snapshot = ksp_job_backfill_lib::BackfillJobSnapshot>,
    {
        return;
    }
    assert_source(std::marker::PhantomData::<ksp_job_backfill_lib::BackfillSnapshotSource>);
    let _runtime_new = ksp_job_backfill_lib::BackfillJobRuntime::new;
    let _handle: std::option::Option<ksp_job_backfill_lib::BackfillJobHandle> = std::option::Option::None;
    let _phase = ksp_job_backfill_lib::BackfillJobPhase::Discovering;
    assert_eq!(ksp_job_backfill_lib::BACKFILL_JOB_KIND_CODE, "solana.raw_transaction.backfill");
    assert_eq!(ksp_job_backfill_lib::ERROR_CODE_BACKFILL_RUNTIME_INVALID, ksp_core_lib::ErrorCode::new("job_backfill", "runtime_invalid"));
    return;
}