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, FRIEND, HOT_EQ, LOST_IT_EQ, PREMATURE_EQ, 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 {

    /// Whether EQ is past `line`, with a friction burn dragging every line down.

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

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

            BURN_RUPTURE

        } else {

            0

        };

        self.body.eq > line - burn

    }

    /// 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.hotter_than(DANGER_EQ) {

            RUPTURE_IN_BAND

        } else if !self.hotter_than(HOT_EQ) {

            RUPTURE_WARM

        } else {

            RUPTURE_HOT

        }

    }

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

        if !self.body.warmed_up {

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

            ));

        }

        if self.body.eq < COLD_EQ {

            return Err(Problem::new(

                StatusCode::NOT_FOUND,

                "cold",

                "The resource exists. It is cold.",

            ));

        }

        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(()),

        }

    }

}