//! Extension pmoserver pour servir les fichiers du cache via HTTP
//!
//! Ce module fournit des handlers génériques pour servir les fichiers
//! d'un cache via des routes HTTP structurées, avec support du streaming progressif.
//!
//! ## Routes générées
//!
//! Format: `/{cache_name}/{cache_type}/{pk}[/{param}]`
//!
//! Exemples:
//! - `/covers/images/abc123` - Image avec param par défaut (orig)
//! - `/covers/images/abc123/256` - Image redimensionnée 256x256
//! - `/audio/tracks/def456` - Piste audio par défaut
//! - `/audio/tracks/def456/stream` - Piste audio streamable
//!
//! ## Streaming progressif
//!
//! Les fichiers en cours de téléchargement sont automatiquement streamés
//! au fur et à mesure de leur disponibilité.
//!
//! ## Utilisation
//!
//! ```rust,no_run
//! use pmocache::pmoserver_ext;
//! use axum::Router;
//!
//! # async fn example(cache: std::sync::Arc<pmocache::Cache<CoversConfig>>) {
//! // Créer un router pour servir les fichiers
//! let router = pmoserver_ext::create_file_router(
//!     cache.clone(),
//!     "image/webp"  // Content-Type
//! );
//!
//! // Le router sera monté à la racine avec les routes complètes
//! // Exemple: GET /covers/images/{pk}
//! //          GET /covers/images/{pk}/{param}
//! # }
//! ```

#[cfg(feature = "pmoserver")]
use crate::{Cache, CacheConfig};
#[cfg(feature = "pmoserver")]
use axum::{
    body::Body,
    extract::{Path, State},
    http::StatusCode,
    response::{IntoResponse, Response},
    routing::{get, post},
    Router,
};
#[cfg(feature = "pmoserver")]
use std::future::Future;
#[cfg(feature = "pmoserver")]
use std::pin::Pin;
#[cfg(feature = "pmoserver")]
use std::sync::Arc;
#[cfg(feature = "pmoserver")]
use tokio_util::io::ReaderStream;
#[cfg(feature = "pmoserver")]
use tracing::warn;

/// Type pour le callback de génération de param
///
/// Appelé quand un fichier avec param n'existe pas.
/// Permet de générer à la volée (ex: redimensionnement d'images).
///
/// # Arguments
///
/// - `cache`: le cache
/// - `pk`: clé primaire
/// - `param`: paramètre demandé (ex: "256" pour une taille)
///
/// # Retourne
///
/// Les données générées ou None si le param n'est pas supporté
#[cfg(feature = "pmoserver")]
pub type ParamGenerator<C> = Arc<
    dyn Fn(Arc<Cache<C>>, String, String) -> Pin<Box<dyn Future<Output = Option<Vec<u8>>> + Send>>
        + Send
        + Sync,
>;

/// Handler générique pour GET /{cache_name}/{cache_type}/{pk}
/// Sert un fichier avec le param par défaut
#[cfg(feature = "pmoserver")]
async fn get_file<C: CacheConfig + 'static>(
    State((cache, content_type, param_generator)): State<(
        Arc<Cache<C>>,
        &'static str,
        Option<ParamGenerator<C>>,
    )>,
    Path(pk): Path<String>,
) -> Response {
    // Utiliser le param par défaut
    let param = C::default_param();
    serve_file_with_streaming(&cache, &pk, param, content_type, param_generator).await
}

/// Handler générique pour GET /{cache_name}/{cache_type}/{pk}/{param}
/// Sert un fichier avec un param spécifique
#[cfg(feature = "pmoserver")]
async fn get_file_with_param<C: CacheConfig + 'static>(
    State((cache, content_type, param_generator)): State<(
        Arc<Cache<C>>,
        &'static str,
        Option<ParamGenerator<C>>,
    )>,
    Path((pk, param)): Path<(String, String)>,
) -> Response {
    serve_file_with_streaming(&cache, &pk, &param, content_type, param_generator).await
}

/// Handler spécifique pour les lazy PK
///
/// Gère le téléchargement on-demand des fichiers lazy :
/// 1. Fast path : vérifie si déjà téléchargé
/// 2. Récupère l'origin_url depuis la DB
/// 3. Lance le téléchargement et calcule le real pk
/// 4. Met à jour la DB (lazy → downloaded)
/// 5. Broadcast l'event pour PK switching
/// 6. Redirige vers le real pk
#[cfg(feature = "pmoserver")]
async fn serve_lazy_audio_file<C: CacheConfig>(
    cache: &Arc<Cache<C>>,
    lazy_pk: &str,
    param: &str,
    content_type: &'static str,
) -> Response {
    use axum::response::Redirect;

    tracing::info!("Lazy download triggered for pk: {}", lazy_pk);

    // 1. Vérifier si déjà téléchargé (fast path)
    if let Ok(Some(real_pk)) = cache.db.get_pk_by_lazy_pk(lazy_pk) {
        tracing::debug!(
            "Lazy PK {} already downloaded as {}, redirecting",
            lazy_pk,
            real_pk
        );

        // Construire l'URL de redirection
        let redirect_url = if param == C::default_param() {
            format!(
                "/{}/{}/{}",
                C::cache_name(),
                C::cache_type(),
                real_pk
            )
        } else {
            format!(
                "/{}/{}/{}/{}",
                C::cache_name(),
                C::cache_type(),
                real_pk,
                param
            )
        };

        return Redirect::temporary(&redirect_url).into_response();
    }

    // 2. Récupérer origin_url
    let origin_url = match cache.db.get_origin_url(lazy_pk) {
        Ok(Some(url)) => url,
        Ok(None) => {
            tracing::error!("Lazy PK {} has no origin_url", lazy_pk);
            return (StatusCode::NOT_FOUND, "Origin URL not found").into_response();
        }
        Err(e) => {
            tracing::error!("Error getting origin_url for {}: {}", lazy_pk, e);
            return (StatusCode::INTERNAL_SERVER_ERROR, "Database error").into_response();
        }
    };

    // 3. Lancer download complet (cela calcule le VRAI pk basé sur content[512:2048])
    let real_pk = match cache.add_from_url(&origin_url, None).await {
        Ok(pk) => pk,
        Err(e) => {
            tracing::error!("Failed to download lazy file: {}", e);
            return (
                StatusCode::INTERNAL_SERVER_ERROR,
                format!("Download failed: {}", e),
            )
                .into_response();
        }
    };

    // 4. Mettre à jour DB : lazy_pk → real_pk mapping
    if let Err(e) = cache.db.update_lazy_to_downloaded(lazy_pk, &real_pk) {
        tracing::error!(
            "Failed to update DB for lazy transition {} → {}: {}",
            lazy_pk,
            real_pk,
            e
        );
        // Continuer quand même, le fichier est téléchargé
    }

    // 5. Broadcast event pour prefetch ET commutation PK
    cache.broadcast_lazy_downloaded(lazy_pk, &real_pk).await;

    // 6. Rediriger vers la vraie URL
    let redirect_url = if param == C::default_param() {
        format!(
            "/{}/{}/{}",
            C::cache_name(),
            C::cache_type(),
            real_pk
        )
    } else {
        format!(
            "/{}/{}/{}/{}",
            C::cache_name(),
            C::cache_type(),
            real_pk,
            param
        )
    };

    tracing::debug!(
        "Lazy PK {} downloaded as {}, redirecting to {}",
        lazy_pk,
        real_pk,
        redirect_url
    );

    Redirect::temporary(&redirect_url).into_response()
}

/// Fonction utilitaire pour servir un fichier avec streaming progressif
///
/// Si le fichier est en cours de téléchargement, il est streamé au fur et à mesure.
/// Sinon, le fichier complet est servi normalement.
/// Si le fichier n'existe pas et qu'un param_generator est fourni, tente de générer le param.
#[cfg(feature = "pmoserver")]
async fn serve_file_with_streaming<C: CacheConfig>(
    cache: &Arc<Cache<C>>,
    pk: &str,
    param: &str,
    content_type: &'static str,
    param_generator: Option<ParamGenerator<C>>,
) -> Response {
    // LAZY PK SUPPORT: Détecter si c'est un lazy PK
    if crate::cache::is_lazy_pk(pk) {
        return serve_lazy_audio_file(cache, pk, param, content_type).await;
    }

    let file_path = cache.get_file_path_with_qualifier(pk, param);
    let qualifier = param.to_string();

    // Si le fichier n'existe pas et qu'on a un générateur, l'utiliser
    if !file_path.exists() {
        if let Some(generator) = param_generator {
            if let Some(data) = generator(cache.clone(), pk.to_string(), param.to_string()).await {
                // Le générateur a créé les données, les servir directement
                let response =
                    (StatusCode::OK, [("content-type", content_type)], data).into_response();

                if response.status().is_success() {
                    cache.notify_broadcast(pk, &qualifier).await;
                }

                return response;
            }
        }
    }

    // Mettre à jour les stats d'utilisation
    if let Err(e) = cache.db.update_hit(pk) {
        warn!("Error updating hit count for {}: {}", pk, e);
    }

    // Vérifier si le download est en cours
    if let Some(download) = cache.get_download(pk).await {
        // Le fichier est en cours de téléchargement
        if !download.finished().await {
            // Streaming progressif
            let response = stream_file_progressive(file_path, download, content_type).await;

            if response.status().is_success() {
                cache.notify_broadcast(pk, &qualifier).await;
            }

            return response;
        }
    }

    // Fichier terminé ou pas de download en cours, servir normalement
    let response = serve_complete_file(file_path, content_type).await;

    if response.status().is_success() {
        cache.notify_broadcast(pk, &qualifier).await;
    }

    response
}

/// Stream un fichier en cours de téléchargement de manière progressive
#[cfg(feature = "pmoserver")]
async fn stream_file_progressive(
    file_path: std::path::PathBuf,
    download: Arc<crate::download::Download>,
    content_type: &'static str,
) -> Response {
    // Attendre qu'au moins 64 KB soient disponibles avant de commencer
    const MIN_SIZE_TO_START: u64 = 64 * 1024;

    if let Err(e) = download.wait_until_min_size(MIN_SIZE_TO_START).await {
        warn!("Error waiting for download to start: {}", e);
        if let Some(error_msg) = download.error().await {
            return (
                StatusCode::INTERNAL_SERVER_ERROR,
                format!("Download error: {}", error_msg),
            )
                .into_response();
        }
        return (StatusCode::NOT_FOUND, "File not available").into_response();
    }

    // Ouvrir le fichier en lecture
    let file = match tokio::fs::File::open(&file_path).await {
        Ok(f) => f,
        Err(e) => {
            warn!("Error opening file {:?}: {}", file_path, e);
            return (StatusCode::NOT_FOUND, "File not found").into_response();
        }
    };

    // Créer un stream à partir du fichier
    let stream = ReaderStream::new(file);
    let body = Body::from_stream(stream);

    (
        StatusCode::OK,
        [
            ("content-type", content_type),
            ("transfer-encoding", "chunked"),
        ],
        body,
    )
        .into_response()
}

/// Sert un fichier complet déjà téléchargé
#[cfg(feature = "pmoserver")]
async fn serve_complete_file(
    file_path: std::path::PathBuf,
    content_type: &'static str,
) -> Response {
    if !file_path.exists() {
        warn!("File not found: {:?}", file_path);
        return (StatusCode::NOT_FOUND, "File not found").into_response();
    }

    match tokio::fs::read(&file_path).await {
        Ok(data) => (StatusCode::OK, [("content-type", content_type)], data).into_response(),
        Err(e) => {
            warn!("Error reading file {:?}: {}", file_path, e);
            (StatusCode::INTERNAL_SERVER_ERROR, "Error reading file").into_response()
        }
    }
}

/// Crée un router pour servir les fichiers d'un cache
///
/// Crée un router avec les routes complètes incluant cache_name et cache_type.
///
/// # Arguments
///
/// * `cache` - Instance du cache
/// * `content_type` - Type MIME des fichiers (ex: "image/webp", "audio/flac")
///
/// # Routes créées
///
/// - `GET /{cache_name}/{cache_type}/{pk}` - Fichier avec param par défaut
/// - `GET /{cache_name}/{cache_type}/{pk}/{param}` - Fichier avec param spécifique
///
/// # Exemple
///
/// ```rust,no_run
/// use pmocache::pmoserver_ext;
/// use axum::Router;
/// use pmoserver::Server;
///
/// # async fn example(server: &mut Server, cache: std::sync::Arc<pmocache::Cache<CoversConfig>>) {
/// let router = pmoserver_ext::create_file_router(
///     cache.clone(),
///     "image/webp"
/// );
///
/// // Le router sera monté à la racine avec les routes complètes:
/// // GET /covers/images/{pk}
/// // GET /covers/images/{pk}/{param}
/// server.add_router("/", router).await;
/// # }
/// ```
#[cfg(feature = "pmoserver")]
pub fn create_file_router<C: CacheConfig + 'static>(
    cache: Arc<Cache<C>>,
    content_type: &'static str,
) -> Router {
    create_file_router_with_generator(cache, content_type, None)
}

/// Crée un router pour servir les fichiers d'un cache avec générateur de param
///
/// Similaire à `create_file_router` mais permet de fournir un générateur
/// pour créer des variantes à la volée (ex: redimensionnement d'images).
///
/// # Arguments
///
/// * `cache` - Instance du cache
/// * `content_type` - Type MIME des fichiers (ex: "image/webp", "audio/flac")
/// * `param_generator` - Générateur optionnel pour créer des params à la volée
///
/// # Exemple
///
/// ```rust,no_run
/// use pmocache::pmoserver_ext::{create_file_router_with_generator, ParamGenerator};
/// use std::sync::Arc;
///
/// # async fn example(cache: std::sync::Arc<pmocache::Cache<CoversConfig>>) {
/// let generator: ParamGenerator<CoversConfig> = Arc::new(|cache, pk, param| {
///     Box::pin(async move {
///         // Générer une variante si param est numérique
///         if let Ok(size) = param.parse::<usize>() {
///             // Générer et retourner les données
///             Some(vec![])
///         } else {
///             None
///         }
///     })
/// });
///
/// let router = create_file_router_with_generator(
///     cache.clone(),
///     "image/webp",
///     Some(generator)
/// );
/// # }
/// ```
#[cfg(feature = "pmoserver")]
pub fn create_file_router_with_generator<C: CacheConfig + 'static>(
    cache: Arc<Cache<C>>,
    content_type: &'static str,
    param_generator: Option<ParamGenerator<C>>,
) -> Router {
    let cache_name = C::cache_name();
    let cache_type = C::cache_type();

    let path_with_param = format!("/{}/{}/{{pk}}/{{param}}", cache_name, cache_type);
    let path_without_param = format!("/{}/{}/{{pk}}", cache_name, cache_type);

    Router::new()
        .route(&path_without_param, get(get_file::<C>))
        .route(&path_with_param, get(get_file_with_param::<C>))
        .with_state((cache, content_type, param_generator))
}

/// Crée un router pour l'API REST du cache
///
/// # Arguments
///
/// * `cache` - Instance du cache
///
/// # Routes créées
///
/// - `GET /` - Liste des items
/// - `POST /` - Ajouter un item
/// - `DELETE /` - Purger le cache
/// - `GET /{pk}` - Info d'un item
/// - `GET /{pk}/status` - Status du download
/// - `DELETE /{pk}` - Supprimer un item
/// - `POST /consolidate` - Consolider le cache
#[cfg(feature = "pmoserver")]
pub fn create_api_router<C: CacheConfig + 'static>(cache: Arc<Cache<C>>) -> Router {
    use crate::api;

    Router::new()
        .route(
            "/",
            get(api::list_items::<C>)
                .post(api::add_item::<C>)
                .delete(api::purge_cache::<C>),
        )
        .route(
            "/{pk}",
            get(api::get_item_info::<C>).delete(api::delete_item::<C>),
        )
        .route("/{pk}/status", get(api::get_download_status::<C>))
        .route("/consolidate", post(api::consolidate_cache::<C>))
        .with_state(cache)
}

/// Trait d'extension pour pmoserver::Server
///
/// Permet d'initialiser un cache générique avec routes HTTP complètes
#[cfg(feature = "pmoserver")]
pub trait GenericCacheExt {
    /// Initialise un cache générique avec routes complètes
    ///
    /// # Arguments
    ///
    /// * `cache_dir` - Répertoire de stockage du cache
    /// * `limit` - Limite de taille du cache (nombre d'éléments)
    /// * `content_type` - Type MIME des fichiers (ex: "image/webp", "audio/flac")
    ///
    /// # Routes créées
    ///
    /// - Fichiers: `/{cache_name}/{cache_type}/{pk}[/{param}]`
    /// - API: `/api/{cache_name}/*`
    /// - Swagger: `/swagger-ui/{cache_name}`
    async fn init_generic_cache<C: CacheConfig + 'static>(
        &mut self,
        cache_dir: &str,
        limit: usize,
        content_type: &'static str,
    ) -> anyhow::Result<Arc<Cache<C>>>;
}