jelq

use super::{

    Lube, Run, Technique,

    balance::STORAGE_BULK,

    lube::LubeRule,

    techniques::{Training, Utility},

};

use crate::problem::Problem;

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

use serde_json::json;

pub(super) fn caged() -> Problem {

    Problem::new(

        StatusCode::LOCKED,

        "caged",

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

    )

}

impl Run {

    pub(super) fn check_cage(&self) -> Result<(), Problem> {

        if self.items.kit.cage {

            return Err(caged());

        }

        Ok(())

    }

    pub(super) fn ready(&self, technique: Technique, lube: Option<Lube>) -> Result<(), Problem> {

        self.access(technique)?;

        match technique {

            Technique::Training(training) => Self::check_lube(training, lube),

            Technique::Utility(_) => Ok(()),

        }

    }

    pub(super) fn access(&self, technique: Technique) -> Result<(), Problem> {

        if technique == Technique::Training(Training::Uli) && !self.online.uli_taught {

            return Err(Problem::new(

                StatusCode::FORBIDDEN,

                "technique-locked",

                "uli is discussed on the forum, in a thread from 2009, by a man who never posted again. You have not found the reply.",

            ));

        }

        if matches!(technique, Technique::Training(_)) {

            self.grip_closes(self.body.grip)?;

        }

        match technique {

            Technique::Utility(Utility::Pump) if !self.items.kit.pump_pro => Err(Problem::new(

                StatusCode::FAILED_DEPENDENCY,

                "no-pump",

                "The pump technique depends on a pump.",

            )),

            Technique::Utility(_) => Ok(()),

            Technique::Training(training) => match training.profile().foreskin {

                Some((min, max)) => self.check_foreskin(min, max),

                None => Ok(()),

            },

        }

    }

    pub(super) fn check_lube(training: Training, lube: Option<Lube>) -> Result<(), Problem> {

        match (training.profile().lube, lube) {

            (LubeRule::Required, None) => Err(Problem::new(

                StatusCode::UNSUPPORTED_MEDIA_TYPE,

                "lubricant-required",

                format!(

                    "The {} technique requires a lubricant. None was declared.",

                    training.name()

                ),

            )

            .with("lubricants", json!(Lube::content_types()))),

            (LubeRule::Forbidden, Some(_)) => Err(Problem::new(

                StatusCode::UNSUPPORTED_MEDIA_TYPE,

                "lubricant-declared",

                format!(

                    "The {} technique was requested. A lubricant was declared.",

                    training.name()

                ),

            )),

            _ => Ok(()),

        }

    }

    /// One unit of whatever was declared. Spit is free and the tap is always on.

    pub(super) fn lube_available(&self, lube: Option<Lube>) -> Result<(), Problem> {

        let Some(bottle) = lube.and_then(Lube::item) else {

            return Ok(());

        };

        if !self.items.has(bottle) {

            return Err(Problem::new(

                StatusCode::UNSUPPORTED_MEDIA_TYPE,

                "lubricant-exhausted",

                format!("{} was declared, but the bottle is empty.", bottle.slug()),

            ));

        }

        Ok(())

    }

    pub(super) fn take_lube(&mut self, lube: Option<Lube>) -> Result<(), Problem> {

        self.lube_available(lube)?;

        if let Some(lube) = lube {

            self.items.lubes.take(lube);

        }

        Ok(())

    }

    pub fn techniques_now(&self) -> impl Iterator<Item = Technique> + '_ {

        let blocked = !self.floor.timed() || self.items.kit.cage;

        Technique::ALL

            .into_iter()

            .filter(move |_| !blocked)

            .filter(|&technique| {

                !self.body.exhausted || technique == Technique::Utility(Utility::Energy)

            })

            .filter(|&technique| match technique {

                Technique::Utility(Utility::Warmup) => {

                    !self.here.towel_warmed || self.here.kitchen.kettle_boiled

                }

                Technique::Utility(Utility::Ice) => self.items.stores.ice_packs > 0,

                Technique::Utility(Utility::Supplement) => self.items.stores.supplements > 0,

                Technique::Utility(Utility::Meditate) => {

                    self.online.meditation_taught && !self.here.meditated

                }

                Technique::Utility(Utility::Energy) => self.items.stores.energy_drinks > 0,

                _ => self.access(technique).is_ok() && self.check_storage().is_ok(),

            })

    }

    pub(super) fn check_foreskin(&self, min: f64, max: f64) -> Result<(), Problem> {

        let Some(f) = self.body.foreskin else {

            if min <= 0.0 {

                return Ok(());

            }

            return Err(Problem::new(

                StatusCode::GONE,

                "foreskin-gone",

                "This technique requires a foreskin. The foreskin is gone.",

            )

            .header(header::CONTENT_LOCATION, self.path("/foreskin")));

        };

        if f < min {

            return Err(Problem::new(

                StatusCode::LENGTH_REQUIRED,

                "foreskin-insufficient",

                format!(

                    "The selected technique requires {min:.1} units of foreskin. {f:.2} units are available. The server has noted the shortfall."

                ),

            )

            .with("required", min));

        }

        if f > max {

            return Err(Problem::new(

                StatusCode::PAYLOAD_TOO_LARGE,

                "foreskin-excessive",

                format!(

                    "The selected technique tolerates at most {max:.1} units of foreskin. {f:.2} units are present."

                ),

            )

            .with("maximum", max));

        }

        Ok(())

    }

    pub(super) fn check_storage(&self) -> Result<(), Problem> {

        if self.items.kit.extender && self.body.girth + self.current_length() / 4.0 > STORAGE_BULK {

            return Err(Problem::new(

                StatusCode::INSUFFICIENT_STORAGE,

                "jeans-full",

                "The jeans are full. The extender is occupying the remaining storage.",

            )

            .with("extender", self.path("/inventory/extender")));

        }

        Ok(())

    }

}