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 serde_json::Value;

use crate::{

    headers::{X_OBSERVED_BY, X_POWERED_BY},

    locale::Locale,

    problem::Problem,

};

const MAX_URI: usize = 512;

const MAX_HEADER: usize = 1024;

const MAX_HEADERS: usize = 64;

/// Responses are re-read to be translated or gzipped. The listings are paged, so none comes close.

const BUFFER_LIMIT: usize = 1 << 20;

/// 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.",

        ));

    }

    let headers = request.headers();

    let oversized = headers

        .iter()

        .any(|(name, value)| name.as_str().len() + value.len() > MAX_HEADER);

    if oversized || headers.len() > MAX_HEADERS {

        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 compressible = response

        .headers()

        .get(header::CONTENT_TYPE)

        .and_then(|value| value.to_str().ok())

        .is_some_and(|type_| {

            type_.starts_with("application/json")

                || type_.starts_with("application/problem+json")

                || type_.starts_with("application/xml")

        });

    if !compressible {

        return response;

    }

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

    let Ok(bytes) = axum::body::to_bytes(body, BUFFER_LIMIT).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))

}

async fn localise(response: Response, locale: Locale) -> Response {

    if locale == Locale::British {

        return response;

    }

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

    for name in [header::VIA, header::VARY, X_OBSERVED_BY] {

        let localised: Vec<HeaderValue> = parts

            .headers

            .get_all(&name)

            .iter()

            .filter_map(|v| v.to_str().ok())

            .filter_map(|v| HeaderValue::from_str(&locale.localise(v)).ok())

            .collect();

        if !localised.is_empty() {

            parts.headers.remove(&name);

            for value in localised {

                parts.headers.append(name.clone(), value);

            }

        }

    }

    let json = parts

        .headers

        .get(header::CONTENT_TYPE)

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

        .is_some_and(|ct| {

            ct.starts_with("application/json") || ct.starts_with("application/problem+json")

        });

    if !json || parts.status == StatusCode::PARTIAL_CONTENT {

        return Response::from_parts(parts, body);

    }

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

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

    };

    let Ok(mut value) = serde_json::from_slice::<Value>(&bytes) else {

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

    };

    locale.localise_json(&mut value);

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

    Response::from_parts(parts, Body::from(value.to_string()))

}

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

    let (gzip, locale) = {

        let header_text = |name| {

            request

                .headers()

                .get(name)

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

                .map(str::to_owned)

        };

        let gzip = header_text(header::ACCEPT_ENCODING)

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

        let locale = Locale::negotiate(header_text(header::ACCEPT_LANGUAGE).as_deref());

        (gzip, locale)

    };

    let response = match reject(&request) {

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

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

    };

    let mut response = localise(response, locale).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.insert(

        header::CONTENT_LANGUAGE,

        HeaderValue::from_static(locale.tag()),

    );

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

    headers

        .entry(header::CACHE_CONTROL)

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

    response

}

/// A handler panic would otherwise drop the connection with no reply at all.

pub fn panicked(_: Box<dyn std::any::Any + Send + 'static>) -> Response {

    Problem::new(

        StatusCode::INTERNAL_SERVER_ERROR,

        "server-fault",

        "The server has had an internal event of its own. It is not discussing it.",

    )

    .into_response()

}