jelq

use axum::http::StatusCode;

use crate::problem::Problem;

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

#[repr(u8)]

pub enum Floor {

    Bedroom = 1,

    Bathroom = 2,

    ChangingRoom = 3,

    Nans = 4,

    Hotel = 5,

    Forum = 6,

    Clinic = 7,

}

impl Floor {

    pub fn number(self) -> u8 {

        self as u8

    }

    pub fn next(self) -> Option<Self> {

        match self {

            Self::Bedroom => Some(Self::Bathroom),

            Self::Bathroom => Some(Self::ChangingRoom),

            Self::ChangingRoom => Some(Self::Nans),

            Self::Nans => Some(Self::Hotel),

            Self::Hotel => Some(Self::Forum),

            Self::Forum => Some(Self::Clinic),

            Self::Clinic => None,

        }

    }

    pub fn name(self) -> &'static str {

        match self {

            Self::Bedroom => "the bedroom",

            Self::Bathroom => "the shared bathroom",

            Self::ChangingRoom => "the gym changing room",

            Self::Nans => "Nan's house at Christmas",

            Self::Hotel => "a business trip hotel",

            Self::Forum => "the forum",

            Self::Clinic => "the urologist's office",

        }

    }

    pub fn note(self) -> &'static str {

        match self {

            Self::Bedroom => "The door does not lock. The cat is present.",

            Self::Bathroom => "The water is hot. Your brother showers at eight.",

            Self::ChangingRoom => {

                "It is cold. Discretion is advised. Everyone here is lying. Pump-Bro is by the lockers."

            }

            Self::Nans => {

                "The walls are thin. Mum is here, and she has been reading about Digest authentication."

            }

            Self::Hotel => {

                "The wifi requires agreement. Housekeeping does not knock. Pump-Bro is in the lobby."

            }

            Self::Forum => "Nothing physical happens here. The Elder has a spreadsheet.",

            Self::Clinic => "The urologist will see you now. He is bored.",

        }

    }

    pub fn observer(self) -> Option<Observer> {

        match self {

            Self::Bedroom => Some(Observer::Cat),

            Self::ChangingRoom => Some(Observer::Greg),

            Self::Nans => Some(Observer::Nan),

            _ => None,

        }

    }

    pub fn has_mum(self) -> bool {

        matches!(self, Self::Bedroom | Self::Nans)

    }

    pub fn has_window(self) -> bool {

        matches!(self, Self::Bedroom | Self::Nans | Self::Hotel)

    }

    pub fn shop_open(self) -> bool {

        matches!(self, Self::ChangingRoom | Self::Hotel)

    }

    pub fn has_kitchen(self) -> bool {

        matches!(self, Self::Bedroom | Self::Nans)

    }

    pub fn timed(self) -> bool {

        !matches!(self, Self::Forum | Self::Clinic)

    }

}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Observer {

    Cat,

    Greg,

    Nan,

}

impl Observer {

    pub fn name(self) -> &'static str {

        match self {

            Self::Cat => "cat",

            Self::Greg => "greg",

            Self::Nan => "nan",

        }

    }

}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Grip {

    Overhand,

    Underhand,

}

impl Grip {

    pub fn name(self) -> &'static str {

        match self {

            Self::Overhand => "overhand",

            Self::Underhand => "underhand",

        }

    }

    pub fn parse(protocol: &str) -> Option<Self> {

        match protocol.to_ascii_lowercase().as_str() {

            "overhand" => Some(Self::Overhand),

            "underhand" => Some(Self::Underhand),

            _ => None,

        }

    }

}

/// State that belongs to the current floor and resets when you leave it.

#[derive(Default)]

pub struct FloorState {

    pub turns: u32,

    pub drawer_searched: bool,

    pub edges: u8,

    pub temp_length: f64,

    pub teapot: bool,

    pub towel_stolen: bool,

    pub brother_told: bool,

    pub shopping: bool,

    pub meditated: bool,

    pub melon_offered: bool,

    pub warm_arrival: bool,

    pub wifi_accepted: bool,

}

#[derive(Default)]

pub struct Conditions {

    pub peyronie: bool,

    pub pulled_muscle: bool,

    pub priapism_turns: u8,

    pub friction_burn: bool,

}

pub struct MumVisit {

    pub errand: &'static str,

    pub nonce: String,

    pub strikes: u8,

    pub knocked: bool,

}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Elder {

    Unverified { strikes: u8 },

    Verified,

    Beaten,

}

#[derive(Default)]

pub struct Clinic {

    pub intake_attempts: usize,

    pub measured: bool,

    pub cured: bool,

}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Story {

    Unopened,

    Pending,

    ReadForum,

    ClosedTab,

}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Cause {

    Ruptured { ice_unused: bool },

    Caught,

    Opened,

    Banned,

    Degloved,

    Zip,

    Meloned,

    Abandoned,

}

impl Cause {

    pub fn slug(self) -> &'static str {

        match self {

            Self::Ruptured { .. } => "vascular-event",

            Self::Caught => "caught",

            Self::Opened => "opened",

            Self::Banned => "banned",

            Self::Degloved => "degloved",

            Self::Zip => "zip",

            Self::Meloned => "watermelon",

            Self::Abandoned => "abandoned",

        }

    }

    pub fn detail(self) -> &'static str {

        match self {

            Self::Ruptured { ice_unused: true } => {

                "A vessel has exceeded its rated pressure. The run has ended. An ice pack was available and was not used."

            }

            Self::Ruptured { ice_unused: false } => {

                "A vessel has exceeded its rated pressure. The run has ended."

            }

            Self::Caught => {

                "Mum has seen enough. The run has ended. Nobody will mention it at dinner."

            }

            Self::Opened => {

                "Mum has stopped knocking and opened the door. The run has ended. Nobody will mention it at dinner."

            }

            Self::Banned => "Your account has been banned. The forum can tell. The run has ended.",

            Self::Degloved => {

                "The outer layer has been removed in one piece. It will not be returning. The run has ended."

            }

            Self::Zip => {

                "The request conflicts with the current state of the zip. The run has ended."

            }

            Self::Meloned => {

                "You have been caught with the watermelon. Nobody will mention it at dinner. The run has ended."

            }

            Self::Abandoned => "The run was abandoned.",

        }

    }

    fn status(self) -> StatusCode {

        match self {

            Self::Ruptured { .. } => StatusCode::INTERNAL_SERVER_ERROR,

            Self::Caught | Self::Opened | Self::Degloved | Self::Abandoned => StatusCode::GONE,

            Self::Meloned => StatusCode::GONE,

            Self::Banned => StatusCode::FORBIDDEN,

            Self::Zip => StatusCode::CONFLICT,

        }

    }

    pub fn problem(self) -> Problem {

        Problem::new(self.status(), self.slug(), self.detail())

    }

}

pub struct Ending {

    pub cause: Cause,

    pub turn: u32,

}

pub struct Pending {

    pub due: u32,

    pub length: f64,

    pub girth: f64,

}