jelq

use std::time::{Duration, Instant};

use axum::{

    Json,

    body::Body,

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

    response::{IntoResponse, Response},

};

use rand::{Rng, SeedableRng, rngs::StdRng};

use serde::Deserialize;

use serde_json::{Value, json};

use crate::problem::Problem;

pub const MAX_STAMINA: i32 = 10;

pub const SUSPICION_LIMIT: u8 = 5;

pub const BRANCH_TURN: u32 = 10;

pub const APPOINTMENT_TURN: u32 = 20;

pub const REFRACTORY: Duration = Duration::from_secs(30);

pub const SELF_REPORT_INFLATION: f64 = 1.5;

pub const MM_PER_INCH: f64 = 25.4;

pub const EXCUSES: [&str; 3] = ["changing", "homework", "pulled a muscle"];

pub const LUBRICANTS: [&str; 5] = [

    "application/baby-oil",

    "application/coconut-oil",

    "application/lotion",

    "application/vaseline",

    "text/plain; charset=spit",

];

pub const INTAKE: [&str; 3] = [

    "The clinic does not accept excuses.",

    "The clinic accepts one token. You have not been carrying it.",

    "Be honest.",

];

pub const SERVER_TIMING: HeaderName = HeaderName::from_static("server-timing");

pub const X_DIAGNOSIS: HeaderName = HeaderName::from_static("x-diagnosis");

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

pub enum Lube {

    BabyOil,

    CoconutOil,

    Lotion,

    Vaseline,

    Spit,

}

impl Lube {

    pub fn from_content_type(content_type: Option<&str>) -> Result<Option<Self>, Problem> {

        let Some(raw) = content_type else {

            return Ok(None);

        };

        let lowered = raw.to_ascii_lowercase();

        let mut parts = lowered.split(';').map(str::trim);

        let essence = parts.next().unwrap_or_default();

        let spit = parts.any(|p| p.replace(' ', "") == "charset=spit");

        match essence {

            "application/baby-oil" => Ok(Some(Self::BabyOil)),

            "application/coconut-oil" => Ok(Some(Self::CoconutOil)),

            "application/lotion" => Ok(Some(Self::Lotion)),

            "application/vaseline" => Ok(Some(Self::Vaseline)),

            "text/plain" if spit => Ok(Some(Self::Spit)),

            e if e.starts_with("image/") || e.starts_with("video/") => Err(Problem::new(

                StatusCode::UNSUPPORTED_MEDIA_TYPE,

                "no",

                "No.",

            )),

            _ => Err(Problem::new(

                StatusCode::UNSUPPORTED_MEDIA_TYPE,

                "unsupported-lubricant",

                format!("{essence} is not a lubricant."),

            )

            .with("lubricants", json!(LUBRICANTS))),

        }

    }

    fn modifier(self) -> i32 {

        match self {

            Self::BabyOil => 1,

            Self::CoconutOil => 3,

            Self::Lotion => 0,

            Self::Vaseline => 2,

            Self::Spit => -2,

        }

    }

}

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

pub enum Technique {

    Warmup,

    Ice,

    Wet,

    Dry,

    Stretch,

    Uli,

}

#[derive(Clone, Copy)]

enum LubeRule {

    Required,

    Forbidden,

    Optional,

}

struct Profile {

    dc: i32,

    length: f64,

    girth: f64,

    foreskin: Option<(f64, f64)>,

    foreskin_growth: f64,

    lube: LubeRule,

}

impl Technique {

    pub const ALL: [Self; 6] = [

        Self::Warmup,

        Self::Ice,

        Self::Wet,

        Self::Dry,

        Self::Stretch,

        Self::Uli,

    ];

    pub fn name(self) -> &'static str {

        match self {

            Self::Warmup => "warmup",

            Self::Ice => "ice",

            Self::Wet => "wet",

            Self::Dry => "dry",

            Self::Stretch => "stretch",

            Self::Uli => "uli",

        }

    }

    pub fn parse(name: &str) -> Option<Self> {

        Self::ALL.into_iter().find(|t| t.name() == name)

    }

    fn profile(self) -> Option<Profile> {

        let profile = match self {

            Self::Warmup | Self::Ice => return None,

            Self::Wet => Profile {

                dc: 10,

                length: 0.010,

                girth: 0.005,

                foreskin: None,

                foreskin_growth: 0.0,

                lube: LubeRule::Required,

            },

            Self::Dry => Profile {

                dc: 12,

                length: 0.008,

                girth: 0.003,

                foreskin: Some((0.8, 2.0)),

                foreskin_growth: 0.01,

                lube: LubeRule::Forbidden,

            },

            Self::Stretch => Profile {

                dc: 11,

                length: 0.015,

                girth: 0.0,

                foreskin: Some((0.0, 1.8)),

                foreskin_growth: 0.03,

                lube: LubeRule::Optional,

            },

            Self::Uli => Profile {

                dc: 15,

                length: 0.002,

                girth: 0.020,

                foreskin: None,

                foreskin_growth: 0.0,

                lube: LubeRule::Optional,

            },

        };

        Some(profile)

    }

    pub fn describe(self, forum_read: bool) -> Value {

        let Some(p) = self.profile() else {

            let effect = match self {

                Self::Warmup => "EQ +25. Satisfies the warm-up precondition.",

                _ => "EQ -40. Consumes an ice pack.",

            };

            return json!({ "name": self.name(), "effect": effect });

        };

        let lubricant = match p.lube {

            LubeRule::Required => "required",

            LubeRule::Forbidden => "forbidden",

            LubeRule::Optional => "optional",

        };

        let foreskin = p

            .foreskin

            .map(|(min, max)| json!({ "min": min, "max": max }));

        json!({

            "name": self.name(),

            "dc": p.dc,

            "lubricant": lubricant,

            "foreskin": foreskin,

            "locked": self == Self::Uli && !forum_read,

        })

    }

}

pub struct Outcome {

    status: StatusCode,

    body: Option<Value>,

    headers: Vec<(HeaderName, String)>,

}

impl Outcome {

    pub fn new(status: StatusCode, body: Option<Value>) -> Self {

        Self {

            status,

            body,

            headers: Vec::new(),

        }

    }

    pub fn header(mut self, name: HeaderName, value: impl Into<String>) -> Self {

        self.headers.push((name, value.into()));

        self

    }

}

impl IntoResponse for Outcome {

    fn into_response(self) -> Response {

        let mut response = match self.body {

            // RFC 9110 §15.3.7 obliges a 206 to be a byte range of the full representation, so it is.

            Some(body) if self.status == StatusCode::PARTIAL_CONTENT => {

                let full = body.to_string().into_bytes();

                let half = full.len() / 2;

                let range = format!("bytes 0-{}/{}", half - 1, full.len());

                (

                    self.status,

                    [

                        (header::CONTENT_TYPE, "application/json".to_owned()),

                        (header::CONTENT_RANGE, range),

                    ],

                    Body::from(full[..half].to_vec()),

                )

                    .into_response()

            }

            Some(body) => (self.status, Json(body)).into_response(),

            None => self.status.into_response(),

        };

        for (name, value) in self.headers {

            let value = HeaderValue::from_str(&value).expect("header values are visible ascii");

            response.headers_mut().append(name, value);

        }

        response

    }

}

#[derive(Deserialize)]

pub struct PatchOp {

    pub op: String,

    pub path: String,

    #[serde(default)]

    pub value: Value,

}

pub struct Pending {

    due: u32,

    length: f64,

    girth: f64,

}

pub struct Ending {

    pub cause: &'static str,

    pub detail: String,

    pub turn: u32,

}

pub struct Run {

    pub id: String,

    pub origin_etag: String,

    pub version: u64,

    pub turn: u32,

    pub length: f64,

    pub girth: f64,

    pub foreskin: Option<f64>,

    pub eq: i32,

    pub stamina: i32,

    pub suspicion: u8,

    pub shame_base: u32,

    pub shame: u32,

    pub ice_packs: u32,

    pub warmed_up: bool,

    pub teapot: bool,

    pub ruler: bool,

    pub put_applied: bool,

    pub forum_read: bool,

    pub branch_pending: bool,

    pub mom_present: bool,

    pub observed: bool,

    pub measured: bool,

    pub cured: bool,

    pub intake_attempts: usize,

    pub refractory_until: Option<Instant>,

    pub pending: Vec<Pending>,

    pub ended: Option<Ending>,

    rng: StdRng,

}

fn round2(x: f64) -> f64 {

    (x * 100.0).round() / 100.0

}

fn round3(x: f64) -> f64 {

    (x * 1000.0).round() / 1000.0

}

fn tenths(x: f64) -> i64 {

    (x * 10.0).round() as i64

}

fn not_extended() -> Problem {

    Problem::new(

        StatusCode::NOT_EXTENDED,

        "not-extended",

        "The requested extension was not applied. The server has recorded the attempt.",

    )

}

pub fn parse_credentials<'a>(authorization: &'a str, scheme: &str) -> Option<&'a str> {

    let (given, rest) = authorization.trim().split_once(' ')?;

    given

        .eq_ignore_ascii_case(scheme)

        .then(|| rest.trim().trim_matches('"'))

}

impl Run {

    pub fn new(id: String, seed: u64, shame_base: u32) -> Self {

        let mut rng = StdRng::seed_from_u64(seed);

        let length = round2(rng.random_range(4.5..6.5));

        let girth = round2(rng.random_range(4.0..5.0));

        let foreskin = round2(rng.random_range(0.4..2.4));

        let mut run = Self {

            id,

            origin_etag: String::new(),

            version: 0,

            turn: 0,

            length,

            girth,

            foreskin: Some(foreskin),

            eq: 20,

            stamina: MAX_STAMINA,

            suspicion: 0,

            shame_base,

            shame: 0,

            ice_packs: 1,

            warmed_up: false,

            teapot: false,

            ruler: false,

            put_applied: false,

            forum_read: false,

            branch_pending: false,

            mom_present: false,

            observed: false,

            measured: false,

            cured: false,

            intake_attempts: 0,

            refractory_until: None,

            pending: Vec::new(),

            ended: None,

            rng,

        };

        run.origin_etag = run.etag();

        run

    }

    pub fn etag(&self) -> String {

        format!("\"{}-{}\"", self.id, self.version)

    }

    pub fn touch(&mut self) {

        self.version += 1;

    }

    pub fn self_reported(&self) -> f64 {

        self.length + SELF_REPORT_INFLATION

    }

    pub fn total_shame(&self) -> u32 {

        self.shame_base + self.shame

    }

    pub fn status(&self) -> &'static str {

        match (&self.ended, self.cured) {

            (Some(_), _) => "gone",

            (None, true) => "normal",

            (None, false) => "alive",

        }

    }

    pub fn view(&self) -> Value {

        let mut view = json!({

            "id": self.id,

            "status": self.status(),

            "turn": self.turn,

            "floor": 1,

            "self_reported_length": round2(self.self_reported()),

            "girth": round2(self.girth),

            "foreskin": self.foreskin.map(round2),

            "eq": self.eq,

            "stamina": self.stamina,

            "suspicion": self.suspicion,

            "shame": self.total_shame(),

            "warmed_up": self.warmed_up,

        });

        if self.ruler {

            view["length"] = json!(round2(self.length));

        }

        if self.teapot {

            view["condition"] = json!("short and stout");

        }

        view

    }

    pub fn end(&mut self, cause: &'static str, detail: &str) {

        self.ended = Some(Ending {

            cause,

            detail: detail.into(),

            turn: self.turn,

        });

    }

    pub fn answer_door(&mut self, authorization: Option<&str>) -> Result<(), Problem> {

        let challenge =

            |p: Problem| p.header(header::WWW_AUTHENTICATE, "Excuse realm=\"household\"");

        let Some(authorization) = authorization else {

            return Err(challenge(

                Problem::new(

                    StatusCode::UNAUTHORIZED,

                    "someone-at-the-door",

                    "Someone is at the door.",

                )

                .with("inventory", format!("/runs/{}/inventory", self.id)),

            ));

        };

        let excuse = parse_credentials(authorization, "excuse");

        if excuse.is_some_and(|e| EXCUSES.iter().any(|known| known.eq_ignore_ascii_case(e))) {

            self.mom_present = false;

            self.suspicion = 0;

            self.touch();

            return Ok(());

        }

        self.shame += 3;

        self.touch();

        Err(challenge(Problem::new(

            StatusCode::UNAUTHORIZED,

            "excuse-rejected",

            "Mom has not heard that one before. She does not believe it.",

        )))

    }

    fn check_refractory(&mut self, now: Instant) -> Result<(), Problem> {

        let Some(until) = self.refractory_until else {

            return Ok(());

        };

        if now < until {

            let seconds = (until - now).as_secs() + 1;

            return Err(Problem::new(

                StatusCode::TOO_MANY_REQUESTS,

                "overtrained",

                "Stamina is exhausted. The refractory period is in effect.",

            )

            .header(header::RETRY_AFTER, seconds.to_string()));

        }

        self.refractory_until = None;

        self.stamina = MAX_STAMINA;

        self.eq = 20;

        self.warmed_up = false;

        self.touch();

        Ok(())

    }

    fn check_foreskin(&self, min: f64, max: f64) -> Result<(), Problem> {

        let Some(f) = self.foreskin else {

            if min <= 0.0 {

                return Ok(());

            }

            return Err(Problem::new(

                StatusCode::GONE,

                "foreskin-gone",

                "This technique requires a foreskin. The foreskin is gone.",