jelq

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

use axum::{

    Json,

    http::{StatusCode, header},

    response::{IntoResponse, Response},

};

use serde_json::{Value, json};

use super::{

    ctx::Ctx,

    inventory::{delete_item, get_inventory, get_item},

    parse::{parse_intensity, parse_techniques},

    resource::{Resource, Verb},

    response::respond,

    run::{Greeting, RunResource, Scope},

    shaft::{get_foreskin, get_length},

};

use crate::{

    game::{

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

        balance::VIEWS_PER_SECOND,

    },

    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

}

pub static RUN: RunResource = RunResource {

    scope: Scope::Home,

    resource: Resource::new(&[

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

        Verb::new("JELQ", jelq).only_when(not_in_clinic, "JELQ is not performed in the clinic."),

        Verb::new("HOLD", hold_run).only_when(

            Run::can_hold,

            "HOLD is only available once Swollen or at 2 stamina or less.",

        ),

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

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

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

    ]),

};

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 KITCHEN: RunResource = home(&[Verb::new("POST", raid_kitchen)]);

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

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

pub static FLOOR: RunResource =

    home(&[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::refused(

        "DELETE",

        "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 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)),

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

    }

}

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

    run.put().into_response()

}

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

    respond(run.hold())

}

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

    (

        StatusCode::OK,

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

        ctx.echo(),

    )

        .into_response()

}

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

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

}

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

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

        .into_iter()

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

        .collect();

    Json(json!({

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

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

        "lubricants": LUBRICANTS,

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

    match ctx.param("choice").parse::<Branch>() {

        Ok(choice) => respond(run.choose(choice)),

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

            StatusCode::NOT_FOUND,

            "no-such-choice",

            "That was not one of the choices.",

        )

        .into_response(),

    }

}

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.browse_shop().map(Json))

}

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

    respond(run.buy(Item::parse(ctx.param("item"))))

}

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

    respond(run.raid_kitchen())

}

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

    respond(run.commit_melon())

}

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

    respond(run.read_thread())

}

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| protocol.trim().parse::<Grip>().ok())

}

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

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

        if let Err(problem) = run.set_grip(grip) {

            return problem.into_response();

        }

        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 {

        return Problem::new(

            StatusCode::NOT_FOUND,

            "no-footage",

            "There is no footage. Yet.",

        )

        .into_response();

    };

    (

        [

            (

                header::CACHE_CONTROL,

                "public, max-age=31536000, immutable".to_owned(),

            ),

            (header::AGE, age.to_string()),

            (header::LAST_MODIFIED, httpdate::fmt_http_date(filmed)),

        ],

        Json(json!({

            "detail": "A recording. It is grainy. It is unmistakably you. It has been shared.",

            "views": 1 + age * VIEWS_PER_SECOND,

        })),

    )

        .into_response()

}