// CHECK: Input validation happens before any processing
fn check_correctness_example(input: &[f32]) -> Result<Vec<f32>, String> {
    // ✅ Validate first
    if input.is_empty() { return Err("empty input".into()); }
    if input.iter().any(|v| !v.is_finite()) { return Err("non-finite input".into()); }

    // ✅ Then compute
    Ok(input.iter().map(|x| x * 2.0).collect())
}

use std::sync::Arc;

// CHECK: Model weights are behind Arc, not cloned
struct GoodService {
    weights: Arc<Vec<f32>>,  // ✅ Shared reference
}

struct BadService {
    weights: Vec<f32>,       // ❌ Will be cloned per request if moved
}

// CHECK: Heavy compute is in spawn_blocking, not async fn
async fn good_handler(weights: Arc<Vec<f32>>, input: Vec<f32>) -> Vec<f32> {
    tokio::task::spawn_blocking(move || {  // ✅
        input.iter().zip(&*weights).map(|(x, w)| x * w).collect()
    }).await.unwrap()
}

use tokio::sync::Semaphore;
use std::sync::Arc;

// CHECK: Concurrency limit prevents thread exhaustion
struct InferenceService {
    semaphore: Arc<Semaphore>,  // ✅ Explicit concurrency control
}

// CHECK: No std::sync::Mutex held across await points
// ❌ BAD:
// async fn bad() {
//     let guard = std::sync::Mutex::new(0).lock().unwrap();
//     tokio::time::sleep(Duration::from_secs(1)).await;  // holding mutex!
//     drop(guard);
// }

// CHECK: Errors are typed, not stringly-typed
#[derive(Debug)]
enum InferError {
    Timeout,
    InvalidInput(String),
    ModelError(String),
}

// ✅ Typed error
fn infer(input: &[f32]) -> Result<Vec<f32>, InferError> {
    if input.is_empty() { return Err(InferError::InvalidInput("empty".into())); }
    Ok(input.iter().map(|x| x * 2.0).collect())
}

// ❌ Stringly-typed error
fn infer_bad(input: &[f32]) -> Result<Vec<f32>, String> {
    if input.is_empty() { return Err("empty input".into()); }
    Ok(input.iter().map(|x| x * 2.0).collect())
}

use std::sync::atomic::{AtomicU64, Ordering};
use std::time::Instant;

static REQUESTS_TOTAL: AtomicU64 = AtomicU64::new(0);
static ERRORS_TOTAL: AtomicU64 = AtomicU64::new(0);

fn with_metrics<F: FnOnce() -> Result<Vec<f32>, String>>(f: F) -> Result<Vec<f32>, String> {
    REQUESTS_TOTAL.fetch_add(1, Ordering::Relaxed);
    let start = Instant::now();
    let result = f();
    if result.is_err() { ERRORS_TOTAL.fetch_add(1, Ordering::Relaxed); }
    let _duration = start.elapsed();
    // In production: histogram!("inference_duration_ms", duration.as_millis())
    result
}