jelq

use std::{ops::ControlFlow, time::SystemTime};

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

use serde_json::json;

use super::{

    Cause, Floor, Notice, Outcome, Run,

    balance::{

        BURN_RUPTURE, COLD_DEGLOVING, COLD_EQ, CURVE_MISSES, DANGER_EQ, DEGLOVING,

        DEGLOVING_INTENSITY, EQ_BAND, FRICTION_MAX, FRICTION_TEAR, FRIEND, HOT_EQ, LOST_IT_EQ,

        PREMATURE_EQ, RAW_DEGLOVING, RUPTURE_HOT, RUPTURE_IN_BAND, RUPTURE_PREMATURE, RUPTURE_WARM,

        SOFT_INTENSITY, SUSPICION_LIMIT, WANDERER_VISIT, WINDOW,

    },

    measure::round3,

    techniques::Training,

    travel::Exit,

};

use crate::problem::Problem;

type Interruption = Result<ControlFlow<Outcome>, Problem>;

impl Run {

    /// EQ with a friction burn dragging every line down.

    pub(super) fn heat(&self) -> i32 {

        let burn = if self.body.conditions.friction_burn {

            BURN_RUPTURE

        } else {

            0

        };

        self.body.eq + burn

    }

    pub(super) fn hotter_than(&self, line: i32) -> bool {

        self.heat() > line

    }

    /// Ruptures go by the cooler of now and the turn's start, so a line crossed this turn cannot rupture

    /// before `X-EQ` has had a chance to name it.

    pub(super) fn risked(&self, line: i32) -> bool {

        self.heat().min(self.body.heat_at_turn_start) > line

    }

    /// The rupture tier for any turn that is not a jelq, so never the premature band's 1 in 3.

    pub(super) fn rupture_odds(&self) -> u32 {

        if !self.risked(DANGER_EQ) {

            RUPTURE_IN_BAND

        } else if !self.risked(HOT_EQ) {

            RUPTURE_WARM

        } else {

            RUPTURE_HOT

        }

    }

    pub(super) fn cold(&self) -> bool {

        self.body.eq < COLD_EQ

    }

    pub(super) fn mishaps(

        &mut self,

        training: Training,

        intensity: i32,

        cold: bool,

    ) -> Interruption {

        if cold {

            if !self.notices.contains(&Notice::ColdStart) {

                self.notices.push(Notice::ColdStart);

            }

            if self.chance(

                self.decision("cold-degloving", "Cold and unprepared, does the skin tear?"),

                COLD_DEGLOVING,

            ) {

                return Err(self.deglove());

            }

        }

        if self.body.friction >= FRICTION_MAX {

            self.tear()?;

        }

        if training == Training::Dry

            && intensity >= DEGLOVING_INTENSITY

            && self.chance(

                self.decision("degloving", "Dry at this intensity, does the skin tear?"),

                DEGLOVING,

            )

        {

            return Err(self.deglove());

        }

        Ok(ControlFlow::Continue(()))

    }

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

        if !self.notices.contains(&Notice::SkinGivingWay) {

            self.notices.push(Notice::SkinGivingWay);

        }

        match self.body.foreskin {

            Some(left) if left - FRICTION_TEAR > 1e-9 => {

                self.body.foreskin = Some(left - FRICTION_TEAR);

                self.body.torn += FRICTION_TEAR;

                Ok(())

            }

            Some(left) => {

                self.body.foreskin = None;

                self.standing.shame += 25;

                Err(Problem::new(

                    StatusCode::GONE,

                    "foreskin-lost",

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

                )

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

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

            }

            None => {

                if self.chance(

                    self.decision("raw-degloving", "Rubbed raw, does the skin tear?"),

                    RAW_DEGLOVING,

                ) {

                    return Err(self.deglove());

                }

                Ok(())

            }

        }

    }

    fn deglove(&mut self) -> Problem {

        let lost = self.body.foreskin.take();

        let problem = self.end(Cause::Degloved);

        match lost {

            Some(lost) => problem.with("foreskin", -round3(lost)),

            None => problem,

        }

    }

    pub(super) fn hazards(&mut self, intensity: i32) -> Interruption {

        if !self.hotter_than(PREMATURE_EQ)

            && self.chance(

                self.decision("rupture", "Does this jelq rupture something?"),

                self.rupture_odds(),

            )

        {

            return Err(self.rupture());

        }

        if self.floor.has_window()

            && !self.items.kit.blinds

            && self.oracle.chance_not(

                self.decision("window", "Are the curtains still closed?"),

                WINDOW,

            )

        {

            self.standing.shame += 30;

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

            return Ok(ControlFlow::Break(

                Outcome::json(

                    StatusCode::CREATED,

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

                )

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

            ));

        }

        if self.floor == Floor::ChangingRoom

            && self.chance(

                self.decision("friend", "Does a friend walk in and offer to help?"),

                FRIEND,

            )

        {

            self.standing.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.body.conditions.peyronie

            && self.chance(

                self.decision(

                    "misdirected",

                    "With the curve, does the stroke land sharply to the left?",

                ),

                CURVE_MISSES,

            )

        {

            return Err(Problem::new(

                StatusCode::MISDIRECTED_REQUEST,

                "misdirected",

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

            ));

        }

        if intensity <= SOFT_INTENSITY && self.body.eq < *EQ_BAND.start() {

            self.body.eq = (self.body.eq - LOST_IT_EQ).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.hotter_than(PREMATURE_EQ) {

            if self.risked(PREMATURE_EQ)

                && self.chance(

                    self.decision(

                        "rupture",

                        "Right at the edge of finishing, does it rupture instead?",

                    ),

                    RUPTURE_PREMATURE,

                )

            {

                return Err(self.rupture());

            }

            self.standing.shame += 5;

            self.next_floor(Exit::Premature);

            return Err(Problem::new(

                StatusCode::TOO_EARLY,

                "premature",

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

            ));

        }

        Ok(ControlFlow::Continue(()))

    }

    /// The enemies suspicion summons on floors without Mum.

    pub(super) fn floor_enemy(&mut self) -> Result<(), Problem> {

        let visits = u32::from(self.standing.suspicion) + 1;

        let wanders_in = matches!(self.floor, Floor::Bathroom | Floor::Hotel)

            && self.oracle.ratio_choice(

                self.decision("wanderer", "Does anyone else come through the door?"),

                visits,

                WANDERER_VISIT,

                "No",

                "Yes",

            );

        if self.standing.suspicion < SUSPICION_LIMIT && !wanders_in {

            return Ok(());

        }

        match self.floor {

            Floor::Bathroom => {

                self.standing.suspicion = 0;

                self.touch();

                if self.items.stores.door_locks > 0 {

                    self.items.stores.door_locks -= 1;

                    self.notices.push(Notice::BrotherTriedTheDoor);

                    return Ok(());

                }

                self.here.brother_told = true;

                Err(Problem::new(

                    StatusCode::CONFLICT,

                    "brother",

                    "Your brother needs the bathroom. He will tell Mum.",

                ))

            }

            Floor::ChangingRoom => {

                self.standing.suspicion = 0;

                self.touch();

                if self.girth_respected() {

                    self.notices.push(Notice::GymStaffLeaveIt);

                    return Ok(());

                }

                self.standing.shame += 5;

                Err(Problem::new(

                    StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS,

                    "gym-staff",

                    "Gym staff have been notified. The server cannot serve this request for legal reasons.",

                ))

            }

            Floor::Hotel => {

                self.standing.suspicion = 0;

                self.touch();

                if self.items.kit.dnd_sign {

                    self.notices.push(Notice::HousekeepingReadTheSign);

                    return Ok(());

                }

                self.standing.shame += 3;

                Err(Problem::new(

                    StatusCode::UNAUTHORIZED,

                    "housekeeping",

                    "Housekeeping has entered. Housekeeping accepts no excuses.",

                )

                .header(header::WWW_AUTHENTICATE, "Excuse realm=\"housekeeping\""))

            }

            _ => Ok(()),

        }

    }

}