jelq

use serde_json::{Value, json};

use super::lube::LubeRule;

/// 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),

}

pub struct Profile {

    pub(crate) dc: i32,

    pub(crate) length: f64,

    pub(crate) girth: f64,

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

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

    pub(crate) foreskin_growth: f64,

    pub(crate) 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, known: bool) -> Value {

        let training = match self {

            Self::Utility(utility) => {

                return json!({

                    "name": utility.name(),

                    "effect": utility.effect(),

                    "locked": !known,

                });

            }

            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": !known,

        })

    }

}