jelq

use std::io::Read as _;

use axum::{

    Json, Router,

    body::{Body, Bytes},

    extract::{Request, State},

    http::{HeaderMap, HeaderValue, Method, StatusCode, header},

    response::{Html, IntoResponse, Response},

};

use flate2::read::GzDecoder;

use serde::Deserialize;

use serde_json::json;

use tower::ServiceExt;

use super::resource::unsupported;

use crate::problem::{Problem, reason};

const BODY_LIMIT: usize = 64 * 1024;

const RESPONSE_LIMIT: usize = 1 << 20;

#[derive(Deserialize)]

struct Envelope {

    method: String,

    path: String,

    #[serde(default)]

    headers: Vec<(String, String)>,

}

pub async fn page(method: Method) -> Response {

    if method != Method::GET && method != Method::HEAD {

        return unsupported(&method, "GET, HEAD, OPTIONS");

    }

    Html(include_str!("../ui.html")).into_response()

}

fn bad_envelope(detail: &str) -> Response {

    Problem::new(StatusCode::BAD_REQUEST, "bad-envelope", detail).into_response()

}

fn decode(headers: &HeaderMap, bytes: Bytes) -> Vec<u8> {

    let gzipped = headers.get(header::CONTENT_ENCODING) == Some(&HeaderValue::from_static("gzip"));

    let mut decoded = Vec::new();

    if gzipped

        && GzDecoder::new(bytes.as_ref())

            .read_to_end(&mut decoded)

            .is_ok()

    {

        return decoded;

    }

    bytes.to_vec()

}

// Browsers hide 3xx responses from fetch and refuse TRACE, Upgrade, and Expect, so the page

// replays requests in-process to show the player exactly what the API said.

pub async fn send(State(api): State<Router>, headers: HeaderMap, body: Bytes) -> Response {

    if body.len() > BODY_LIMIT {

        return bad_envelope("The envelope is larger than any request the server would take.");

    }

    let Ok(envelope) = serde_json::from_slice::<Envelope>(&body) else {

        return bad_envelope("The envelope could not be parsed.");

    };

    if !envelope.path.starts_with('/') || envelope.path.starts_with("/ui") {

        return bad_envelope("The path must be an API path.");

    }

    let Ok(method) = Method::from_bytes(envelope.method.as_bytes()) else {

        return bad_envelope("That is not a method.");

    };

    let mut request = Request::builder().method(method).uri(&envelope.path);

    for (name, value) in envelope.headers.iter().filter(|(_, v)| !v.is_empty()) {

        request = request.header(name, value);

    }

    for cookie in headers.get_all(header::COOKIE) {

        request = request.header(header::COOKIE, cookie);

    }

    let Ok(request) = request.body(Body::empty()) else {

        return bad_envelope("The request could not be built. A header may be malformed.");

    };

    let Ok(response) = api.oneshot(request).await;

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

    let bytes = axum::body::to_bytes(body, RESPONSE_LIMIT)

        .await

        .unwrap_or_default();

    let shown = decode(&parts.headers, bytes);

    let listed: Vec<(String, String)> = parts

        .headers

        .iter()

        .map(|(name, value)| {

            (

                name.to_string(),

                value.to_str().unwrap_or("<binary>").to_owned(),

            )

        })

        .collect();

    let mut response = Json(json!({

        "status": parts.status.as_u16(),

        "reason": reason(parts.status),

        "headers": listed,

        "body": String::from_utf8_lossy(&shown),

    }))

    .into_response();

    for cookie in parts.headers.get_all(header::SET_COOKIE) {

        response

            .headers_mut()

            .append(header::SET_COOKIE, cookie.clone());

    }

    response

}