// file: crates/ksp-app-backfill-desk/unit_tests/backfill_run.rs
// version: 4

#[test]
fn generated_run_ids_are_backend_owned_bounded_and_unique_in_session() {
    let state = crate::BackfillRunState::new();
    let first = state.next_job_id();
    let second = state.next_job_id();
    assert!(first.is_ok());
    assert!(second.is_ok());
    let first = match first {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let second = match second {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_ne!(first, second);
    assert!(first.as_str().starts_with("backfill-desk-"));
    assert!(second.as_str().starts_with("backfill-desk-"));
    assert!(first.as_str().len() <= ksp_job_api::MAX_JOB_ID_BYTES);
    assert!(second.as_str().len() <= ksp_job_api::MAX_JOB_ID_BYTES);
}

fn cancellable_runtime(
    job_id: &str,
) -> std::option::Option<(ksp_job_api::JobId, ksp_job_backfill_lib::BackfillRequest, ksp_job_backfill_lib::BackfillJobRuntime)> {
    let job_id = match ksp_job_api::JobId::new(job_id) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    let network = match ksp_store_lib::RawNetworkId::new("mainnet") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    let request = ksp_job_backfill_lib::BackfillRequest::new(
        job_id.clone(),
        network,
        ksp_onchain_transport_lib::HttpRoleName::new("backfill_pool"),
        ksp_job_backfill_lib::BackfillCommitment::Finalized,
        ksp_job_backfill_lib::BackfillScope::latest_address(ksp_core_lib::Pubkey::new_from_array([1_u8; 32])),
        1,
        1,
        1,
        1,
        std::option::Option::None,
    );
    let request = match request {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    let retained_request = request.clone();
    let runtime = match ksp_job_backfill_lib::BackfillJobRuntime::new(request) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    return std::option::Option::Some((job_id, retained_request, runtime));
}

#[test]
fn targeted_cancel_is_idempotent_and_rejects_stale_job_identity() {
    let state = crate::BackfillRunState::new();
    let runtime = cancellable_runtime("backfill-desk-41");
    assert!(runtime.is_some());
    let (job_id, request, runtime) = match runtime {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let installed = state.install(job_id.clone(), runtime.handle(), request);
    assert!(installed.is_ok());
    let first = state.cancel(job_id.as_str());
    assert!(first.is_ok());
    if let std::result::Result::Ok(first) = first {
        assert!(first.accepted);
        assert_eq!(first.state, "cancelling");
    }
    let repeated = state.cancel(job_id.as_str());
    assert!(repeated.is_ok());
    if let std::result::Result::Ok(repeated) = repeated {
        assert!(!repeated.accepted);
        assert_eq!(repeated.state, "cancelling");
    }
    let stale = state.cancel("backfill-desk-40");
    assert!(stale.is_err());
    if let std::result::Result::Err(error) = stale {
        assert_eq!(error.code().domain(), crate::ERROR_CODE_BACKFILL_RUN_MISMATCH.domain());
        assert_eq!(error.code().code(), crate::ERROR_CODE_BACKFILL_RUN_MISMATCH.code());
    }
}

#[test]
fn resume_requires_terminal_checkpoint_and_rejects_active_run() {
    let state = crate::BackfillRunState::new();
    let next = match ksp_job_api::JobId::new("backfill-desk-50") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let unavailable = state.resume_request(next.clone());
    assert!(unavailable.is_err());
    if let std::result::Result::Err(error) = unavailable {
        assert_eq!(error.code(), crate::ERROR_CODE_BACKFILL_RESUME_UNAVAILABLE);
    }
    let runtime = cancellable_runtime("backfill-desk-49");
    assert!(runtime.is_some());
    let (job_id, request, runtime) = match runtime {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let installed = state.install(job_id, runtime.handle(), request);
    assert!(installed.is_ok());
    let active = state.resume_request(next);
    assert!(active.is_err());
    if let std::result::Result::Err(error) = active {
        assert_eq!(error.code(), crate::ERROR_CODE_BACKFILL_RUN_ACTIVE);
    }
}