jelq

//! Plumbing shared by every resource under `/runs/{id}`.

use axum::{

    http::{HeaderName, HeaderValue, StatusCode, header},

    response::{IntoResponse, Response},

};

use hyper_util::rt::TokioIo;

use tokio::io::AsyncWriteExt;

use super::{

    AppState, ctx::Ctx, meta, middleware::Compress, registry::hold, resource::Resource, runs,

};

use crate::{

    game::{

        Elder, FORUM_THREAD, Floor, Run, SHOP, Story,

        balance::{FRICTION_MAX, KITCHEN_TELLINGS, SUSPICION_LIMIT},

    },

    headers::{

        X_CASH, X_EQ, X_FLOOR, X_FORESKIN, X_FRICTION, X_GIRTH, X_LENGTH, X_OBSERVED_BY,

        X_SELF_REPORTED_LENGTH, X_SHAME, X_STAMINA, X_SUSPICION,

    },

    locale::Locale,

    problem::{PROBLEM_BASE, Problem},

    records::Record,

    secret::Secret,

};

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

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

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

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

pub enum Scope {

    Home,

    Pockets,

}

pub struct RunResource {

    pub scope: Scope,

    pub resource: Resource<Run>,

}

/// What the server writes over the connection after a `101`.

#[derive(Clone)]

pub struct Greeting(pub String);

pub fn serve(state: &AppState, mut ctx: Ctx, target: &RunResource) -> Response {

    let id = ctx.param("id").to_owned();

    let Some(slot) = state.runs.get(&id) else {

        return match state.records.find(&id) {

            Some(Record {

                ending: Some(ending),

                turn,

                ..

            }) => gone(&ending.cause, turn),

            _ => Problem::new(

                StatusCode::NOT_FOUND,

                "no-such-run",

                "There is no such run. There may never have been.",

            )

            .into_response(),

        };

    };

    let mut guard = hold(&slot);

    let run = &mut *guard;

    if let Some(ending) = &run.ended {

        return gone(ending.cause.slug(), ending.turn);

    }

    run.last_seen = ctx.now;

    run.observed = None;

    let response =

        gate(run, &ctx, target.scope).unwrap_or_else(|| target.resource.dispatch(run, &ctx));

    let response = finish(run, &ctx, &state.config.secret, response);

    if run.ended.is_some() || run.clinic.cured {

        state.records.save(&Record::of(run));

    }

    let ended = run.ended.is_some();

    drop(guard);

    if ended {

        state.runs.remove(&id);

    }

    greet(response, &mut ctx)

}

fn gone(cause: &str, turn: u32) -> Response {

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

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

        .with("turn", turn)

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

        .into_response()

}

fn gate(run: &mut Run, ctx: &Ctx, scope: Scope) -> Option<Response> {

    if scope == Scope::Pockets {

        return None;

    }

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

        let portal = run.path("/portal");

        return Some(

            Problem::new(

                StatusCode::NETWORK_AUTHENTICATION_REQUIRED,

                "captive-portal",

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

            )

            .with("portal", portal.as_str())

            .header(header::LINK, format!("<{portal}>; rel=\"{REL_BASE}portal\""))

            .into_response(),

        );

    }

    let authorization = ctx

        .header(header::AUTHORIZATION)

        .map(|text| Locale::negotiate(ctx.header(header::ACCEPT_LANGUAGE)).canonicalise(text));

    run.answer_door(authorization.as_deref())

        .err()

        .map(IntoResponse::into_response)

}

/// Every resource the run can reach right now, then every technique a JELQ could use. The `allow`

/// and `lubricant` extension attributes (RFC 8288 §3) say what each accepts, so a client never guesses.

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

    let thread_reachable = run.thread_reachable();

    let linked: [(&str, &RunResource, bool); 15] = [

        ("", &runs::RUN, true),

        ("floor", &runs::FLOOR, true),

        ("length", &runs::LENGTH, true),

        ("foreskin", &runs::FORESKIN, run.foreskin.is_some()),

        ("inventory", &runs::INVENTORY, true),

        ("techniques", &runs::TECHNIQUES, true),

        ("drawer", &runs::DRAWER, run.drawer_worth_searching()),

        ("kitchen", &runs::KITCHEN, {

            run.floor.has_kitchen() && run.kitchen_tellings < KITCHEN_TELLINGS

        }),

        ("re-read", &runs::REREAD, thread_reachable),

        ("grip", &runs::GRIP, true),

        ("shop", &runs::SHOP, run.floor.shop_open()),

        (

            "portal",

            &runs::PORTAL,

            run.floor == Floor::Hotel && !run.here.wifi_accepted,

        ),

        (

            "elder",

            &runs::ELDER,

            run.floor == Floor::Forum && run.elder != Elder::Beaten,

        ),

        ("footage", &runs::FOOTAGE, run.filmed_at.is_some()),

        ("diagnosis", &runs::DIAGNOSIS, run.floor == Floor::Clinic),

    ];

    linked

        .into_iter()

        .filter(|(_, _, relevant)| *relevant)

        .map(|(rel, target, _)| {

            let (path, name) = if rel.is_empty() {

                (run.path(""), "run")

            } else {

                (run.path(&format!("/{rel}")), rel)

            };

            let allow = target.resource.allow(run);

            format!("<{path}>; rel=\"{REL_BASE}{name}\"; allow=\"{allow}\"")

        })

        .chain(thread_reachable.then(|| {

            format!(

                "<{FORUM_THREAD}>; rel=\"{REL_BASE}thread\"; allow=\"{}\"",

                meta::THREAD.allow_any()

            )

        }),)

        .chain((run.story == Story::Pending).then(|| {

            let choice = |slug: &str, title: &str| {

                format!(

                    "<{}>; rel=\"{REL_BASE}branch\"; title=\"{title}\"; allow=\"POST\"",

                    run.path(&format!("/branches/{slug}"))

                )

            };

            [choice("forum", "Read the forum"), choice("close-tab", "Close the tab")].join(", ")

        }))

        .chain(run.techniques_now().into_iter().map(|technique| {

            let name = technique.name();

            let lubricant = technique

                .lubricant()

                .map_or(String::new(), |rule| format!("; lubricant=\"{rule}\""));

            format!(

                "<{}?technique={name}>; rel=\"{REL_BASE}technique\"; title=\"{name}\"; allow=\"JELQ\"{lubricant}",

                run.path("")

            )

        }))

        .chain(run.here.shopping.then(|| {

            SHOP.iter()

                .filter_map(|item| {

                    let price = item.price()?;

                    Some(format!(

                        "<{}>; rel=\"{REL_BASE}shop-item\"; title=\"{} for {price}\"; allow=\"POST\"",

                        run.path(&format!("/shop/{}", item.slug())),

                        item.slug()

                    ))

                })

                .collect::<Vec<_>>()

                .join(", ")

        }))

        .collect::<Vec<_>>()

        .join(", ")

}

/// Shame lives in a signed cookie so it follows the player across runs. Each response adds this

/// run's new shame to whatever total the client presents, so two runs at once both count.

fn settle_shame(run: &mut Run, ctx: &Ctx, secret: &Secret) -> u32 {

    let presented = ctx

        .cookie("shame")

        .and_then(|signed| secret.verify("shame", signed))

        .and_then(|total| total.parse::<u32>().ok());

    let total = presented.unwrap_or(run.shame_total) + (run.shame - run.shame_reported);

    run.shame_reported = run.shame;

    run.shame_total = total;

    total

}

pub fn finish(run: &mut Run, ctx: &Ctx, secret: &Secret, mut response: Response) -> Response {

    let status = response.status();

    if status == StatusCode::NOT_MODIFIED {

        return response;

    }

    let shame = settle_shame(run, ctx, secret);

    let mut stats: Vec<(HeaderName, String)> = vec![

        if run.items.ruler {

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

        } else {

            (

                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_FRICTION, format!("{}/{}", run.friction, FRICTION_MAX)),

        (X_EQ, run.eq.to_string()),

        (X_STAMINA, format!("{}/{}", run.stamina, run.max_stamina())),

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

        (X_SHAME, shame.to_string()),

        (X_CASH, run.cash.to_string()),

        (X_FLOOR, run.floor.number().to_string()),

        (header::LINK, links(run)),

    ];

    if let Some(observer) = run.observed {

        stats.push((X_OBSERVED_BY, observer.name().into()));

    }

    if run.mum.is_some() {

        stats.push((header::VIA, "1.1 mum".into()));

        stats.push((header::VARY, "Mum".into()));

    }

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

    if run.conditions.pulled_muscle {

        stats.push((header::WARNING, "199 - \"a muscle has been pulled\"".into()));

    }

    if run.conditions.friction_burn {

        stats.push((header::WARNING, "199 - \"friction burn\"".into()));

    }

    for notice in run.notices.drain(..) {

        stats.push((header::WARNING, format!("199 - \"{notice}\"")));

    }

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

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

    }

    stats.push((

        header::SET_COOKIE,

        format!(

            "shame={}; {COOKIE_ATTRIBUTES}",

            secret.sign("shame", &shame.to_string())

        ),

    ));

    if run.items.ruler {

        stats.push((

            header::SET_COOKIE,

            format!("ruler={}; {COOKIE_ATTRIBUTES}", secret.sign("ruler", "1")),

        ));

    }

    let headers = response.headers_mut();

    for (name, value) in stats {

        if let Ok(value) = HeaderValue::from_str(&value) {

            headers.append(name, value);

        }

    }

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

    if run.items.ring && !bodiless {

        response.extensions_mut().insert(Compress);

    }

    response

}

fn greet(response: Response, ctx: &mut Ctx) -> Response {

    if response.status() != StatusCode::SWITCHING_PROTOCOLS {

        return response;

    }

    let (Some(Greeting(text)), Some(upgrade)) = (

        response.extensions().get::<Greeting>().cloned(),

        ctx.upgrade.take(),

    ) else {

        return response;

    };

    tokio::spawn(async move {

        if let Ok(upgraded) = upgrade.await {

            let mut io = TokioIo::new(upgraded);

            let _ = io.write_all(text.as_bytes()).await;

            let _ = io.shutdown().await;

        }

    });

    response

}