jelq

use std::{

    fmt::Write as _,

    time::{Duration, Instant, SystemTime},

};

use axum::http::{StatusCode, header};

use rand::Rng;

use serde_json::json;

use super::{

    CLINIC_ALLOW, FORUM_THREAD, Floor, Grip, Lube, Outcome, REFRACTORY, Run, SERVER_TIMING,

    SUSPICION_LIMIT, Technique, catalog::LubeRule, catalog::Profile, not_extended, round3,

};

use crate::{game::LUBRICANTS, problem::Problem};

const WEEK: Duration = Duration::from_secs(7 * 24 * 60 * 60);

const PRIAPISM_TURNS: u8 = 5;

const PRIAPISM_EQ: i32 = 75;

const DEGLOVED: &str =

    "The outer layer has been removed in one piece. It will not be returning. The run has ended.";

impl Run {

    pub fn jelq(

        &mut self,

        techniques: &[Technique],

        intensity: i32,

        lube: Option<Lube>,

        now: Instant,

    ) -> Result<Outcome, Problem> {

        self.check_refractory(now)?;

        if self.branch_pending {

            return Ok(self.branch_offer());

        }

        match self.floor {

            Floor::Forum => {

                return Ok(Outcome::json(

                    StatusCode::SEE_OTHER,

                    json!({ "detail": "Refer to the forum." }),

                )

                .header(header::LOCATION, FORUM_THREAD));

            }

            Floor::Clinic => {

                return Err(Problem::new(

                    StatusCode::METHOD_NOT_ALLOWED,

                    "not-in-the-clinic",

                    "JELQ is not performed in the clinic.",

                )

                .header(header::ALLOW, CLINIC_ALLOW));

            }

            _ => {}

        }

        if self.items.cage {

            return Err(Problem::new(

                StatusCode::LOCKED,

                "caged",

                "The cage is locked. The key is not in the box.",

            ));

        }

        match *techniques {

            [technique] => self.single(technique, intensity, lube, now),

            [a, b] => self.combo(a, b, intensity, lube, now),

            _ => Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "too-many-techniques",

                "Two techniques at most. The server has limits even if you do not.",

            )),

        }

    }

    fn single(

        &mut self,

        technique: Technique,

        intensity: i32,

        lube: Option<Lube>,

        now: Instant,

    ) -> Result<Outcome, Problem> {

        match technique {

            Technique::Warmup => return self.warm_up(),

            Technique::Ice => return self.ice(),

            Technique::Supplement => return self.supplement(),

            Technique::Edge => {}

            _ => self.edges = 0,

        }

        self.prepare(technique, lube)?;

        self.check_storage()?;

        self.floor_enemy()?;

        match technique {

            Technique::Edge => return self.edge(now),

            Technique::Pump => return self.pump(now),

            _ => {}

        }

        let profile = technique.profile().expect("training technique");

        self.commit(intensity, lube, now, 1);

        if technique == Technique::Dry && intensity >= 8 && self.rng.random_ratio(1, 60) {

            self.end("degloved", DEGLOVED);

            return Err(Problem::new(StatusCode::GONE, "degloved", DEGLOVED));

        }

        if let Some(interrupted) = self.hazards(intensity)? {

            return Ok(interrupted);

        }

        let result = self.roll(technique, &profile, intensity, lube);

        Ok(self.gossip(result?))

    }

    fn combo(

        &mut self,

        a: Technique,

        b: Technique,

        intensity: i32,

        lube: Option<Lube>,

        now: Instant,

    ) -> Result<Outcome, Problem> {

        let (Some(first), Some(second)) = (a.profile(), b.profile()) else {

            return Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "combo-invalid",

                "Only training techniques can be combined.",

            ));

        };

        if a == b {

            return Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "combo-invalid",

                "A technique cannot be combined with itself. The server has checked.",

            ));

        }

        self.edges = 0;

        self.prepare(a, lube)?;

        self.prepare(b, lube)?;

        self.check_storage()?;

        self.floor_enemy()?;

        self.commit(intensity, lube, now, 2);

        if let Some(interrupted) = self.hazards(intensity)? {

            return Ok(interrupted);

        }

        let mut statuses = Vec::new();

        for (technique, profile) in [(a, first), (b, second)] {

            let result = self.roll(technique, &profile, intensity, lube);

            if self.ended.is_some() {

                return result;

            }

            let status = match &result {

                Ok(outcome) => outcome.status(),

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

            };

            statuses.push((technique, status));

        }

        let mut xml = String::from(

            "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<D:multistatus xmlns:D=\"DAV:\">\n",

        );

        for (technique, status) in statuses {

            let _ = write!(

                xml,

                "  <D:response>\n    <D:href>/runs/{}?technique={}</D:href>\n    <D:status>HTTP/1.1 {} {}</D:status>\n  </D:response>\n",

                self.id,

                technique.name(),

                status.as_u16(),

                status.canonical_reason().unwrap_or_default(),

            );

        }

        xml.push_str(

            "  <D:responsedescription>Each technique has been reported separately.</D:responsedescription>\n</D:multistatus>\n",

        );

        Ok(Outcome::raw(

            StatusCode::MULTI_STATUS,

            "application/xml; charset=utf-8",

            xml,

        ))

    }

    fn prepare(&self, technique: Technique, lube: Option<Lube>) -> Result<(), Problem> {

        if technique == Technique::Uli && !self.forum_read {

            return Err(Problem::new(

                StatusCode::FORBIDDEN,

                "technique-locked",

                "This technique is discussed on the forum. You have not been to the forum.",

            ));

        }

        if !self.warmed_up {

            return Err(Problem::new(

                StatusCode::PRECONDITION_FAILED,

                "cold-start",

                "Warm-up was skipped. The server has noted this.",

            )

            .with("technique", Technique::Warmup.name()));

        }

        if technique == Technique::Pump && !self.items.pump_pro {

            return Err(Problem::new(

                StatusCode::FAILED_DEPENDENCY,

                "no-pump",

                "The pump technique depends on a pump.",

            ));

        }

        let Some(profile) = technique.profile() else {

            return Ok(());

        };

        match (profile.lube, lube) {

            (LubeRule::Required, None) => {

                return Err(Problem::new(

                    StatusCode::UNSUPPORTED_MEDIA_TYPE,

                    "lubricant-required",

                    format!(

                        "The {} technique requires a lubricant. None was declared.",

                        technique.name()

                    ),

                )

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

            }

            (LubeRule::Forbidden, Some(_)) => {

                return Err(Problem::new(

                    StatusCode::UNSUPPORTED_MEDIA_TYPE,

                    "lubricant-declared",

                    "The dry technique was requested. A lubricant was declared.",

                ));

            }

            _ => {}

        }

        if let Some((min, max)) = profile.foreskin {

            self.check_foreskin(min, max)?;

        }

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

            )

            .header(

                header::CONTENT_LOCATION,

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

            ));

        };

        if f < min {

            return Err(Problem::new(

                StatusCode::LENGTH_REQUIRED,

                "foreskin-insufficient",

                format!(

                    "The selected technique requires {min:.1} units of foreskin. {f:.2} units are available. The server has noted the shortfall."

                ),

            )

            .with("required", min)

            .with("available", super::round2(f)));

        }

        if f > max {

            return Err(Problem::new(

                StatusCode::PAYLOAD_TOO_LARGE,

                "foreskin-excessive",

                format!(

                    "The selected technique tolerates at most {max:.1} units of foreskin. {f:.2} units are present."

                ),

            )

            .with("maximum", max)

            .with("present", super::round2(f)));

        }

        Ok(())

    }

    fn check_storage(&self) -> Result<(), Problem> {

        if self.items.extender && self.girth > 5.0 {

            return Err(Problem::new(

                StatusCode::INSUFFICIENT_STORAGE,

                "jeans-full",

                "The jeans are full. The extender is occupying the remaining storage.",

            )

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

        }

        Ok(())

    }

    fn commit(&mut self, intensity: i32, lube: Option<Lube>, now: Instant, cost: i32) {

        self.touch();

        self.turn += 1;

        self.floor_turns += 1;

        self.realize();

        if self.items.extender {

            self.length += 0.004;

        }

        self.stamina -= cost + i32::from(lube == Some(Lube::Lotion));

        if self.stamina <= 0 {

            self.stamina = 0;

            self.refractory_until = Some(now + *REFRACTORY);

        }

        let chill = if self.floor == Floor::LockerRoom {

            8

        } else {

            0

        };

        let wobble = self.rng.random_range(-3..=3);

        self.eq = (self.eq + intensity * 2 - 6 - chill + wobble).clamp(0, 100);

        let mut suspicion = intensity / 5 + i32::from(lube == Some(Lube::Vaseline));

        if matches!(self.floor, Floor::LockerRoom | Floor::Grandmas) {

            suspicion *= 2;

        }

        if self.floor == Floor::Grandmas && lube == Some(Lube::CoconutOil) {

            suspicion += 2;

        }

        let was_below = self.suspicion < SUSPICION_LIMIT;

        self.suspicion =

            (i32::from(self.suspicion) + suspicion).min(i32::from(SUSPICION_LIMIT)) as u8;

        if self.floor.has_mom() && !self.mom_present {

            let summoned = was_below && self.suspicion == SUSPICION_LIMIT;

            if summoned || self.rng.random_ratio(u32::from(self.suspicion) + 1, 16) {

                self.mom_present = true;

                self.mom_strikes = 0;

                self.mom_errand = self.errand(summoned);

                self.nonce = self.fresh_nonce();

            }

        }

        if let Some(observer) = self.floor.observer()

            && self.rng.random_ratio(1, 6)

        {

            self.observed = Some(observer);

            self.shame += 1;

            if observer == "cat" && self.rng.random_ratio(1, 5) {

                self.towel_stolen = true;

            }

        }

        if intensity >= 9 && !self.pulled_muscle && self.rng.random_ratio(1, 12) {

            self.pulled_muscle = true;

            self.stamina = self.stamina.min(self.max_stamina());

        }

        if self.items.ring && self.eq > 85 && self.rng.random_ratio(1, 10) {

            self.priapism_turns = PRIAPISM_TURNS;

        }

        if self.priapism_turns > 0 {

            self.priapism_turns -= 1;

            self.eq = self.eq.max(PRIAPISM_EQ);

        }

        if self.turn == super::BRANCH_TURN {

            self.branch_pending = true;

        }

    }

    fn hazards(&mut self, intensity: i32) -> Result<Option<Outcome>, Problem> {

        let odds = match self.eq {

            ..=70 => 250,

            71..=85 => 25,

            _ => 10,

        };

        if self.rng.random_ratio(1, odds) {

            return Err(self.rupture());

        }

        let windowed = matches!(self.floor, Floor::Bedroom | Floor::Grandmas | Floor::Hotel);

        if windowed && !self.items.blinds && self.rng.random_ratio(1, 60) {

            self.shame += 30;

            self.filmed_at.get_or_insert_with(SystemTime::now);

            return Ok(Some(

                Outcome::json(

                    StatusCode::CREATED,

                    json!({ "detail": "A neighbour was at the window. A recording has been created. It has been shared." }),

                )

                .header(header::LOCATION, format!("/runs/{}/footage", self.id)),

            ));

        }

        if self.floor == Floor::LockerRoom && self.rng.random_ratio(1, 10) {

            self.shame += 1;

            return Err(Problem::new(

                StatusCode::USE_PROXY,

                "friend",

                "A friend has offered to help. Use Proxy is deprecated, and the server has declined on your behalf.",

            ));

        }

        if self.peyronie && self.rng.random_ratio(1, 3) {

            return Err(Problem::new(

                StatusCode::MISDIRECTED_REQUEST,

                "misdirected",

                "The technique landed slightly to the left. It was meant for a different server.",

            ));

        }

        if intensity <= 2 && self.eq < 50 {

            self.eq = (self.eq - 10).max(0);

            return Err(Problem::new(

                StatusCode::REQUEST_TIMEOUT,

                "lost-it",

                "The request took too long. It was lost.",

            )

            .header(header::CONNECTION, "close"));

        }

        if self.eq > 95 {

            if self.rng.random_ratio(1, 3) {

                return Err(self.rupture());

            }

            self.shame += 5;

            self.next_floor(false);

            return Err(Problem::new(

                StatusCode::TOO_EARLY,

                "premature",

                "The floor has ended early. Everyone involved has agreed not to discuss it.",

            )

            .with("floor", self.floor.number()));

        }

        if self.eq < 30 {

            return Err(Problem::new(

                StatusCode::NOT_FOUND,

                "cold",

                "The resource exists. It is cold.",

            )

            .with("eq", self.eq));

        }

        Ok(None)

    }

    fn roll(

        &mut self,

        technique: Technique,

        profile: &Profile,

        intensity: i32,

        lube: Option<Lube>,

    ) -> Result<Outcome, Problem> {

        let natural: i32 = self.rng.random_range(1..=20);

        let band = if (50..=70).contains(&self.eq) { 2 } else { 0 };

        let grip = match (self.grip, technique) {

            (Grip::Underhand, Technique::Stretch) => 2,

            (Grip::Underhand, Technique::Wet) => -1,

            _ => 0,

        };

        let modifier = lube.map_or(0, Lube::modifier) + band + grip;

        let dc = profile.dc + intensity / 3;

        let total = natural + modifier;

        let timing = format!("roll;desc=\"d20{modifier:+} vs {dc}\";dur={natural}");

        let timed = |p: Problem| p.header(SERVER_TIMING, &timing);

        let scale = f64::from(intensity);

        let (mut length, mut girth) = (profile.length * scale, profile.girth * scale);

        if self.teapot {

            length *= 0.5;

            girth *= 1.5;

        }

        if self.items.ring {

            girth *= 2.0;

        }

        let rupture_eq = if self.items.ring { 80 } else { 90 };

        if natural == 1 {

            let touches_foreskin = profile.foreskin.is_some_and(|(min, _)| min > 0.0);

            if touches_foreskin && self.foreskin.is_some() {

                self.foreskin = None;

                self.shame += 25;

                return Err(timed(

                    Problem::new(

                        StatusCode::GONE,

                        "foreskin-lost",

                        "The technique has removed the foreskin. It will not be returning.",

                    )

                    .header(

                        header::CONTENT_LOCATION,

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

                    ),

                ));

            }

            if self.eq > 70 {

                return Err(timed(self.rupture()));

            }

            if technique == Technique::Stretch && !self.teapot {

                self.teapot = true;

                self.items.teapot_spout = true;

                self.shame += 5;

                return Err(timed(Problem::new(

                    StatusCode::IM_A_TEAPOT,

                    "teapot",

                    "The subject is now short and stout. Length gains are halved for the rest of the floor.",

                )));

            }