jelq

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

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

use rand::Rng;

use serde_json::json;

use super::{

    Cause, Floor, Outcome, Run,

    balance::{

        BURN_RUPTURE, COLD_EQ, CURVE_MISSES, DANGER_EQ, DEGLOVING, DEGLOVING_INTENSITY, FRIEND,

        HOT_EQ, PREMATURE_EQ, RUPTURE_HOT, RUPTURE_IN_BAND, RUPTURE_PREMATURE, RUPTURE_WARM,

        SUSPICION_LIMIT, WANDERER_VISIT, WINDOW,

    },

    techniques::Training,

};

use crate::problem::Problem;

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

impl Run {

    /// How far the friction burn drags the rupture tiers down.

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

        if self.conditions.friction_burn {

            BURN_RUPTURE

        } else {

            0

        }

    }

    /// 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.eq <= DANGER_EQ - self.burn() {

            RUPTURE_IN_BAND

        } else if self.eq <= HOT_EQ - self.burn() {

            RUPTURE_WARM

        } else {

            RUPTURE_HOT

        }

    }

    /// Accidents tied to a specific technique.

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

        if training == Training::Dry && intensity >= DEGLOVING_INTENSITY && self.chance(DEGLOVING) {

            return Err(self.end(Cause::Degloved));

        }

        Ok(ControlFlow::Continue(()))

    }

    /// Everything that can go wrong on a committed turn before the roll.

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

        let burn = self.burn();

        if self.eq <= PREMATURE_EQ - burn && self.chance(self.rupture_odds()) {

            return Err(self.rupture());

        }

        if self.floor.has_window() && !self.items.blinds && self.chance(WINDOW) {

            self.shame += 30;

            self.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(FRIEND) {

            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.conditions.peyronie && self.chance(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 <= 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 > PREMATURE_EQ - burn {

            if self.chance(RUPTURE_PREMATURE) {

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

            ));

        }

        if self.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.suspicion) + 1;

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

            && self.rng.random_ratio(visits, WANDERER_VISIT);

        if self.suspicion < SUSPICION_LIMIT && !wanders_in {

            return Ok(());

        }

        match self.floor {

            Floor::Bathroom => {

                self.suspicion = 0;

                self.touch();

                if self.items.door_locks > 0 {

                    self.items.door_locks -= 1;

                    self.notices.push("your brother tried the door");

                    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.suspicion = 0;

                self.shame += 5;

                self.touch();

                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.suspicion = 0;

                self.touch();

                if self.items.dnd_sign {

                    self.notices.push("housekeeping read the sign");

                    return Ok(());

                }

                self.shame += 3;

                Err(Problem::new(

                    StatusCode::UNAUTHORIZED,

                    "housekeeping",

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

                )

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

            }

            _ => Ok(()),

        }

    }

}