use axum::{extract::State, routing::get, Router};
use prometheus::{Encoder, TextEncoder, Counter, Opts, Registry};
use std::sync::{Arc, Mutex};
use tokio::net::TcpListener;

struct AppState {
    registry: Registry,
    counter: Mutex<Counter>,
}

async fn metrics_handler(State(state): State<Arc<AppState>>) -> String {
    let encoder = TextEncoder::new();
    let mut buffer = Vec::new();
    let metric_families = state.registry.gather();
    encoder.encode(&metric_families, &mut buffer).unwrap();
    String::from_utf8(buffer).unwrap()
}

async fn increment_handler(State(state): State<Arc<AppState>>) -> &'static str {
    let mut counter = state.counter.lock().unwrap();
    counter.inc();
    "Counter incremented"
}

#[tokio::main]
async fn main() {
    let registry = Registry::new();
    let counter_opts = Opts::new("example_counter", "Пример счётчика");
    let counter = Counter::with_opts(counter_opts).unwrap();
    registry.register(Box::new(counter.clone())).unwrap();

    let state = Arc::new(AppState {
        registry,
        counter: Mutex::new(counter),
    });

    let app = Router::new()
        .route("/metrics", get(metrics_handler))
        .route("/increment", get(increment_handler))
        .with_state(state.clone());

    let listener = TcpListener::bind("0.0.0.0:8080").await.unwrap();
    // axum::Server::from_tcp(listener).unwrap().serve(app.into_make_service()).await.unwrap();
    // let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}