jelq

use std::{fmt::Write as _, ops::ControlFlow, time::Instant};

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

use rand::Rng;

use serde_json::json;

use super::{

    Floor, Grip, LUBRICANTS, Lube, Outcome, Payload, Run, Story, Technique,

    balance::{

        ARRIVAL_BONUS, BAND_BONUS, BRANCH_TURN, BURN_RUPTURE, CAT_TAKES_TOWEL, CHANGING_ROOM_CHILL,

        DANGER_EQ, EQ_BAND, EQ_WOBBLE, EXTENDER_GAIN, FRICTION_BURN, FRICTION_BURN_AT,

        FRICTION_DRY, FRICTION_GRIP, FRICTION_HOLD, FRICTION_MAX, FRICTION_MEDITATE, FRICTION_SPIT,

        GREED_HOT, GREED_WARM, HOLD_EQ, HOT_EQ, MEDITATION_EQ, OBSERVED, PRIAPISM_EQ,

        PRIAPISM_TURNS, PULLED_MUSCLE, PULLED_MUSCLE_INTENSITY, REFLECTION, RING_PRIAPISM,

        RING_RUPTURE_LINE, RUPTURE_LINE, STORAGE_GIRTH, SUSPICION_LIMIT,

    },

    not_extended, round3,

    state::{MumVisit, Observer, Pending},

    techniques::{LubeRule, Profile, Training, Utility},

};

use crate::{headers::SERVER_TIMING, problem::Problem};

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.story == Story::Pending {

            return Ok(self.branch_offer());

        }

        if self.floor == Floor::Forum {

            return Ok(Outcome::json(

                StatusCode::SEE_OTHER,

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

            )

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

        }

        if self.items.cage {

            return Err(Problem::new(

                StatusCode::LOCKED,

                "caged",

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

            ));

        }

        self.here.shopping = false;

        match *techniques {

            [Technique::Utility(utility)] => self.utility(utility, lube, now),

            [Technique::Training(training)] => self.single(training, intensity, lube, now),

            [Technique::Training(a), Technique::Training(b)] => {

                self.combo(a, b, intensity, lube, now)

            }

            [_, _] => Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "combo-invalid",

                "Only training techniques can be combined.",

            )),

            _ => Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "too-many-techniques",

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

            )),

        }

    }

    fn utility(

        &mut self,

        utility: Utility,

        lube: Option<Lube>,

        now: Instant,

    ) -> Result<Outcome, Problem> {

        match utility {

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

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

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

            Utility::Meditate => return self.meditate(),

            Utility::Energy => return self.energy(),

            Utility::Edge | Utility::Pump => {}

        }

        if utility == Utility::Pump {

            self.here.edges = 0;

        }

        self.ready(Technique::Utility(utility), lube)?;

        self.check_storage()?;

        self.floor_enemy()?;

        match utility {

            Utility::Edge => self.edge(now),

            _ => self.pump(now),

        }

    }

    fn single(

        &mut self,

        training: Training,

        intensity: i32,

        lube: Option<Lube>,

        now: Instant,

    ) -> Result<Outcome, Problem> {

        self.here.edges = 0;

        self.ready(Technique::Training(training), lube)?;

        self.check_storage()?;

        self.lube_available(lube)?;

        self.floor_enemy()?;

        self.take_lube(lube)?;

        self.chafe(lube);

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

        if let ControlFlow::Break(interrupted) = self.mishaps(training, intensity)? {

            return Ok(interrupted);

        }

        if let ControlFlow::Break(interrupted) = self.hazards(intensity)? {

            return Ok(interrupted);

        }

        let outcome = self.roll(training, intensity, lube)?;

        Ok(self.gossip(outcome))

    }

    fn combo(

        &mut self,

        a: Training,

        b: Training,

        intensity: i32,

        lube: Option<Lube>,

        now: Instant,

    ) -> Result<Outcome, Problem> {

        if a == b {

            return Err(Problem::new(

                StatusCode::BAD_REQUEST,

                "combo-invalid",

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

            ));

        }

        self.here.edges = 0;

        self.ready(Technique::Training(a), lube)?;

        self.ready(Technique::Training(b), lube)?;

        self.check_storage()?;

        self.lube_available(lube)?;

        self.floor_enemy()?;

        self.take_lube(lube)?;

        self.chafe(lube);

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

        for training in [a, b] {

            if let ControlFlow::Break(interrupted) = self.mishaps(training, intensity)? {

                return Ok(interrupted);

            }

        }

        if let ControlFlow::Break(interrupted) = self.hazards(intensity)? {

            return Ok(interrupted);

        }

        let mut statuses = Vec::new();

        for training in [a, b] {

            let result = self.roll(training, intensity, lube);

            if self.ended.is_some() {

                return result;

            }

            let status = match result {

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

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

            };

            statuses.push((training, status));

        }

        let mut xml = String::from(

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

        );

        for (training, status) in statuses {

            let _ = write!(

                xml,

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

                self.path(""),

                training.name(),

                status.as_u16(),

                crate::problem::reason(status),

            );

        }

        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 ready(&self, technique: Technique, lube: Option<Lube>) -> Result<(), Problem> {

        self.access(technique)?;

        match technique {

            Technique::Training(training) => Self::check_lube(training, lube),

            Technique::Utility(_) => Ok(()),

        }

    }

    /// Whether the run could attempt the technique now, ignoring the lubricant.

    fn access(&self, technique: Technique) -> Result<(), Problem> {

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

            return Err(Problem::new(

                StatusCode::FORBIDDEN,

                "technique-locked",

                "uli is discussed on the forum, in a thread from 2009, by a man who never posted again. You have not been to the forum.",

            ));

        }

        if technique == Technique::Utility(Utility::Meditate) {

            return if self.meditation_taught {

                Ok(())

            } else {

                Err(Problem::new(

                    StatusCode::FORBIDDEN,

                    "technique-locked",

                    "The breathing technique is described in one of the forum's replies. You have not found it.",

                ))

            };

        }

        if !self.warmed_up {

            return Err(Problem::new(

                StatusCode::PRECONDITION_FAILED,

                "cold-start",

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

            )

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

        }

        match technique {

            Technique::Utility(Utility::Pump) if !self.items.pump_pro => Err(Problem::new(

                StatusCode::FAILED_DEPENDENCY,

                "no-pump",

                "The pump technique depends on a pump.",

            )),

            Technique::Utility(_) => Ok(()),

            Technique::Training(training) => match training.profile().foreskin {

                Some((min, max)) => self.check_foreskin(min, max),

                None => Ok(()),

            },

        }

    }

    fn check_lube(training: Training, lube: Option<Lube>) -> Result<(), Problem> {

        match (training.profile().lube, lube) {

            (LubeRule::Required, None) => Err(Problem::new(

                StatusCode::UNSUPPORTED_MEDIA_TYPE,

                "lubricant-required",

                format!(

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

                    training.name()

                ),

            )

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

            (LubeRule::Forbidden, Some(_)) => Err(Problem::new(

                StatusCode::UNSUPPORTED_MEDIA_TYPE,

                "lubricant-declared",

                format!(

                    "The {} technique was requested. A lubricant was declared.",

                    training.name()

                ),

            )),

            _ => Ok(()),

        }

    }

    /// One unit of whatever was declared. Spit is free and the tap is always on.

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

        let (held, name) = match lube {

            None | Some(Lube::Spit) => return Ok(()),

            Some(Lube::BabyOil) => (&self.items.baby_oil, "baby-oil"),

            Some(Lube::CoconutOil) => (&self.items.coconut_oil, "coconut-oil"),

            Some(Lube::Lotion) => (&self.items.lotion, "lotion"),

            Some(Lube::Vaseline) => (&self.items.vaseline, "vaseline"),

        };

        if *held == 0 {

            return Err(Problem::new(

                StatusCode::UNSUPPORTED_MEDIA_TYPE,

                "lubricant-exhausted",

                format!("{name} was declared, but the bottle is empty."),

            ));

        }

        Ok(())

    }

    fn take_lube(&mut self, lube: Option<Lube>) -> Result<(), Problem> {

        self.lube_available(lube)?;

        let held = match lube {

            None | Some(Lube::Spit) => return Ok(()),

            Some(Lube::BabyOil) => &mut self.items.baby_oil,

            Some(Lube::CoconutOil) => &mut self.items.coconut_oil,

            Some(Lube::Lotion) => &mut self.items.lotion,

            Some(Lube::Vaseline) => &mut self.items.vaseline,

        };

        *held -= 1;

        Ok(())

    }

    /// The techniques a JELQ could use right now without being refused before the roll.

    pub fn techniques_now(&self, now: Instant) -> Vec<Technique> {

        let blocked = !self.floor.timed()

            || self.items.cage

            || self.refractory_until.is_some_and(|until| now < until);

        if blocked {

            return Vec::new();

        }

        Technique::ALL

            .into_iter()

            .filter(|&technique| match technique {

                Technique::Utility(Utility::Warmup) => true,

                Technique::Utility(Utility::Ice) => self.items.ice_packs > 0,

                Technique::Utility(Utility::Supplement) => self.items.supplements > 0,

                Technique::Utility(Utility::Meditate) => {

                    self.meditation_taught && !self.here.meditated

                }

                Technique::Utility(Utility::Energy) => self.items.energy_drinks > 0,

                _ => self.access(technique).is_ok() && self.check_storage().is_ok(),

            })

            .collect()

    }

    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, self.path("/foreskin")));

        };

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

        }

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

        }

        Ok(())

    }

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

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

            return Err(Problem::new(

                StatusCode::INSUFFICIENT_STORAGE,

                "jeans-full",

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

            )

            .with("extender", self.path("/inventory/extender")));

        }

        Ok(())

    }

    fn chafe(&mut self, lube: Option<Lube>) {

        let mut friction = match lube {

            None => FRICTION_DRY,

            Some(Lube::Spit) => FRICTION_SPIT,

            Some(_) => 0,

        };

        if friction > 0 && self.jelq_grip.is_some_and(|grip| grip != self.grip) {

            friction -= FRICTION_GRIP;

        }

        self.jelq_grip = Some(self.grip);

        self.friction = (self.friction + friction).min(FRICTION_MAX);

        if self.friction >= FRICTION_BURN_AT

            && !self.conditions.friction_burn

            && self.chance(FRICTION_BURN)

        {

            self.conditions.friction_burn = true;

        }

    }

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

        self.touch();

        self.turn += 1;

        self.here.turns += 1;

        self.realise();

        if self.items.extender {

            self.length += EXTENDER_GAIN;

        }

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

        if self.stamina <= 0 {

            self.exhaust(now);

        }

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

            CHANGING_ROOM_CHILL

        } else {

            0

        };

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

        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::ChangingRoom | Floor::Nans) {

            suspicion *= 2;

        }

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

            suspicion += 2;

        }

        let was_below = self.suspicion < SUSPICION_LIMIT;

        self.suspicion =

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

                .unwrap_or(SUSPICION_LIMIT);

        if intensity >= PULLED_MUSCLE_INTENSITY

            && !self.conditions.pulled_muscle

            && self.chance(PULLED_MUSCLE)

        {

            self.conditions.pulled_muscle = true;

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

        }

        self.settle(was_below);

    }

    /// The part of a turn the house takes part in, whatever the action was.

    pub(super) fn settle(&mut self, was_below: bool) {

        self.maybe_summon_mum(was_below);

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

            && self.chance(OBSERVED)

        {

            self.observed = Some(observer);

            self.shame += 1;

            if observer == Observer::Cat && self.chance(CAT_TAKES_TOWEL) {

                self.here.towel_stolen = true;

            }

        }

        if self.items.ring && self.eq > HOT_EQ && self.chance(RING_PRIAPISM) {

            self.conditions.priapism_turns = PRIAPISM_TURNS;

        }

        if self.conditions.priapism_turns > 0 {

            self.conditions.priapism_turns -= 1;

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

        }

        if self.turn == BRANCH_TURN && self.story == Story::Unopened {

            self.story = Story::Pending;

            self.notices

                .push("Somewhere, a forum thread from 2009 still has replies.");

        }

    }

    /// HOLD. A pause between strokes, offered when the band has been left or the stamina is gone.

    pub fn can_hold(&self) -> bool {

        self.eq > DANGER_EQ || self.stamina <= 2

    }

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

        self.check_refractory(now)?;

        if self.story == Story::Pending {

            return Ok(self.branch_offer());

        }

        if self.items.cage {

            return Err(Problem::new(

                StatusCode::LOCKED,

                "caged",