jelq

use super::{

    Arousal, Run,

    balance::{FRICTION_BURN_AT, FRICTION_MAX, LOW_STAMINA, SUSPICION_LIMIT},

};

/// How close a gauge is to hurting the run, so a client can flag it without knowing the balance.

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

pub enum Danger {

    Dangerous,

    Critical,

}

impl Danger {

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

        match self {

            Self::Dangerous => "dangerous",

            Self::Critical => "critical",

        }

    }

}

impl Arousal {

    fn danger(self) -> Option<Danger> {

        match self {

            Self::Cold | Self::Swollen | Self::Throbbing => Some(Danger::Dangerous),

            Self::Straining | Self::Imminent | Self::Priapic => Some(Danger::Critical),

            Self::Flaccid | Self::Warm | Self::Ideal => None,

        }

    }

}

impl Run {

    pub(super) fn dangers(&self) -> Vec<(&'static str, Danger)> {

        let friction = if self.body.friction >= FRICTION_MAX || self.body.conditions.friction_burn {

            Some(Danger::Critical)

        } else {

            (self.body.friction >= FRICTION_BURN_AT).then_some(Danger::Dangerous)

        };

        let stamina = if self.body.stamina <= 0 {

            Some(Danger::Critical)

        } else {

            (self.body.stamina <= LOW_STAMINA).then_some(Danger::Dangerous)

        };

        let suspicion = if self.standing.suspicion + 1 >= SUSPICION_LIMIT {

            Some(Danger::Critical)

        } else {

            (self.standing.suspicion + 2 >= SUSPICION_LIMIT).then_some(Danger::Dangerous)

        };

        [

            ("friction", friction),

            ("eq", self.arousal().danger()),

            ("stamina", stamina),

            ("suspicion", suspicion),

        ]

        .into_iter()

        .filter_map(|(gauge, danger)| Some((gauge, danger?)))

        .collect()

    }

}