jelq

use axum::http::StatusCode;

use serde_json::json;

use super::Item;

use crate::problem::Problem;

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

pub enum Lube {

    BabyOil,

    CoconutOil,

    Lotion,

    Vaseline,

    Spit,

}

impl Lube {

    const ALL: [Self; 5] = [

        Self::BabyOil,

        Self::CoconutOil,

        Self::Lotion,

        Self::Vaseline,

        Self::Spit,

    ];

    pub fn content_types() -> [&'static str; 5] {

        Self::ALL.map(Self::content_type)

    }

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

        match self {

            Self::BabyOil => "application/baby-oil",

            Self::CoconutOil => "application/coconut-oil",

            Self::Lotion => "application/lotion",

            Self::Vaseline => "application/vaseline",

            Self::Spit => "text/plain; charset=spit",

        }

    }

    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");

        if let Some(lube) = Self::ALL.into_iter().find(|l| l.content_type() == essence) {

            return Ok(Some(lube));

        }

        match essence {

            "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!(Self::content_types()))),

        }

    }

    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",

        }

    }

}