jelq

use std::{

    ops::ControlFlow,

    time::{Duration, SystemTime},

};

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

use serde_json::json;

use super::{

    Floor, Lube, Outcome, Run,

    balance::{

        EDGE_EQ, EDGE_GIRTH, EDGE_LOOP, ENERGY_STAMINA, FRICTION_ICE, 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.here.towel_warmed && !self.here.kitchen.kettle_boiled {

            return Err(Problem::new(

                StatusCode::CONFLICT,

                "towel-cold",

                "The towel has gone cold. It warms once per floor, unless someone boils the kettle.",

            ));

        }

        if self.floor == Floor::Hotel

            && self.chance(

                self.decision(

                    "hotel-stress",

                    "Has the hotel's plumbing given up for the week?",

                ),

                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.step_away();

        if self.here.towel_warmed {

            self.here.kitchen.kettle_boiled = false;

        }

        self.here.towel_warmed = true;

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

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

    }

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

        if self.items.stores.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.step_away();

        self.items.stores.ice_packs -= 1;

        let treated = std::mem::take(&mut self.body.conditions.friction_burn);

        let eased = self.body.friction > 0;

        self.shed(FRICTION_ICE);

        let priapism = self.body.conditions.priapism_turns > 0;

        let mut detail = Vec::new();

        if treated {

            detail.push("The friction burn is treated.");

        }

        if eased {

            detail.push("Friction has eased.");

        }

        if priapism {

            if detail.is_empty() {

                detail.push("The ice has no effect.");

            } else {

                detail.push("EQ has not moved.");

            }

            detail.push("The condition persists.");

        } else {

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

            detail.push("EQ has been reduced.");

        }

        detail.push("The ice pack is gone.");

        Ok(Outcome::json(

            StatusCode::OK,

            json!({ "detail": detail.join(" ") }),

        ))

    }

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

        if self.items.stores.energy_drinks == 0 {

            return Err(Problem::new(

                StatusCode::FAILED_DEPENDENCY,

                "no-energy-drink",

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

            ));

        }

        self.items.stores.energy_drinks -= 1;

        self.step_away();

        self.body.exhausted = false;

        self.body.stamina = (self.body.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.stores.supplements == 0 {

            return Err(Problem::new(

                StatusCode::FAILED_DEPENDENCY,

                "no-supplement",

                "The supplement technique depends on a supplement.",

            ));

        }

        self.items.stores.supplements -= 1;

        self.step_away();

        self.touch();

        if self.chance(

            self.decision(

                "supplement",

                "Does the supplement from Pump-Bro actually work?",

            ),

            SUPPLEMENT_WORKS,

        ) {

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

            self.body.conditions.priapism_turns = PRIAPISM_TURNS;

            self.body.eq = self.body.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, lube: Option<Lube>) -> Result<Outcome, Problem> {

        self.take_lube(lube)?;

        self.chafe(lube, 5, false);

        self.commit(5, lube, 1)?;

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

            return Ok(interrupted);

        }

        self.here.edges += 1;

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

        self.body.girth += EDGE_GIRTH;

        if self.here.edges >= EDGE_LOOP {

            self.here.edges = 0;

            self.exhaust();

            return Err(Problem::new(

                StatusCode::LOOP_DETECTED,

                "edging-loop",

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

            ));

        }

        Ok(Outcome::json(

            StatusCode::OK,

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

        ))

    }

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

        self.commit(4, None, 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")))

    }

}