jelq

use axum::http::StatusCode;

use serde_json::json;

use super::Item;

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,

        }

    }

    /// The bottle this lube comes in. Spit has none and never runs out.

    pub fn item(self) -> Option<Item> {

        match self {

            Self::Spit => None,

            Self::BabyOil => Some(Item::BabyOil),

            Self::CoconutOil => Some(Item::CoconutOil),

            Self::Lotion => Some(Item::Lotion),

            Self::Vaseline => Some(Item::Vaseline),

        }

    }

}

#[derive(Clone, Copy)]

pub enum LubeRule {

    Required,

    Forbidden,

    Optional,

}

impl LubeRule {

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

        match self {

            Self::Required => "required",

            Self::Forbidden => "forbidden",

            Self::Optional => "optional",

        }

    }

}