use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;

/// Global atomic performance counters.
#[derive(Debug, Default)]
pub struct PerfCounters {
    pub tokens_generated: AtomicU64,
    pub requests_completed: AtomicU64,
    pub requests_failed: AtomicU64,
    pub total_prompt_tokens: AtomicU64,
}

impl PerfCounters {
    pub fn new() -> Arc<Self> {
        Arc::new(Self::default())
    }

    pub fn inc_tokens(&self, n: u64) {
        self.tokens_generated.fetch_add(n, Ordering::Relaxed);
    }

    pub fn inc_completed(&self) {
        self.requests_completed.fetch_add(1, Ordering::Relaxed);
    }

    pub fn inc_failed(&self) {
        self.requests_failed.fetch_add(1, Ordering::Relaxed);
    }

    pub fn snapshot(&self) -> CountersSnapshot {
        CountersSnapshot {
            tokens_generated: self.tokens_generated.load(Ordering::Relaxed),
            requests_completed: self.requests_completed.load(Ordering::Relaxed),
            requests_failed: self.requests_failed.load(Ordering::Relaxed),
            total_prompt_tokens: self.total_prompt_tokens.load(Ordering::Relaxed),
        }
    }
}

#[derive(Debug, Clone, serde::Serialize)]
pub struct CountersSnapshot {
    pub tokens_generated: u64,
    pub requests_completed: u64,
    pub requests_failed: u64,
    pub total_prompt_tokens: u64,
}