jelq

use std::{

    collections::HashMap,

    convert::Infallible,

    fmt::Write as _,

    io::Write as _,

    sync::{Arc, Mutex},

    time::Instant,

};

use axum::{

    Json, Router,

    body::{Body, Bytes},

    extract::{Path, Query, Request, State},

    http::{HeaderMap, HeaderName, HeaderValue, Method, StatusCode, Uri, Version, header},

    middleware::{self, Next},

    response::{IntoResponse, Response},

    routing::any,

};

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

use hyper_util::rt::TokioIo;

use rand::Rng;

use serde_json::{Value, json};

use tokio::io::AsyncWriteExt;

use crate::{

    game::{

        ELDER_LAST_MODIFIED, FORUM_THREAD, Floor, Grip, LUBRICANTS, Lube, MAX_STAMINA, MM_PER_INCH,

        PatchOp, RUN_ALLOW, Run, SUSPICION_LIMIT, Technique, forum_thread, shaft,

    },

    problem::{PROBLEM_BASE, Problem},

};

const REL_BASE: &str = "https://jelq.dev/rels/";

const COOKIE_ATTRIBUTES: &str = "Max-Age=31536000; Path=/; HttpOnly; SameSite=Strict";

const THERAPY: &str = "Your options are listed in the Allow header. There are more of them than you think. You could also try being honest. It is not in the Allow header because it is not a method.";

const MAX_URI: usize = 512;

const MAX_HEADER: usize = 1024;

#[derive(Default)]

pub struct AppState {

    runs: Mutex<HashMap<String, Run>>,

}

impl AppState {

    pub fn insert(&self, run: Run) {

        self.runs.lock().unwrap().insert(run.id.clone(), run);

    }

}

type Shared = Arc<AppState>;

#[derive(Clone)]

struct Compress;

/// Which household hazards stand between the request and the run.

#[derive(Clone, Copy, PartialEq, Eq)]

enum Scope {

    Home,

    Pockets,

}

pub fn app() -> Router {

    router(Arc::default())

}

pub fn router(state: Shared) -> Router {

    Router::new()

        .route("/runs", any(runs))

        .route("/runs/{id}", any(run))

        .route("/runs/{id}/length", any(length))

        .route("/runs/{id}/foreskin", any(foreskin))

        .route("/runs/{id}/inventory", any(inventory))

        .route("/runs/{id}/inventory/{item}", any(item))

        .route("/runs/{id}/techniques", any(techniques))

        .route("/runs/{id}/drawer", any(drawer))

        .route("/runs/{id}/branches/{choice}", any(branch))

        .route("/runs/{id}/floor", any(floor))

        .route("/runs/{id}/shop", any(shop))

        .route("/runs/{id}/shop/{item}", any(buy))

        .route("/runs/{id}/portal", any(portal))

        .route("/runs/{id}/elder", any(elder))

        .route("/runs/{id}/grip", any(grip))

        .route("/runs/{id}/diagnosis", any(diagnosis))

        .route("/forum/threads/{year}", any(thread))

        .route("/graveyard", any(graveyard))

        .route("/leaderboard", any(leaderboard))

        .fallback(not_found)

        .layer(middleware::from_fn(chrome))

        .with_state(state)

}

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());

    if encoder.write_all(&bytes).is_err() {

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

    }

    let Ok(gzipped) = encoder.finish() 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 chrome(request: Request, next: Next) -> Response {

    let gzip = header_str(request.headers(), header::ACCEPT_ENCODING)

        .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.insert(

        header::CACHE_CONTROL,

        HeaderValue::from_static("no-store, private"),

    );

    response

}

fn header_str(headers: &HeaderMap, name: HeaderName) -> Option<&str> {

    headers.get(name).and_then(|v| v.to_str().ok())

}

fn cookie<'a>(headers: &'a HeaderMap, name: &str) -> Option<&'a str> {

    headers

        .get_all(header::COOKIE)

        .iter()

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

        .flat_map(|v| v.split(';'))

        .filter_map(|pair| pair.trim().split_once('='))

        .find(|(key, _)| *key == name)

        .map(|(_, value)| value)

}

fn unsupported(method: &Method, allow: &'static str) -> Response {

    if *method == Method::CONNECT {

        return StatusCode::NOT_IMPLEMENTED.into_response();

    }

    let known = matches!(

        method.as_str(),

        "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "TRACE" | "JELQ"

    );

    if !known {

        return Problem::new(

            StatusCode::NOT_IMPLEMENTED,

            "not-implemented",

            format!("The server does not implement {method}."),

        )

        .into_response();

    }

    Problem::new(

        StatusCode::METHOD_NOT_ALLOWED,

        "method-not-allowed",

        format!("{method} is not supported here."),

    )

    .header(header::ALLOW, allow)

    .into_response()

}

fn options(allow: &'static str, patchable: bool) -> Response {

    let mut response = (

        StatusCode::OK,

        [(header::ALLOW, allow)],

        Json(json!({ "detail": THERAPY })),

    )

        .into_response();

    if patchable {

        response.headers_mut().insert(

            "accept-patch",

            HeaderValue::from_static("application/json-patch+json"),

        );

    }

    response

}

fn trace(method: &Method, uri: &Uri, version: Version, headers: &HeaderMap) -> Response {

    let mut message = format!("{method} {uri} {version:?}\r\n");

    for (name, value) in headers {

        let _ = write!(

            message,

            "{name}: {}\r\n",

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

        );

    }

    message.push_str("\r\n");

    (

        StatusCode::OK,

        [(header::CONTENT_TYPE, "message/http")],

        message,

    )

        .into_response()

}

fn links(run: &Run) -> String {

    let id = &run.id;

    let mut links = vec![format!("</runs/{id}>; rel=\"{REL_BASE}run\"")];

    for rel in [

        "floor",

        "length",

        "foreskin",

        "inventory",

        "techniques",

        "drawer",

        "grip",

        "diagnosis",

    ] {

        links.push(format!("</runs/{id}/{rel}>; rel=\"{REL_BASE}{rel}\""));

    }

    if run.floor.shop_open() {

        links.push(format!("</runs/{id}/shop>; rel=\"{REL_BASE}shop\""));

    }

    links.join(", ")

}

fn finish(run: &Run, mut response: Response) -> Response {

    let status = response.status();

    if status == StatusCode::NOT_MODIFIED {

        return response;

    }

    let mut stats = vec![

        (

            "x-self-reported-length",

            format!("{:.2}", run.self_reported()),

        ),

        ("x-girth", format!("{:.2}", run.girth)),

        (

            "x-foreskin",

            run.foreskin.map_or("gone".into(), |f| format!("{f:.2}")),

        ),

        ("x-eq", run.eq.to_string()),

        ("x-stamina", format!("{}/{MAX_STAMINA}", run.stamina)),

        (

            "x-suspicion",

            format!("{}/{SUSPICION_LIMIT}", run.suspicion),

        ),

        ("x-shame", run.total_shame().to_string()),

        ("x-cash", run.cash.to_string()),

        ("x-floor", run.floor.number().to_string()),

        ("link", links(run)),

    ];

    if let Some(observer) = run.observed {

        stats.push(("x-observed-by", observer.into()));

    }

    if run.mom_present {

        stats.push(("via", "1.1 mom".into()));

        stats.push(("vary", "Mom".into()));

    }

    // RFC 9111 obsoleted Warning, which is why nobody heeds it.

    if run.eq > 70 && run.ended.is_none() {

        stats.push(("warning", "199 - \"it is turning purple\"".into()));

    }

    stats.push((

        "set-cookie",

        format!("shame={}; {COOKIE_ATTRIBUTES}", run.total_shame()),

    ));

    if run.items.ruler {

        stats.push(("set-cookie", format!("ruler=1; {COOKIE_ATTRIBUTES}")));

    }

    let headers = response.headers_mut();

    for (name, value) in stats {

        headers.append(name, HeaderValue::from_str(&value).expect("visible ascii"));

    }

    let bodiless = status.is_informational() || status == StatusCode::NO_CONTENT;

    if run.items.ring && !bodiless {

        response.extensions_mut().insert(Compress);

    }

    response

}

fn gone(run: &Run) -> Response {

    let ending = run.ended.as_ref().expect("only called on ended runs");

    Problem::new(StatusCode::GONE, "run-ended", "This run has ended.")

        .with("cause", format!("{PROBLEM_BASE}{}", ending.cause))

        .with("turn", ending.turn)

        .with("graveyard", "/graveyard")

        .into_response()

}

fn captive_portal(run: &Run) -> Response {

    Problem::new(

        StatusCode::NETWORK_AUTHENTICATION_REQUIRED,

        "captive-portal",

        "The network requires authentication. The hotel would like you to agree to some terms.",

    )

    .with("portal", format!("/runs/{}/portal", run.id))

    .header(

        header::LINK,

        format!("</runs/{}/portal>; rel=\"{REL_BASE}portal\"", run.id),

    )

    .into_response()

}

fn with_run(

    state: &AppState,

    id: &str,

    headers: &HeaderMap,

    scope: Scope,

    handle: impl FnOnce(&mut Run) -> Response,

) -> Response {

    let mut runs = state.runs.lock().unwrap();

    let Some(run) = runs.get_mut(id) else {

        return Problem::new(

            StatusCode::NOT_FOUND,

            "no-such-run",

            format!("There is no run {id}. There may never have been."),

        )

        .into_response();

    };

    if run.ended.is_some() {

        return gone(run);

    }

    run.observed = None;

    if scope == Scope::Home {

        if run.floor == Floor::Hotel && !run.wifi_accepted {

            return finish(run, captive_portal(run));

        }

        if run.floor.has_mom()

            && run.mom_present

            && let Err(problem) = run.answer_door(header_str(headers, header::AUTHORIZATION))

        {

            return finish(run, problem.into_response());

        }

    }

    let response = handle(run);

    finish(run, response)

}

fn respond<T: IntoResponse, E: IntoResponse>(result: Result<T, E>) -> Response {

    match result {

        Ok(ok) => ok.into_response(),

        Err(err) => err.into_response(),

    }

}

async fn runs(

    State(state): State<Shared>,

    method: Method,

    Query(query): Query<HashMap<String, String>>,

    headers: HeaderMap,

) -> Response {

    if method != Method::POST {

        return unsupported(&method, "POST");

    }

    let seed = match query.get("seed").map(|s| s.parse::<u64>()) {

        None => rand::rng().random(),

        Some(Ok(seed)) => seed,

        Some(Err(_)) => {

            return Problem::new(

                StatusCode::BAD_REQUEST,

                "bad-seed",

                "The seed must be an unsigned 64-bit integer.",

            )

            .into_response();

        }

    };

    let shame = cookie(&headers, "shame")

        .and_then(|s| s.parse().ok())

        .unwrap_or(0);

    let id = format!("{:08x}", rand::rng().random::<u32>());

    let run = Run::new(id.clone(), seed, shame);

    let response = (

        StatusCode::CREATED,

        [

            (header::LOCATION, format!("/runs/{id}")),

            (header::ETAG, run.etag()),

            (HeaderName::from_static("x-seed"), seed.to_string()),

        ],

        Json(run.view()),

    )

        .into_response();

    let response = finish(&run, response);

    state.insert(run);

    response

}

#[allow(clippy::too_many_arguments)]

async fn run(

    State(state): State<Shared>,

    Path(id): Path<String>,

    method: Method,

    uri: Uri,

    version: Version,

    Query(query): Query<HashMap<String, String>>,

    headers: HeaderMap,

    body: Bytes,

) -> Response {

    let now = Instant::now();

    with_run(&state, &id, &headers, Scope::Home, |run| {

        match method.as_str() {

            "GET" | "HEAD" => {

                let accept = header_str(&headers, header::ACCEPT).unwrap_or_default();

                if accept.contains("reassurance") {

                    return Problem::new(

                        StatusCode::NOT_ACCEPTABLE,

                        "no-reassurance",

                        "The server does not produce reassurance.",

                    )

                    .into_response();

                }

                (

                    StatusCode::OK,

                    [(header::ETAG, run.etag())],

                    Json(run.view()),

                )

                    .into_response()

            }

            "JELQ" => jelq(run, &query, &headers, now),

            "PUT" => run.put().into_response(),

            "PATCH" => patch(run, &headers, &body),

            "DELETE" => {

                run.end("abandoned", "The run was abandoned.");

                StatusCode::NO_CONTENT.into_response()

            }

            "OPTIONS" => options(RUN_ALLOW, true),

            "TRACE" => {

                run.shame += 1;

                trace(&method, &uri, version, &headers)

            }

            _ => unsupported(&method, RUN_ALLOW),

        }

    })

}