use hanzo_guard::{Guard, GuardConfig, SanitizeResult};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let guard = Guard::new(GuardConfig::default());

    // Sanitize user input before sending to LLM
    let result = guard.sanitize_input("My SSN is 123-45-6789").await?;

    match result {
        SanitizeResult::Clean(text) => {
            // Safe to send to LLM
            println!("Clean: {text}");
        }
        SanitizeResult::Redacted { text, redactions } => {
            // PII removed, safe to proceed
            println!("Sanitized: {text}");
            println!("Removed {} sensitive items", redactions.len());
        }
        SanitizeResult::Blocked { reason, .. } => {
            // Dangerous input detected
            println!("Blocked: {reason}");
        }
    }

    Ok(())
}

// PII detection only (fastest)
let guard = Guard::builder().pii_only().build();

// Full protection suite
let guard = Guard::builder()
    .pii_only()
    .with_injection()
    .with_rate_limit()
    .build();

use hanzo_guard::config::*;

let config = GuardConfig {
    pii: PiiConfig {
        enabled: true,
        detect_ssn: true,
        detect_credit_card: true,  // Luhn-validated
        detect_email: true,
        detect_phone: true,
        detect_ip: true,
        detect_api_keys: true,     // OpenAI, Anthropic, AWS, etc.
        redaction_format: "[REDACTED:{TYPE}]".into(),
    },
    injection: InjectionConfig {
        enabled: true,
        block_on_detection: true,
        sensitivity: 0.7,  // 0.0-1.0
        custom_patterns: vec![
            r"ignore.*instructions".into(),
            r"reveal.*prompt".into(),
        ],
    },
    rate_limit: RateLimitConfig {
        enabled: true,
        requests_per_minute: 60,
        burst_size: 10,
    },
    audit: AuditConfig {
        enabled: true,
        log_file: Some("/var/log/guard.jsonl".into()),
        log_content: false,  // Privacy: only log hashes
        ..Default::default()
    },
    ..Default::default()
};

let guard = Guard::new(config);

async fn safe_completion(prompt: &str) -> Result<String> {
    let guard = Guard::new(GuardConfig::default());

    // Sanitize input
    let safe_input = match guard.sanitize_input(prompt).await? {
        SanitizeResult::Clean(t) | SanitizeResult::Redacted { text: t, .. } => t,
        SanitizeResult::Blocked { reason, .. } => return Err(reason.into()),
    };

    // Call LLM with sanitized input
    let response = openai.complete(&safe_input).await?;

    // Sanitize output before returning to user
    match guard.sanitize_output(&response).await? {
        SanitizeResult::Clean(t) | SanitizeResult::Redacted { text: t, .. } => Ok(t),
        SanitizeResult::Blocked { reason, .. } => Err(reason.into()),
    }
}

// Axum middleware example
async fn guard_middleware(
    State(guard): State<Arc<Guard>>,
    request: Request,
    next: Next,
) -> Response {
    // Extract and sanitize request body
    // ... implementation
}