use admin_api::error::{
    execution_test_failure, execution_test_failure_localized, runtime_test_failure,
};
use crank_core::{CorrelationContext, ExecutionErrorCode, ExecutionFailure, ExecutionLocale};
use crank_runtime::RuntimeError;

#[test]
fn runtime_test_failure_includes_structured_context() {
    let payload = runtime_test_failure(&RuntimeError::InvalidPreparedRequest {
        field: "request.headers".to_owned(),
        reason: "must be an object".to_owned(),
    });

    assert_eq!(payload["code"], "prepared_request_invalid");
    assert_eq!(payload["stage"], "request_preparation");
    assert_eq!(payload["retryability"], "never");
    assert_eq!(payload["outcome_certainty"], "certain");
    assert!(payload.get("context").is_none());
}

#[test]
fn runtime_error_context_does_not_expose_secret_crypto_details() {
    let canary = "story18-secret-crypto-canary";
    let payload = runtime_test_failure(&RuntimeError::SecretCrypto {
        operation: "decode secret envelope",
        details: canary.to_owned(),
    });

    assert_eq!(payload["code"], "secret_invalid");
    assert!(!payload.to_string().contains(canary));
}

#[test]
fn runtime_test_failure_includes_runtime_overload_context() {
    let payload = runtime_test_failure(&RuntimeError::ConcurrencyLimitExceeded {
        kind: "window",
        limit: 16,
    });

    assert_eq!(payload["code"], "execution_overloaded");
    assert_eq!(payload["stage"], "admission");
    assert_eq!(payload["retryability"], "after_delay");
    assert!(payload.get("context").is_none());
}

#[test]
fn every_execution_code_projects_the_canonical_semantics_without_raw_context() {
    let canary = "story18-admin-projection-canary";
    for code in ExecutionErrorCode::ALL {
        let failure = ExecutionFailure::new(code, CorrelationContext::generate());
        let payload = execution_test_failure(&failure);
        assert_eq!(payload["code"], code.as_str());
        assert_eq!(payload["stage"], code.stage().as_str());
        assert_eq!(payload["retryability"], code.retryability().as_str());
        assert_eq!(
            payload["outcome_certainty"],
            code.outcome_certainty().as_str()
        );
        assert!(!payload["message"].as_str().unwrap_or_default().is_empty());
        assert!(!payload.to_string().contains(canary));
    }
}

#[test]
fn confirmation_challenge_is_bounded_and_localized_at_the_admin_boundary() {
    let failure = ExecutionFailure::new(
        ExecutionErrorCode::ConfirmationRequired,
        CorrelationContext::generate(),
    )
    .try_with_confirmation("confirmation-capability", 30_000)
    .unwrap();
    let payload = execution_test_failure_localized(&failure, ExecutionLocale::Ru);

    assert_eq!(payload["message"], "Операция требует подтверждения.");
    assert_eq!(
        payload["context"]["confirmation_token"],
        "confirmation-capability"
    );
    assert_eq!(payload["context"]["expires_in_ms"], 30_000);
    assert!(!format!("{failure:?}").contains("confirmation-capability"));
}