jelq

use std::{

    collections::HashMap,

    convert::Infallible,

    fmt::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 rand::Rng;

use serde_json::{Value, json};

use crate::{

    game::{

        EXCUSES, LUBRICANTS, Lube, MAX_STAMINA, MM_PER_INCH, PatchOp, Run, SUSPICION_LIMIT,

        Technique, 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.";

#[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>;

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}/diagnosis", any(diagnosis))

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

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

        .fallback(not_found)

        .layer(middleware::from_fn(chrome))

        .with_state(state)

}

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

    let mut response = next.run(request).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 [

        "length",

        "foreskin",

        "inventory",

        "techniques",

        "drawer",

        "diagnosis",

    ] {

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

    }

    links.join(", ")

}

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

    if response.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()),

        ("link", links(run)),

    ];

    if run.observed {

        stats.push(("x-observed-by", "cat".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.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"));

    }

    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 with_run(

    state: &AppState,

    id: &str,

    headers: &HeaderMap,

    mom_applies: bool,

    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 = false;

    if mom_applies

        && 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 {

    const ALLOW: &str = "GET, HEAD, JELQ, PUT, PATCH, DELETE, OPTIONS, TRACE";

    let now = Instant::now();

    with_run(&state, &id, &headers, true, |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(ALLOW, true),

        "TRACE" => {

            run.shame += 1;

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

        }

        _ => unsupported(&method, ALLOW),

    })

}

fn jelq(

    run: &mut Run,

    query: &HashMap<String, String>,

    headers: &HeaderMap,

    now: Instant,

) -> Response {

    let technique = match query.get("technique") {

        None => {

            return Problem::new(

                StatusCode::BAD_REQUEST,

                "technique-required",

                "No technique was specified.",

            )

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

            .into_response();

        }

        Some(name) => match Technique::parse(name) {

            Some(t) => t,

            None => {

                return Problem::new(

                    StatusCode::BAD_REQUEST,

                    "unknown-technique",

                    format!("{name} is not a technique."),

                )

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

                .into_response();

            }

        },

    };

    let intensity = match query.get("intensity").map(|i| i.parse::<i32>()) {

        None => 5,

        Some(Ok(i)) if (1..=10).contains(&i) => i,

        Some(_) => {

            return Problem::new(

                StatusCode::BAD_REQUEST,

                "intensity-out-of-range",

                "Intensity is measured from 1 to 10.",

            )

            .into_response();

        }

    };

    let lube = match Lube::from_content_type(header_str(headers, header::CONTENT_TYPE)) {

        Ok(lube) => lube,

        Err(problem) => return problem.into_response(),

    };

    respond(run.jelq(technique, intensity, lube, now))

}

fn patch(run: &mut Run, headers: &HeaderMap, body: &[u8]) -> Response {

    let content_type = header_str(headers, header::CONTENT_TYPE).unwrap_or_default();

    if !content_type.starts_with("application/json-patch+json") {

        return Problem::new(

            StatusCode::UNSUPPORTED_MEDIA_TYPE,

            "patch-format",

            "Patches are accepted as application/json-patch+json.",

        )

        .header(

            HeaderName::from_static("accept-patch"),

            "application/json-patch+json",

        )

        .into_response();

    }

    match serde_json::from_slice::<Vec<PatchOp>>(body) {

        Ok(ops) => respond(run.patch(&ops)),

        Err(_) => Problem::new(

            StatusCode::BAD_REQUEST,

            "malformed-patch",

            "The patch could not be parsed.",

        )

        .into_response(),

    }

}

async fn length(

    State(state): State<Shared>,

    Path(id): Path<String>,

    method: Method,

    headers: HeaderMap,

) -> Response {

    const ALLOW: &str = "GET, HEAD, OPTIONS";

    with_run(&state, &id, &headers, true, |run| match method.as_str() {

        "GET" | "HEAD" => {

            let content_type = [(header::CONTENT_TYPE, "text/plain; charset=us-ascii")];

            if run.ruler {

                let mm = (run.length * MM_PER_INCH).round() as usize;

                return (StatusCode::OK, content_type, shaft(mm)).into_response();

            }

            let mm = (run.self_reported() * MM_PER_INCH).round() as usize;

            let chunks: Vec<Result<Bytes, Infallible>> = shaft(mm)

                .into_bytes()

                .chunks(16)

                .map(|c| Ok(Bytes::copy_from_slice(c)))

                .collect();

            let body = Body::from_stream(futures_util::stream::iter(chunks));

            (StatusCode::OK, content_type, body).into_response()

        }

        "OPTIONS" => options(ALLOW, false),

        _ => unsupported(&method, ALLOW),

    })

}

async fn foreskin(

    State(state): State<Shared>,

    Path(id): Path<String>,

    method: Method,

    headers: HeaderMap,

) -> Response {

    const ALLOW: &str = "GET, HEAD, DELETE, OPTIONS";

    with_run(&state, &id, &headers, true, |run| match method.as_str() {

        "GET" | "HEAD" => match run.foreskin {

            Some(f) => (

                StatusCode::OK,

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

                Json(json!({ "foreskin": (f * 100.0).round() / 100.0 })),

            )

                .into_response(),

            None => Problem::new(

                StatusCode::GONE,

                "foreskin-gone",

                "The foreskin is gone. It will not be returning.",

            )

            .into_response(),

        },

        "DELETE" => respond(run.delete_foreskin(header_str(&headers, header::IF_MATCH))),