jelq

use std::{

    ops::ControlFlow,

    time::{Duration, Instant, SystemTime},

};

use axum::http::{StatusCode, header};

use serde_json::json;

use super::{

    Floor, Outcome, Run,

    balance::{

        EDGE_EQ, EDGE_GIRTH, EDGE_LOOP, ENERGY_STAMINA, HOTEL_STRESS, ICE_EQ, PRIAPISM_EQ,

        PRIAPISM_TURNS, PUMP_GAIN, SHOWER_EQ, SUPPLEMENT_WORKS, TOWELLESS_EQ, WARMUP_EQ,

    },

};

use crate::problem::Problem;

const WEEK: Duration = Duration::from_secs(7 * 24 * 60 * 60);

impl Run {

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

        if self.floor == Floor::Hotel && self.chance(HOTEL_STRESS) {

            return Err(Problem::new(

                StatusCode::SERVICE_UNAVAILABLE,

                "service-unavailable",

                "Service is unavailable. The server estimates next week. The server is being pessimistic.",

            )

            .header(

                header::RETRY_AFTER,

                httpdate::fmt_http_date(SystemTime::now() + WEEK),

            ));

        }

        let (boost, detail) = if self.floor == Floor::Bathroom {

            (

                SHOWER_EQ,

                "Warmed up. The shower is hot. Your brother's will not be.",

            )

        } else if self.here.towel_stolen {

            (TOWELLESS_EQ, "Warmed up, poorly. The cat has the towel.")

        } else {

            (WARMUP_EQ, "Warmed up. The towel has cooled.")

        };

        self.touch();

        self.warmed_up = true;

        self.eq = (self.eq + boost).min(100);

        Ok(Outcome::json(StatusCode::OK, json!({ "detail": detail })))

    }

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

        if self.items.ice_packs == 0 {

            return Err(Problem::new(

                StatusCode::FAILED_DEPENDENCY,

                "no-ice",

                "The ice technique depends on an ice pack. There are none.",

            ));

        }

        self.touch();

        self.items.ice_packs -= 1;

        if self.conditions.priapism_turns > 0 {

            return Ok(Outcome::json(

                StatusCode::OK,

                json!({ "detail": "The ice has no effect. The condition persists. The ice pack is gone." }),

            ));

        }

        self.eq = (self.eq - ICE_EQ).max(0);

        let detail = if self.conditions.friction_burn {

            self.conditions.friction_burn = false;

            "The friction burn is treated. EQ has been reduced. The ice pack is gone."

        } else {

            "EQ has been reduced. The ice pack is gone."

        };

        Ok(Outcome::json(StatusCode::OK, json!({ "detail": detail })))

    }

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

        if self.items.energy_drinks == 0 {

            return Err(Problem::new(

                StatusCode::FAILED_DEPENDENCY,

                "no-energy-drink",

                "The energy technique depends on an energy drink.",

            ));

        }

        self.items.energy_drinks -= 1;

        self.stamina = (self.stamina + ENERGY_STAMINA).min(self.max_stamina());

        self.touch();

        Ok(Outcome::json(

            StatusCode::OK,

            json!({ "detail": "The energy arrives before the regret. Stamina +3." }),

        ))

    }

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

        if self.items.supplements == 0 {

            return Err(Problem::new(

                StatusCode::FAILED_DEPENDENCY,

                "no-supplement",

                "The supplement technique depends on a supplement.",

            ));

        }

        self.items.supplements -= 1;

        self.touch();

        if self.chance(SUPPLEMENT_WORKS) {

            self.stamina = self.max_stamina();

            self.conditions.priapism_turns = PRIAPISM_TURNS;

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

            return Ok(Outcome::json(

                StatusCode::OK,

                json!({ "detail": "The upstream returned a valid response. It is still returning it. Stamina is fully restored." }),

            ));

        }

        Err(Problem::new(

            StatusCode::BAD_GATEWAY,

            "bad-gateway",

            "The upstream returned an invalid response.",

        )

        .with("upstream", "Pump-Bro"))

    }

    pub(super) fn edge(&mut self, now: Instant) -> Result<Outcome, Problem> {

        self.commit(5, None, now, 1);

        self.here.edges += 1;

        self.eq = (self.eq + EDGE_EQ).min(100);

        self.girth += EDGE_GIRTH;

        if self.here.edges >= EDGE_LOOP {

            self.here.edges = 0;

            self.exhaust(now);

            return Err(Problem::new(

                StatusCode::LOOP_DETECTED,

                "edging-loop",

                "Edging has looped. The server detected an infinite loop and terminated it.",

            ));

        }

        if let ControlFlow::Break(interrupted) = self.hazards(5)? {

            return Ok(interrupted);

        }

        Ok(Outcome::json(

            StatusCode::OK,

            json!({ "detail": "Edged. EQ is rising. Nothing else is.", "edges": self.here.edges }),

        ))

    }

    pub(super) fn pump(&mut self, now: Instant) -> Result<Outcome, Problem> {

        self.commit(4, None, now, 1);

        if let ControlFlow::Break(interrupted) = self.hazards(4)? {

            return Ok(interrupted);

        }

        self.here.temp_length += PUMP_GAIN;

        Ok(Outcome::json(

            StatusCode::TEMPORARY_REDIRECT,

            json!({ "detail": "Gains applied. They are temporary.", "length": PUMP_GAIN }),

        )

        .header(header::LOCATION, self.path("/length")))

    }

}