jelq

use super::{

    Floor, Lube, MumVisit, Notice, Observer, Run, Story,

    balance::{

        BRANCH_TURN, CAT_TAKES_TOWEL, CHANGING_ROOM_CHILL, EQ_WOBBLE, EXTENDER_GAIN,

        FORESKIN_GLIDE, FRICTION_BURN, FRICTION_BURN_AT, FRICTION_COLD, FRICTION_DRY,

        FRICTION_GRIP, FRICTION_MAX, FRICTION_SPIT, GIRTH_THICK, HOT_EQ, OBSERVED, PRIAPISM_EQ,

        PRIAPISM_TURNS, PULLED_MUSCLE, PULLED_MUSCLE_INTENSITY, RING_PRIAPISM, RING_TIGHT_PRIAPISM,

        STROKE_EQ, STROKE_EQ_COST, SUSPICION_LIMIT, VIGOUR,

    },

};

use crate::problem::Problem;

impl Run {

    pub(super) fn chafe(&mut self, lube: Option<Lube>, intensity: i32, cold: bool) {

        let (base, slip) = match lube {

            None => (FRICTION_DRY, 0),

            Some(Lube::Spit) => (FRICTION_SPIT, 0),

            Some(Lube::Lotion) => (0, 0),

            Some(Lube::BabyOil | Lube::CoconutOil) => (0, 1),

            Some(Lube::Vaseline) => (0, 2),

        };

        let vigour = usize::try_from(intensity - 1).map_or(0, |i| VIGOUR[i.min(VIGOUR.len() - 1)]);

        let unlubed = matches!(lube, None | Some(Lube::Spit));

        let thick = i32::from(unlubed && self.body.girth > GIRTH_THICK);

        let glide = i32::from(unlubed && self.body.foreskin.is_some_and(|f| f >= FORESKIN_GLIDE));

        let mut friction = (base + vigour + thick - slip - glide).max(0);

        if friction > 0

            && self

                .body

                .jelq_grip

                .is_some_and(|grip| grip != self.body.grip)

        {

            friction -= FRICTION_GRIP;

        }

        if cold {

            friction += FRICTION_COLD;

        }

        self.body.jelq_grip = Some(self.body.grip);

        self.body.friction = (self.body.friction + friction).min(FRICTION_MAX);

        if self.body.friction >= FRICTION_BURN_AT

            && !self.body.conditions.friction_burn

            && self.chance(

                self.decision(

                    "friction-burn",

                    "With the skin this raw, has it finally burned?",

                ),

                FRICTION_BURN,

            )

        {

            self.body.conditions.friction_burn = true;

        }

    }

    pub(super) fn commit(

        &mut self,

        intensity: i32,

        lube: Option<Lube>,

        cost: i32,

    ) -> Result<(), Problem> {

        self.begin_turn()?;

        self.step_away();

        if self.items.kit.extender {

            self.body.length += EXTENDER_GAIN;

        }

        self.body.stamina -= cost + i32::from(lube == Some(Lube::Lotion));

        if self.body.stamina <= 0 {

            self.exhaust();

        }

        let chill = if self.floor == Floor::ChangingRoom {

            CHANGING_ROOM_CHILL

        } else {

            0

        };

        let wobble = self.oracle.span_int(

            self.decision(

                "wobble",

                "How does the count drift on this stroke, up or down?",

            ),

            -EQ_WOBBLE,

            EQ_WOBBLE,

        );

        self.body.eq =

            (self.body.eq + intensity * STROKE_EQ - STROKE_EQ_COST - chill + wobble).clamp(0, 100);

        self.make_noise(intensity / 5 + i32::from(lube == Some(Lube::Vaseline)));

        if self.floor == Floor::Nans && lube == Some(Lube::CoconutOil) {

            self.add_suspicion(2);

        }

        if intensity >= PULLED_MUSCLE_INTENSITY

            && !self.body.conditions.pulled_muscle

            && self.oracle.chance_not(

                self.decision("pulled-muscle", "Do the muscles hold?"),

                PULLED_MUSCLE,

            )

        {

            self.body.conditions.pulled_muscle = true;

            self.body.stamina = self.body.stamina.min(self.max_stamina());

        }

        self.settle();

        Ok(())

    }

    pub(super) fn make_noise(&mut self, noise: i32) {

        let doubled = match self.floor {

            Floor::Nans => true,

            Floor::ChangingRoom => !self.holds_own_in_the_locker_room(),

            _ => false,

        };

        self.add_suspicion(if doubled { noise * 2 } else { noise });

    }

    pub(super) fn add_suspicion(&mut self, amount: i32) {

        self.standing.suspicion = u8::try_from(

            (i32::from(self.standing.suspicion) + amount).clamp(0, i32::from(SUSPICION_LIMIT)),

        )

        .unwrap_or(SUSPICION_LIMIT);

    }

    pub(super) fn settle(&mut self) {

        self.maybe_summon_mum();

        if let Some(observer) = self.floor.observer()

            && self.chance(

                self.decision("observed", "Has someone quietly noticed what is going on?"),

                OBSERVED,

            )

        {

            self.observed = Some(observer);

            self.standing.shame += 1;

            if observer == Observer::Cat

                && self.chance(

                    self.decision("cat-takes-towel", "Has the cat taken the towel?"),

                    CAT_TAKES_TOWEL,

                )

            {

                self.here.towel_stolen = true;

            }

        }

        if self.items.kit.ring

            && self.body.eq > HOT_EQ

            && self.chance(

                self.decision(

                    "ring-priapism",

                    "With the ring still on and everything this warm, will it not go down?",

                ),

                if self.body.girth > GIRTH_THICK {

                    RING_TIGHT_PRIAPISM

                } else {

                    RING_PRIAPISM

                },

            )

        {

            self.body.conditions.priapism_turns = PRIAPISM_TURNS;

        }

        if self.body.conditions.priapism_turns > 0 {

            self.body.conditions.priapism_turns -= 1;

            self.body.eq = self.body.eq.max(PRIAPISM_EQ);

        }

        if self.turn == BRANCH_TURN && self.online.story == Story::Unopened {

            self.online.story = Story::Pending;

            self.notices.push(Notice::ThreadHasReplies);

        }

    }

    pub(super) fn maybe_summon_mum(&mut self) {

        let was_below = self.standing.at_turn_start < SUSPICION_LIMIT;

        if !self.floor.has_mum() || self.household.mum.is_some() {

            return;

        }

        let summoned = was_below && self.standing.suspicion == SUSPICION_LIMIT;

        let mut visits = u32::from(self.standing.suspicion) + 1;

        if self.here.brother_told {

            visits *= 2;

        }

        if summoned

            || self.oracle.ratio(

                self.decision(

                    "mum-summon",

                    "With this much noise in the house, is Mum on her way up?",

                ),

                visits,

                super::balance::MUM_VISIT,

            )

        {

            let errand = self.errand(summoned);

            let nonce = self.fresh_nonce();

            self.household.mum = Some(MumVisit {

                errand,

                nonce,

                strikes: 0,

                knocked: false,

            });

        }

    }

}