use axum::body::Body;
use axum::extract::{Path, Query, State};
use axum::http::{StatusCode, header};
use axum::response::Response;

use crate::handler::html::error::html_err;
use crate::handler::html::{HtmlRepoPath, resolve_view};
use crate::service::GitService;
use crate::service::pdf;
use crate::share::access::BasicAuth;

#[derive(Debug, Clone, serde::Deserialize, utoipa::IntoParams)]
pub struct BlobPagesQuery {
    #[serde(default)]
    pub revision: Option<String>,
    #[serde(default)]
    pub path: Option<String>,
    /// Rasterisation scale: 1.0 is 72 dpi. Clamped to 0.5..=3.0.
    #[serde(default)]
    pub scale: Option<f32>,
}

/// Rasterised pages of a PDF, streamed one page at a time.
///
/// Framing: repeating `u32 header_len | header | u32 payload_len | payload`,
/// all big-endian. The header is JSON — `{page,total,width,height}` per page,
/// `{page,total,error}` for a page that failed, `{total,done}` to close — and
/// the payload of a page frame is its PNG bytes. Streaming (rather than one
/// request per page) is what keeps the first page instant while the rest of a
/// long document is still being rasterised.
#[utoipa::path(
    get,
    path = "/repos/{space_name}/{repo_name}/html/blob-pages",
    tag = "html",
    description = "按页栅格化 PDF 并以分帧流式返回 PNG，供文件页阅读器使用。",
    operation_id = "render_blob_pages",
    params(HtmlRepoPath, BlobPagesQuery),
    responses(
        (status = 200, description = "framed png page stream"),
        (status = 404, description = "repo, ref or blob not found"),
        (status = 400, description = "blob is not a readable pdf")
    )
)]
pub async fn render_blob_pages(
    State(service): State<GitService>,
    Path(path): Path<HtmlRepoPath>,
    Query(q): Query<BlobPagesQuery>,
    auth: BasicAuth,
) -> Response {
    let view = match resolve_view(service.clone(), path, auth, q.revision, q.path, true).await {
        Ok(v) => v,
        Err(resp) => return resp,
    };
    let ctx = view.ctx;
    let scale = pdf::clamp_scale(q.scale);
    let receiver = match pdf::render_stream(
        &service,
        &ctx.space_name,
        &ctx.repo_name,
        &view.revision,
        &view.clean_path,
        scale,
    )
    .await
    {
        Ok(rx) => rx,
        Err(crate::share::errors::GitError::NotFound) => return html_err(404, "blob not found"),
        Err(e) => {
            tracing::warn!(error = %e, "pdf page stream rejected");
            return html_err(400, "blob is not a readable pdf");
        }
    };

    let stream = futures::stream::unfold(receiver, |mut rx| async move {
        rx.recv()
            .await
            .map(|chunk| (Ok::<Vec<u8>, std::io::Error>(chunk), rx))
    });
    let mut resp = Response::new(Body::from_stream(stream));
    *resp.status_mut() = StatusCode::OK;
    let headers = resp.headers_mut();
    headers.insert(
        header::CONTENT_TYPE,
        "application/octet-stream".parse().unwrap(),
    );
    headers.insert(header::CACHE_CONTROL, "private, no-store".parse().unwrap());
    headers.insert(header::VARY, "Cookie".parse().unwrap());
    // Reverse proxies must hand each frame through as it is produced, otherwise
    // the streaming reader degrades into a spinner until the document ends.
    headers.insert("x-accel-buffering", "no".parse().unwrap());
    resp
}