jelq

use super::{

    Grip, Lube, Outcome, Run,

    balance::{

        ARRIVAL_BONUS, BAND_BONUS, CLEAN_HIT, DANGER_EQ, EQ_BAND, GREED_HOT, GREED_WARM, HOT_EQ,

        NEAR_MISS, QUEUED_ETA, UNDERHAND_STRETCH, UNDERHAND_WET,

    },

    body::Pending,

    measure::round3,

    techniques::{Profile, Training},

};

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

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

use serde_json::{Value, json};

fn gains(detail: &str, length: f64, girth: f64, foreskin: Option<f64>) -> Value {

    let mut body = json!({ "detail": detail, "length": round3(length), "girth": round3(girth) });

    if let Some(foreskin) = foreskin {

        body["foreskin"] = json!(round3(foreskin));

    }

    body

}

impl Run {

    pub(super) fn roll(

        &mut self,

        training: Training,

        intensity: i32,

        lube: Option<Lube>,

    ) -> Result<Outcome, Problem> {

        let profile = training.profile();

        let natural: i32 = self.oracle.span_int(

            self.decision(

                "natural",

                "What does the twenty-sided die show for this technique?",

            ),

            1,

            20,

        );

        let modifier = self.modifier(training, lube);

        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 (length, girth) = self.scaled_gains(&profile, intensity);

        let rupture_line = self.rupture_line();

        if natural == 1 {

            return Err(timed(self.critical_failure(training, &profile)));

        }

        self.here.warm_arrival = false;

        if natural == 2 && self.risked(DANGER_EQ) {

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

        }

        if self.risked(rupture_line) && total < dc {

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

        }

        if natural == 20 {

            let foreskin = self.gain(length * 2.0, girth * 2.0, profile.foreskin_growth);

            return Ok(Outcome::json(

                StatusCode::PERMANENT_REDIRECT,

                gains(

                    "Your length has moved permanently.",

                    length * 2.0,

                    girth * 2.0,

                    foreskin,

                ),

            )

            .header(header::LOCATION, self.path("/length"))

            .header(SERVER_TIMING, timing));

        }

        if total < dc - NEAR_MISS {

            return Err(timed(not_extended()));

        }

        if total < dc {

            return Ok(Outcome::empty(StatusCode::NO_CONTENT).header(SERVER_TIMING, timing));

        }

        Ok(self

            .land(&profile, length, girth, total >= dc + CLEAN_HIT)

            .header(SERVER_TIMING, timing))

    }

    fn modifier(&self, training: Training, lube: Option<Lube>) -> i32 {

        let band = if EQ_BAND.contains(&self.body.eq) {

            BAND_BONUS

        } else {

            0

        };

        let grip = match (self.body.grip, training) {

            (Grip::Underhand, Training::Stretch) => UNDERHAND_STRETCH,

            (Grip::Underhand, Training::Wet) => UNDERHAND_WET,

            _ => 0,

        };

        let arrival = if self.here.warm_arrival {

            ARRIVAL_BONUS

        } else {

            0

        };

        lube.map_or(0, Lube::modifier) + band + grip + arrival

    }

    fn land(&mut self, profile: &Profile, length: f64, girth: f64, clean: bool) -> Outcome {

        if self.body.eq < *EQ_BAND.start() {

            let foreskin = self.gain(length / 2.0, girth / 2.0, profile.foreskin_growth);

            Outcome::json(

                StatusCode::PARTIAL_CONTENT,

                gains(

                    "Partial gains were applied. EQ was short of Ideal.",

                    length / 2.0,

                    girth / 2.0,

                    foreskin,

                ),

            )

        } else if clean {

            let foreskin = self.gain(length, girth, profile.foreskin_growth);

            Outcome::json(

                StatusCode::OK,

                gains("Gains were applied.", length, girth, foreskin),

            )

        } else {

            let eta = self.oracle.span_int(

                self.decision("eta", "In how many turns will the queued gains arrive?"),

                *QUEUED_ETA.start(),

                *QUEUED_ETA.end(),

            );

            self.body.pending.push(Pending {

                due: self.turn + eta.unsigned_abs(),

                length,

                girth,

                foreskin: profile.foreskin_growth,

            });

            let mut body = json!({

                "detail": "Gains have been queued. They may arrive.",

            });

            let torn = std::mem::take(&mut self.body.torn);

            if torn > 0.0 {

                body["foreskin"] = json!(-round3(torn));

            }

            Outcome::json(StatusCode::ACCEPTED, body)

        }

    }

    pub(super) fn scaled_gains(&self, profile: &Profile, intensity: i32) -> (f64, f64) {

        let scale = f64::from(intensity);

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

        let greed = if self.body.eq > HOT_EQ {

            GREED_HOT

        } else if self.body.eq > DANGER_EQ {

            GREED_WARM

        } else {

            1.0

        };

        length *= greed;

        girth *= greed;

        if self.here.teapot {

            length *= 0.5;

            girth *= 1.5;

        }

        if self.items.kit.ring {

            girth *= 2.0;

        }

        if self.body.conditions.friction_burn {

            length *= 0.5;

            girth *= 0.5;

        }

        (length, girth)

    }

    pub(super) fn critical_failure(&mut self, training: Training, profile: &Profile) -> Problem {

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

        if uses_foreskin && let Some(lost) = self.body.foreskin.take() {

            self.standing.shame += 25;

            return Problem::new(

                StatusCode::GONE,

                "foreskin-lost",

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

            )

            .with("foreskin", -round3(lost))

            .header(header::CONTENT_LOCATION, self.path("/foreskin"));

        }

        if self.risked(DANGER_EQ) {

            return self.rupture();

        }

        if training == Training::Stretch && !self.here.teapot {

            self.here.teapot = true;

            self.items.kit.teapot_spout = true;

            self.standing.shame += 5;

            return Problem::new(

                StatusCode::IM_A_TEAPOT,

                "teapot",

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

            );

        }

        if training == Training::Uli && !self.body.conditions.peyronie {

            self.body.conditions.peyronie = true;

            self.standing.shame += 5;

            return Problem::new(

                StatusCode::MISDIRECTED_REQUEST,

                "curvature",

                "A curvature has developed. Techniques will land slightly to the left until a professional is consulted.",

            );

        }

        not_extended()

    }

    pub(super) fn gossip(&mut self, outcome: Outcome) -> Outcome {

        let reportable = matches!(outcome.status().as_u16(), 200 | 202 | 206 | 308);

        if !self.here.brother_told || !reportable {

            return outcome;

        }

        self.here.brother_told = false;

        outcome.retold(

            StatusCode::ALREADY_REPORTED,

            "Your brother has already told Mum.",

        )

    }

}

pub(super) fn not_extended() -> Problem {

    Problem::new(

        StatusCode::NOT_EXTENDED,

        "not-extended",

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

    )

}