jelq

use axum::http::StatusCode;

use serde_json::{Value, json};

use crate::problem::Problem;

pub const LUBRICANTS: [&str; 5] = [

    "application/baby-oil",

    "application/coconut-oil",

    "application/lotion",

    "application/vaseline",

    "text/plain; charset=spit",

];

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Lube {

    BabyOil,

    CoconutOil,

    Lotion,

    Vaseline,

    Spit,

}

impl Lube {

    pub fn from_content_type(content_type: Option<&str>) -> Result<Option<Self>, Problem> {

        let Some(raw) = content_type else {

            return Ok(None);

        };

        let lowered = raw.to_ascii_lowercase();

        let mut parts = lowered.split(';').map(str::trim);

        let essence = parts.next().unwrap_or_default();

        let spit = parts.any(|p| p.replace(' ', "") == "charset=spit");

        match essence {

            "application/baby-oil" => Ok(Some(Self::BabyOil)),

            "application/coconut-oil" => Ok(Some(Self::CoconutOil)),

            "application/lotion" => Ok(Some(Self::Lotion)),

            "application/vaseline" => Ok(Some(Self::Vaseline)),

            "text/plain" if spit => Ok(Some(Self::Spit)),

            e if e.starts_with("image/") || e.starts_with("video/") => Err(Problem::new(

                StatusCode::UNSUPPORTED_MEDIA_TYPE,

                "no",

                "No.",

            )),

            _ => Err(Problem::new(

                StatusCode::UNSUPPORTED_MEDIA_TYPE,

                "unsupported-lubricant",

                format!("{essence} is not a lubricant."),

            )

            .with("lubricants", json!(LUBRICANTS))),

        }

    }

    pub fn modifier(self) -> i32 {

        match self {

            Self::BabyOil => 1,

            Self::CoconutOil => 3,

            Self::Lotion => 0,

            Self::Vaseline => 2,

            Self::Spit => -2,

        }

    }

}

/// Techniques that roll for gains.

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Training {

    Wet,

    Dry,

    Stretch,

    Uli,

}

/// Techniques that change EQ or spend an item without rolling.

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Utility {

    Warmup,

    Ice,

    Edge,

    Pump,

    Supplement,

    Meditate,

    Energy,

}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Technique {

    Training(Training),

    Utility(Utility),

}

#[derive(Clone, Copy)]

pub enum LubeRule {

    Required,

    Forbidden,

    Optional,

}

impl LubeRule {

    fn name(self) -> &'static str {

        match self {

            Self::Required => "required",

            Self::Forbidden => "forbidden",

            Self::Optional => "optional",

        }

    }

}

pub struct Profile {

    pub dc: i32,

    pub length: f64,

    pub girth: f64,

    /// Minimum and maximum foreskin the technique tolerates. A minimum above zero means it is used.

    pub foreskin: Option<(f64, f64)>,

    pub foreskin_growth: f64,

    pub lube: LubeRule,

}

impl Training {

    pub fn name(self) -> &'static str {

        match self {

            Self::Wet => "wet",

            Self::Dry => "dry",

            Self::Stretch => "stretch",

            Self::Uli => "uli",

        }

    }

    pub fn profile(self) -> Profile {

        match self {

            Self::Wet => Profile {

                dc: 10,

                length: 0.010,

                girth: 0.005,

                foreskin: None,

                foreskin_growth: 0.0,

                lube: LubeRule::Required,

            },

            Self::Dry => Profile {

                dc: 12,

                length: 0.008,

                girth: 0.003,

                foreskin: Some((0.8, 2.0)),

                foreskin_growth: 0.01,

                lube: LubeRule::Forbidden,

            },

            Self::Stretch => Profile {

                dc: 11,

                length: 0.015,

                girth: 0.0,

                foreskin: Some((0.0, 1.8)),

                foreskin_growth: 0.03,

                lube: LubeRule::Optional,

            },

            Self::Uli => Profile {

                dc: 15,

                length: 0.002,

                girth: 0.020,

                foreskin: None,

                foreskin_growth: 0.0,

                lube: LubeRule::Optional,

            },

        }

    }

}

impl Utility {

    pub fn name(self) -> &'static str {

        match self {

            Self::Warmup => "warmup",

            Self::Ice => "ice",

            Self::Edge => "edge",

            Self::Pump => "pump",

            Self::Supplement => "supplement",

            Self::Meditate => "meditate",

            Self::Energy => "energy",

        }

    }

    fn effect(self) -> &'static str {

        match self {

            Self::Warmup => "EQ +25. Satisfies the warm-up precondition.",

            Self::Ice => "EQ -40. Treats a friction burn. Consumes an ice pack.",

            Self::Edge => "EQ +15 and a little girth. Three in a row is a loop.",

            Self::Pump => "Large gains, all temporary. Requires a pump.",

            Self::Supplement => "Consumes a supplement.",

            Self::Meditate => "EQ -10, sheds 2 friction. Taught by the forum. Once per floor.",

            Self::Energy => "+3 stamina. Consumes an energy drink. Tastes like a battery.",

        }

    }

}

impl Technique {

    pub const ALL: [Self; 11] = [

        Self::Utility(Utility::Warmup),

        Self::Utility(Utility::Ice),

        Self::Utility(Utility::Edge),

        Self::Utility(Utility::Pump),

        Self::Utility(Utility::Supplement),

        Self::Utility(Utility::Meditate),

        Self::Utility(Utility::Energy),

        Self::Training(Training::Wet),

        Self::Training(Training::Dry),

        Self::Training(Training::Stretch),

        Self::Training(Training::Uli),

    ];

    pub fn name(self) -> &'static str {

        match self {

            Self::Training(t) => t.name(),

            Self::Utility(u) => u.name(),

        }

    }

    pub fn parse(name: &str) -> Option<Self> {

        Self::ALL.into_iter().find(|t| t.name() == name)

    }

    pub fn lubricant(self) -> Option<&'static str> {

        match self {

            Self::Training(training) => Some(training.profile().lube.name()),

            Self::Utility(_) => None,

        }

    }

    pub fn describe(self, uli_taught: bool) -> Value {

        let training = match self {

            Self::Utility(utility) => {

                return json!({ "name": utility.name(), "effect": utility.effect() });

            }

            Self::Training(training) => training,

        };

        let profile = training.profile();

        let lubricant = profile.lube.name();

        json!({

            "name": training.name(),

            "dc": profile.dc,

            "lubricant": lubricant,

            "foreskin": profile.foreskin.map(|(min, max)| json!({ "min": min, "max": max })),

            "locked": training == Training::Uli && !uli_taught,

        })

    }

}