jelq

use super::{

    Notice, Outcome, Run, Story,

    balance::{

        DANGER_EQ, FRICTION_HOLD, FRICTION_MEDITATE, HOLD_EQ, MEDITATION_EQ, REFLECTION,

        RUPTURE_HOLD,

    },

};

use crate::problem::Problem;

use axum::http::StatusCode;

use serde_json::json;

impl Run {

    pub fn can_hold(&self) -> bool {

        self.hotter_than(DANGER_EQ) || self.body.stamina <= 2

    }

    pub fn hold(&mut self) -> Result<Outcome, Problem> {

        if self.online.story == Story::Pending {

            return Ok(self.branch_offer());

        }

        if self.items.kit.cage {

            return Err(Problem::new(

                StatusCode::LOCKED,

                "caged",

                "The cage is locked. The key is not in the box.",

            ));

        }

        self.begin_turn()?;

        if self.oracle.chance_not(

            self.decision("rupture", "The pause is uneventful"),

            RUPTURE_HOLD,

        ) {

            return Err(self.rupture());

        }

        if self.body.exhausted {

            let second_wind = self.recover();

            self.shed(FRICTION_HOLD);

            self.settle();

            let back = if second_wind {

                "The count went well past ten, and something came back that had no business coming back. Stamina is full."

            } else {

                "The count went well past ten. Some of the stamina is back."

            };

            let after = if self.body.conditions.priapism_turns > 0 {

                "It went down a little. Maybe. You hope."

            } else {

                "Everything else has gone quiet, and you are cold again."

            };

            return Ok(Outcome::json(

                StatusCode::OK,

                json!({ "detail": format!("{back} {after}") }),

            ));

        }

        if self.chance(

            self.decision(

                "reflection",

                "In the quiet afterwards, have you caught your own eye in the mirror?",

            ),

            REFLECTION,

        ) {

            self.body.eq = 0;

            self.standing.shame += 1;

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

        } else {

            self.body.eq = (self.body.eq - HOLD_EQ).clamp(0, 100);

        }

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

        self.shed(FRICTION_HOLD);

        self.settle();

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

    }

    /// The breathing technique from the forum's replies. It spends no stamina and the turn is

    /// not the floor's, but each floor allows it once.

    pub(super) fn meditate(&mut self) -> Result<Outcome, Problem> {

        if !self.online.meditation_taught {

            return Err(Problem::new(

                StatusCode::FORBIDDEN,

                "technique-locked",

                "Somebody on a forum knows how to breathe. You have not found the reply.",

            ));

        }

        if self.here.meditated {

            return Err(Problem::new(

                StatusCode::CONFLICT,

                "already-meditated",

                "This floor has had its meditation.",

            ));

        }

        self.here.meditated = true;

        self.step_away();

        self.reset_eq(self.body.eq - MEDITATION_EQ);

        self.shed(FRICTION_MEDITATE);

        self.touch();

        Ok(Outcome::json(

            StatusCode::OK,

            json!({

                "detail": "In through the nose, out through the mouth. EQ falls a little.",

            }),

        ))

    }

}