jelq

use std::io::Write as _;

use axum::{

    body::Body,

    extract::Request,

    http::{HeaderValue, StatusCode, Version, header},

    middleware::Next,

    response::{IntoResponse, Response},

};

use flate2::{Compression, write::GzEncoder};

use crate::{headers::X_POWERED_BY, problem::Problem};

const MAX_URI: usize = 512;

const MAX_HEADER: usize = 1024;

/// Marks a response for gzip, which the cock ring asks for.

#[derive(Clone)]

pub struct Compress;

fn reject(request: &Request) -> Option<Problem> {

    if request.version() < Version::HTTP_11 {

        return Some(Problem::new(

            StatusCode::HTTP_VERSION_NOT_SUPPORTED,

            "pdf",

            "HTTP/1.0 is the version the original jelqing PDF was written for. The server has read it.",

        ));

    }

    if request.uri().to_string().len() > MAX_URI {

        return Some(Problem::new(

            StatusCode::URI_TOO_LONG,

            "uri-too-long",

            "The URI is longer than anything else here.",

        ));

    }

    if request.headers().values().any(|v| v.len() > MAX_HEADER) {

        return Some(Problem::new(

            StatusCode::REQUEST_HEADER_FIELDS_TOO_LARGE,

            "head-too-large",

            "Head too large.",

        ));

    }

    let expectation = request.headers().get(header::EXPECT)?;

    if expectation.as_bytes().eq_ignore_ascii_case(b"100-continue") {

        return None;

    }

    Some(Problem::new(

        StatusCode::EXPECTATION_FAILED,

        "expectations",

        format!(

            "Expect: {} cannot be met.",

            expectation.to_str().unwrap_or("that")

        ),

    ))

}

async fn compress(response: Response) -> Response {

    let (mut parts, body) = response.into_parts();

    let Ok(bytes) = axum::body::to_bytes(body, usize::MAX).await else {

        return Response::from_parts(parts, Body::empty());

    };

    let mut encoder = GzEncoder::new(Vec::new(), Compression::default());

    let gzipped = encoder.write_all(&bytes).and_then(|()| encoder.finish());

    let Ok(gzipped) = gzipped else {

        return Response::from_parts(parts, Body::from(bytes));

    };

    parts

        .headers

        .insert(header::CONTENT_ENCODING, HeaderValue::from_static("gzip"));

    parts.headers.remove(header::CONTENT_LENGTH);

    parts

        .headers

        .append(header::VARY, HeaderValue::from_static("Accept-Encoding"));

    Response::from_parts(parts, Body::from(gzipped))

}

pub async fn chrome(request: Request, next: Next) -> Response {

    let gzip = request

        .headers()

        .get(header::ACCEPT_ENCODING)

        .and_then(|v| v.to_str().ok())

        .is_some_and(|e| e.to_ascii_lowercase().contains("gzip"));

    let mut response = match reject(&request) {

        Some(problem) => problem.into_response(),

        None => next.run(request).await,

    };

    if gzip && response.extensions().get::<Compress>().is_some() {

        response = compress(response).await;

    }

    let headers = response.headers_mut();

    headers.insert(header::SERVER, HeaderValue::from_static("jelqd/0.6.9"));

    headers.insert(X_POWERED_BY, HeaderValue::from_static("blood"));

    headers

        .entry(header::CACHE_CONTROL)

        .or_insert(HeaderValue::from_static("no-store, private"));

    response

}