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, links, meta::GRAVEYARD_PATH, middleware::Compress, registry::Lock,

    resource::Resource, shame,

};

use crate::{

    game::{

        Cause, Gauges, Run, Shown,

        balance::{FRICTION_MAX, SUSPICION_LIMIT},

    },

    headers::{

        X_CASH, X_DANGER, X_EQ, X_FLOOR, X_FLOOR_OVER, X_FLOOR_TURN, X_FORESKIN, X_FRICTION,

        X_GAINS_ARRIVED, X_GIRTH, X_LENGTH, X_OBSERVED_BY, X_RUN_OVER, X_SELF_REPORTED_LENGTH,

        X_SHAME, X_STAMINA, X_SUSPICION, X_TURN,

    },

    link::Link,

    locale::Locale,

    problem::{PROBLEM_BASE, Problem},

    records::Record,

    secret::Secret,

};

/// 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 records_unavailable(error: &rusqlite::Error) -> Response {

    Problem::new(

        StatusCode::SERVICE_UNAVAILABLE,

        "records-unavailable",

        "The records are unavailable. Nothing has been forgotten, it is only out of reach.",

    )

    .with("error", error.to_string())

    .into_response()

}

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

            Ok(Some(Record {

                cause: Some(cause),

                turn,

                ..

            })) => gone(cause.slug(), turn),

            Ok(_) => Problem::new(

                StatusCode::NOT_FOUND,

                "no-such-run",

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

            )

            .into_response(),

            Err(error) => records_unavailable(&error),

        };

    };

    let (response, record) = match Lock::take(&slot) {

        Lock::Poisoned(mut run) => {

            run.lose();

            let response = gone(Cause::Lost.slug(), run.turn);

            (response, Some(Record::of(&run)))

        }

        Lock::Held(mut run) => {

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

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

            }

            run.seen(ctx.now());

            let mut response = gate(&mut run, &ctx, target.scope)

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

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

                response

                    .headers_mut()

                    .insert(X_RUN_OVER, HeaderValue::from_static(ending.cause.slug()));

            }

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

            let record = run.status().finished().then(|| Record::of(&run));

            (response, record)

        }

    };

    if let Some(record) = record {

        if let Err(error) = state.records.save(&record) {

            return records_unavailable(&error);

        }

        if record.cause.is_some() {

            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_PATH)

        .header(X_RUN_OVER, cause)

        .into_response()

}

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

    if scope == Scope::Pockets {

        return None;

    }

    if run.needs_portal() {

        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, Link::jelq(&portal, "portal").to_string())

            .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)

}

fn stats(gauges: &Gauges, shame: u32) -> Vec<(HeaderName, String)> {

    let mut stats = vec![

        match gauges.length {

            Shown::Measured(length) => (X_LENGTH, format!("{length:.2}")),

            Shown::SelfReported(length) => (X_SELF_REPORTED_LENGTH, format!("{length:.2}")),

        },

        (X_GIRTH, format!("{:.2}", gauges.girth)),

        (

            X_FORESKIN,

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

        ),

        (X_FRICTION, format!("{}/{FRICTION_MAX}", gauges.friction)),

        (X_EQ, gauges.arousal.name().into()),

        (

            X_STAMINA,

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

        ),

        (

            X_SUSPICION,

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

        ),

        (X_SHAME, shame.to_string()),

        (X_CASH, gauges.cash.to_string()),

        (X_FLOOR, gauges.floor.to_string()),

        (X_TURN, gauges.turn.to_string()),

        (

            X_FLOOR_TURN,

            gauges

                .floor_limit

                .map_or(gauges.floor_turns.to_string(), |limit| {

                    format!("{}/{limit}", gauges.floor_turns)

                }),

        ),

    ];

    if gauges.floor_over {

        stats.push((X_FLOOR_OVER, "?1".into()));

    }

    if !gauges.dangers.is_empty() {

        let dangers: Vec<String> = gauges

            .dangers

            .iter()

            .map(|(gauge, danger)| format!("{gauge}={}", danger.name()))

            .collect();

        stats.push((X_DANGER, dangers.join(", ")));

    }

    if let Some(observer) = gauges.observed {

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

    }

    if let Some(challenge) = &gauges.mum_challenge {

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

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

        stats.push((header::WWW_AUTHENTICATE, challenge.clone()));

    }

    if let Some(arrived) = &gauges.arrived {

        let mut gains = format!("length={:.3}, girth={:.3}", arrived.length, arrived.girth);

        if let Some(foreskin) = arrived.foreskin {

            gains.push_str(&format!(", foreskin={foreskin:.3}"));

        }

        stats.push((X_GAINS_ARRIVED, gains));

    }

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

    for warning in &gauges.warnings {

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

    }

    stats

}

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, shame_cookie) = shame::settle(run, ctx, secret);

    let gauges = run.gauges();

    let link = links::header(run);

    let headers = response.headers_mut();

    for (name, value) in stats(&gauges, shame) {

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

            headers.append(name, value);

        }

    }

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

        headers.append(header::LINK, link);

    }

    headers.append(header::SET_COOKIE, shame_cookie);

    if gauges.ruler {

        headers.append(header::SET_COOKIE, shame::ruler_cookie(secret));

    }

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

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

    ) 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

}