use axum::{
    extract::State,
    http::Request,
    middleware::Next,
    response::Response,
};
use std::time::Instant;
use uuid::Uuid;

use crate::app::AppState;
use crate::network::http::context::{CurrentUser, RequestContext};

pub async fn context_middleware(
    State(app_state): State<AppState>,
    mut req: Request<axum::body::Body>,
    next: Next,
) -> Response {
    let request_id = Uuid::new_v4();
    let started_at = Instant::now();

    // Infos "type Django request"
    let method = req.method().clone();
    let uri = req.uri().clone();

    // Exemple: récupérer un user depuis un token (pseudo-code)
    // Ici je laisse volontairement une logique minimaliste/placeholder.
    // Le but: montrer où tu branches ta vraie auth.
    let user: Option<CurrentUser> = {
        let _maybe_auth = req
            .headers()
            .get(axum::http::header::AUTHORIZATION)
            .and_then(|v| v.to_str().ok());

        // TODO: vérifier token -> user_id -> charger en DB avec app_state
        // Some(CurrentUser { id: ..., username: ... })
        None
    };

    // Injecte le contexte dans la requête
    req.extensions_mut().insert(RequestContext {
        request_id,
        started_at,
        method: method.clone(),
        uri: uri.clone(),
        user,
    });

    println!(">>> Incoming [{}] {} {}", request_id, method, uri);

    // Passe la requête au reste de la stack
    let resp = next.run(req).await;

    println!("<<< Response [{}]: {}", request_id, resp.status());

    resp
}