jelq

//! The resources under `/runs/{id}`.

use std::{convert::Infallible, fmt::Write as _};

use axum::{

    Json,

    body::{Body, Bytes},

    http::{StatusCode, header},

    response::{IntoResponse, Response},

};

use serde_json::{Value, json};

use super::{

    ctx::Ctx,

    resource::{Resource, Verb},

    response::respond,

    run::{Greeting, RunResource, Scope},

};

use crate::{

    game::{

        Cause, Floor, Grip, Item, LUBRICANTS, Lube, PatchOp, Run, Technique,

        balance::{EQ_BAND, MM_PER_INCH},

        shaft,

    },

    headers::ACCEPT_PATCH,

    problem::Problem,

};

const fn home(verbs: &'static [Verb<Run>]) -> RunResource {

    RunResource {

        scope: Scope::Home,

        resource: Resource::new(verbs),

    }

}

const fn pockets(verbs: &'static [Verb<Run>]) -> RunResource {

    RunResource {

        scope: Scope::Pockets,

        resource: Resource::new(verbs),

    }

}

fn not_in_clinic(run: &Run) -> bool {

    run.floor != Floor::Clinic

}

fn never(_: &Run) -> bool {

    false

}

fn unreachable_handler(_: &mut Run, _: &Ctx) -> Response {

    StatusCode::METHOD_NOT_ALLOWED.into_response()

}

pub static RUN: RunResource = RunResource {

    scope: Scope::Home,

    resource: Resource {

        verbs: &[

            Verb::new("GET", get_run),

            Verb::new("JELQ", jelq)

                .only_when(not_in_clinic, "JELQ is not performed in the clinic."),

            Verb::new("PUT", put_run),

            Verb::new("PATCH", patch_run),

            Verb::new("DELETE", delete_run),

            Verb::new("TRACE", trace_run),

        ],

        accept_patch: true,

    },

};

pub static LENGTH: RunResource = home(&[Verb::new("GET", get_length)]);

pub static FORESKIN: RunResource = home(&[

    Verb::new("GET", get_foreskin),

    Verb::new("DELETE", delete_foreskin),

]);

pub static INVENTORY: RunResource = pockets(&[Verb::new("GET", get_inventory)]);

pub static ITEM: RunResource =

    pockets(&[Verb::new("GET", get_item), Verb::new("DELETE", delete_item)]);

pub static TECHNIQUES: RunResource = home(&[Verb::new("GET", get_techniques)]);

pub static DRAWER: RunResource = home(&[Verb::new("POST", search_drawer)]);

pub static BRANCH: RunResource = home(&[Verb::new("POST", choose_branch)]);

pub static FLOOR: RunResource =

    pockets(&[Verb::new("GET", get_floor), Verb::new("POST", leave_floor)]);

pub static SHOP: RunResource = home(&[Verb::new("GET", get_shop)]);

pub static BUY: RunResource = home(&[Verb::new("POST", buy)]);

pub static PORTAL: RunResource = pockets(&[

    Verb::new("GET", get_portal),

    Verb::new("POST", accept_portal),

]);

pub static ELDER: RunResource = home(&[Verb::new("GET", get_elder)]);

pub static GRIP: RunResource = home(&[Verb::new("GET", get_grip)]);

pub static DIAGNOSIS: RunResource = pockets(&[Verb::new("GET", get_diagnosis)]);

pub static FOOTAGE: RunResource = pockets(&[

    Verb::new("GET", get_footage),

    Verb::new("DELETE", unreachable_handler).only_when(

        never,

        "The footage has been cached by intermediaries. It cannot be deleted.",

    ),

]);

fn get_run(run: &mut Run, ctx: &Ctx) -> Response {

    if ctx

        .header(header::ACCEPT)

        .is_some_and(|accept| 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()

}

fn parse_techniques(run: &Run, ctx: &Ctx) -> Result<Vec<Technique>, Problem> {

    let required = || {

        Problem::new(

            StatusCode::BAD_REQUEST,

            "technique-required",

            "No technique was specified.",

        )

        .with("techniques", run.path("/techniques"))

    };

    let names = ctx

        .query("technique")

        .filter(|n| !n.trim().is_empty())

        .ok_or_else(required)?;

    names

        .split(',')

        .map(str::trim)

        .filter(|n| !n.is_empty())

        .map(|name| {

            Technique::parse(name).ok_or_else(|| {

                Problem::new(

                    StatusCode::BAD_REQUEST,

                    "unknown-technique",

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

                )

                .with("techniques", run.path("/techniques"))

            })

        })

        .collect()

}

fn parse_intensity(ctx: &Ctx) -> Result<i32, Problem> {

    match ctx.query("intensity").map(str::parse::<i32>) {

        None => Ok(5),

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

        Some(_) => Err(Problem::new(

            StatusCode::BAD_REQUEST,

            "intensity-out-of-range",

            "Intensity is measured from 1 to 10.",

        )),

    }

}

fn jelq(run: &mut Run, ctx: &Ctx) -> Response {

    let parsed = parse_techniques(run, ctx).and_then(|techniques| {

        let intensity = parse_intensity(ctx)?;

        let lube = Lube::from_content_type(ctx.header(header::CONTENT_TYPE))?;

        Ok((techniques, intensity, lube))

    });

    match parsed {

        Ok((techniques, intensity, lube)) => {

            respond(run.jelq(&techniques, intensity, lube, ctx.now))

        }

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

    }

}

fn put_run(run: &mut Run, _: &Ctx) -> Response {

    run.put().into_response()

}

fn patch_run(run: &mut Run, ctx: &Ctx) -> Response {

    let is_patch = ctx

        .header(header::CONTENT_TYPE)

        .is_some_and(|ct| ct.starts_with("application/json-patch+json"));

    if !is_patch {

        return Problem::new(

            StatusCode::UNSUPPORTED_MEDIA_TYPE,

            "patch-format",

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

        )

        .header(ACCEPT_PATCH, "application/json-patch+json")

        .into_response();

    }

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

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

        Err(_) => Problem::new(

            StatusCode::BAD_REQUEST,

            "malformed-patch",

            "The patch could not be parsed.",

        )

        .into_response(),

    }

}

fn delete_run(run: &mut Run, _: &Ctx) -> Response {

    run.end(Cause::Abandoned);

    StatusCode::NO_CONTENT.into_response()

}

fn trace_run(run: &mut Run, ctx: &Ctx) -> Response {

    run.shame += 1;

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

    for (name, value) in &ctx.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 millimetres(inches: f64) -> usize {

    (inches * MM_PER_INCH).round() as usize

}

fn parse_inch_range(range: &str, total: f64) -> Option<(f64, f64)> {

    let (start, end) = range.strip_prefix("inches=")?.split_once('-')?;

    let start: f64 = start.trim().parse().ok()?;

    let end: f64 = match end.trim() {

        "" => total,

        end => end.parse().ok()?,

    };

    (start >= 0.0 && start < total && start <= end).then_some((start, end.min(total)))

}

fn get_length(run: &mut Run, ctx: &Ctx) -> Response {

    let inches = if run.items.ruler {

        run.current_length()

    } else {

        run.self_reported()

    };

    let body = shaft(millimetres(inches));

    let content_type = (

        header::CONTENT_TYPE,

        "text/plain; charset=us-ascii".to_owned(),

    );

    let accept_ranges = (header::ACCEPT_RANGES, "inches".to_owned());

    if let Some(range) = ctx.header(header::RANGE)

        && range.starts_with("inches=")

    {

        let Some((start, end)) = parse_inch_range(range, inches) else {

            return Problem::new(

                StatusCode::RANGE_NOT_SATISFIABLE,

                "range-not-satisfiable",

                format!("The requested range is not available. {inches:.2} inches are."),

            )

            .header(header::CONTENT_RANGE, format!("inches */{inches:.2}"))

            .into_response();

        };

        let from = millimetres(start).min(body.len() - 1);

        let to = millimetres(end).clamp(from + 1, body.len());

        let content_range = (

            header::CONTENT_RANGE,

            format!("inches {start:.2}-{end:.2}/{inches:.2}"),

        );

        return (

            StatusCode::PARTIAL_CONTENT,

            [content_type, accept_ranges, content_range],

            body[from..to].to_owned(),

        )

            .into_response();

    }

    if run.items.ruler {

        return (StatusCode::OK, [content_type, accept_ranges], body).into_response();

    }

    let chunks: Vec<Result<Bytes, Infallible>> = body

        .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, accept_ranges], body).into_response()

}

fn get_foreskin(run: &mut Run, _: &Ctx) -> Response {

    if run.foreskin.is_none() {

        return Problem::new(

            StatusCode::GONE,

            "foreskin-gone",

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

        )

        .into_response();

    }

    (StatusCode::NO_CONTENT, [(header::ETAG, run.etag())]).into_response()

}

fn delete_foreskin(run: &mut Run, ctx: &Ctx) -> Response {

    respond(run.delete_foreskin(ctx.header(header::IF_MATCH)))

}

fn get_inventory(run: &mut Run, _: &Ctx) -> Response {

    let items: Vec<Value> = run

        .items

        .owned()

        .into_iter()

        .map(|item| {

            json!({

                "name": item.slug(),

                "href": run.path(&format!("/inventory/{}", item.slug())),

            })

        })

        .collect();

    Json(json!({

        "items": items,

        "ice_packs": run.items.ice_packs,

        "supplements": run.items.supplements,

        "excuses": run.excuses(),

    }))

    .into_response()

}

fn owned_item(run: &Run, ctx: &Ctx) -> Result<Item, Problem> {

    Item::parse(ctx.param("item"))

        .filter(|&item| run.items.has(item))

        .ok_or_else(|| {

            Problem::new(

                StatusCode::NOT_FOUND,

                "no-such-item",

                "You do not have that.",

            )

        })

}

fn get_item(run: &mut Run, ctx: &Ctx) -> Response {

    match owned_item(run, ctx) {

        Ok(item) => {

            Json(json!({ "name": item.slug(), "description": item.description() })).into_response()

        }

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

    }

}

fn delete_item(run: &mut Run, ctx: &Ctx) -> Response {

    match owned_item(run, ctx) {

        Ok(item) => respond(run.drop_item(item)),

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

    }

}

fn get_techniques(run: &mut Run, _: &Ctx) -> Response {

    let listed: Vec<Value> = Technique::ALL

        .into_iter()

        .map(|t| t.describe(run.forum_read()))

        .collect();

    Json(json!({

        "usage": format!("JELQ {}?technique=<name>[,<name>]&intensity=<1-10>", run.path("")),

        "lubricant": "Declared with Content-Type.",

        "lubricants": LUBRICANTS,

        "eq_band": [EQ_BAND.start(), EQ_BAND.end()],

        "techniques": listed,

    }))

    .into_response()

}

fn search_drawer(run: &mut Run, _: &Ctx) -> Response {

    respond(run.search_drawer())

}

fn choose_branch(run: &mut Run, ctx: &Ctx) -> Response {

    respond(run.choose(ctx.param("choice")))

}

fn get_floor(run: &mut Run, _: &Ctx) -> Response {

    Json(run.floor_view()).into_response()

}

fn leave_floor(run: &mut Run, _: &Ctx) -> Response {

    respond(run.advance())

}

fn get_shop(run: &mut Run, _: &Ctx) -> Response {

    respond(run.shop_view().map(Json))

}

fn buy(run: &mut Run, ctx: &Ctx) -> Response {

    respond(run.buy(ctx.param("item")))

}

fn get_portal(run: &mut Run, _: &Ctx) -> Response {

    Json(json!({

        "terms": "By connecting you agree that the hotel is not responsible for anything that happens in this room, and that it does not want to know.",

        "accept": { "href": run.path("/portal"), "method": "POST" },

    }))

    .into_response()

}

fn accept_portal(run: &mut Run, _: &Ctx) -> Response {

    respond(run.accept_terms())

}

fn get_elder(run: &mut Run, ctx: &Ctx) -> Response {

    respond(run.elder(

        ctx.header(header::PROXY_AUTHORIZATION),

        ctx.header(header::IF_MODIFIED_SINCE),

    ))

}

fn requested_grip(ctx: &Ctx) -> Option<Grip> {

    let connection = ctx.header(header::CONNECTION)?.to_ascii_lowercase();

    if !connection.split(',').any(|token| token.trim() == "upgrade") {

        return None;

    }

    ctx.header(header::UPGRADE)?

        .split(',')

        .find_map(|protocol| Grip::parse(protocol.trim()))

}

fn get_grip(run: &mut Run, ctx: &Ctx) -> Response {

    if let Some(grip) = requested_grip(ctx) {

        run.set_grip(grip);

        let mut response = (

            StatusCode::SWITCHING_PROTOCOLS,

            [

                (header::UPGRADE, grip.name()),

                (header::CONNECTION, "upgrade"),

            ],

        )

            .into_response();

        response.extensions_mut().insert(Greeting(format!(

            "You are now jelqing {}.\r\n",

            grip.name()

        )));

        return response;

    }

    let detail = match ctx.header(header::UPGRADE) {

        Some(protocol) => {

            format!("The server does not know the {protocol} grip. Grips are protocols.")

        }

        None => "Grips are protocols. Change grip by upgrading the connection.".to_owned(),

    };

    (

        StatusCode::OK,

        [(header::UPGRADE, "overhand, underhand")],

        Json(json!({ "grip": run.grip.name(), "detail": detail })),

    )

        .into_response()

}

fn get_diagnosis(run: &mut Run, ctx: &Ctx) -> Response {

    respond(run.diagnose(

        ctx.header(header::AUTHORIZATION),

        ctx.header(header::IF_NONE_MATCH),

    ))

}

fn get_footage(run: &mut Run, _: &Ctx) -> Response {

    let Some((filmed, age)) = run.footage() else {