jelq

use axum::http::StatusCode;

use super::{

    Outcome, Run,

    balance::{GIRTH_RESPECTED, GIRTH_THICK, LOCKER_ROOM_BAR, MAX_STAMINA, STARTING_EQ},

    credentials::etag_matches,

};

use crate::problem::Problem;

pub struct Body {

    pub(crate) length: f64,

    pub(crate) girth: f64,

    pub(crate) foreskin: Option<f64>,

    pub(crate) eq: i32,

    pub(crate) stamina: i32,

    pub(crate) friction: i32,

    pub(crate) grip: Grip,

    /// The grip of the last stroke, which decides whether this one gets the switching discount.

    pub(crate) jelq_grip: Option<Grip>,

    pub(crate) warmed_up: bool,

    pub(crate) exhausted: bool,

    pub(crate) put_applied: bool,

    pub(crate) conditions: Conditions,

    pub(crate) pending: Vec<Pending>,

}

impl Body {

    pub fn new(length: f64, girth: f64, foreskin: f64) -> Self {

        Self {

            length,

            girth,

            foreskin: Some(foreskin),

            eq: STARTING_EQ,

            stamina: MAX_STAMINA,

            friction: 0,

            grip: Grip::Overhand,

            jelq_grip: None,

            warmed_up: false,

            exhausted: false,

            put_applied: false,

            conditions: Conditions::default(),

            pending: Vec::new(),

        }

    }

}

#[derive(Default)]

pub struct Conditions {

    pub(crate) peyronie: bool,

    pub(crate) pulled_muscle: bool,

    pub(crate) priapism_turns: u8,

    pub(crate) friction_burn: bool,

}

/// Gains a `202` promised, due on a later turn.

pub struct Pending {

    pub(crate) due: u32,

    pub(crate) length: f64,

    pub(crate) girth: f64,

    pub(crate) foreskin: f64,

}

#[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",

        }

    }

}

impl std::str::FromStr for Grip {

    type Err = ();

    fn from_str(protocol: &str) -> Result<Self, ()> {

        match protocol.to_ascii_lowercase().as_str() {

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

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

            _ => Err(()),

        }

    }

}

impl Run {

    pub fn delete_foreskin(&mut self, if_match: Option<&str>) -> Result<Outcome, Problem> {

        if self.body.foreskin.is_none() {

            return Err(Problem::new(

                StatusCode::GONE,

                "foreskin-gone",

                "The foreskin is gone. It will not be returning.",

            ));

        }

        let Some(if_match) = if_match else {

            return Err(Problem::new(

                StatusCode::PRECONDITION_REQUIRED,

                "confirmation-required",

                "The server requires you to be sure. Send If-Match.",

            ));

        };

        if !etag_matches(if_match, &self.etag()) {

            return Err(Problem::new(

                StatusCode::PRECONDITION_FAILED,

                "stale-foreskin",

                "The foreskin has changed since you last looked at it.",

            ));

        }

        self.body.foreskin = None;

        self.standing.shame += 20;

        self.touch();

        Ok(Outcome::empty(StatusCode::NO_CONTENT))

    }

    pub fn set_grip(&mut self, grip: Grip) -> Result<(), Problem> {

        self.grip_closes(grip)?;

        self.body.grip = grip;

        self.touch();

        Ok(())

    }

    pub(super) fn grip_closes(&self, grip: Grip) -> Result<(), Problem> {

        if grip == Grip::Underhand && self.body.girth > GIRTH_THICK {

            return Err(Problem::new(

                StatusCode::PAYLOAD_TOO_LARGE,

                "grip-too-small",

                format!(

                    "The underhand grip no longer closes around {:.2} inches of girth.",

                    self.body.girth

                ),

            )

            .with("maximum", GIRTH_THICK));

        }

        Ok(())

    }

    /// Everyone in the changing room self-reports, so the comparison is self-report against self-report.

    pub fn holds_own_in_the_locker_room(&self) -> bool {

        self.self_reported() >= LOCKER_ROOM_BAR

    }

    pub fn girth_respected(&self) -> bool {

        self.body.girth >= GIRTH_RESPECTED

    }

}