jelq

use std::fmt;

pub const REL_BASE: &str = "https://jelq.dev/rels/";

enum Rel<'a> {

    Jelq(&'a str),

    Registered(&'a str),

}

/// One RFC 8288 link. `allow`, `lubricant` and `intensity` are extension attributes (§3), so a client never

/// has to guess what a target accepts.

pub struct Link<'a> {

    href: &'a str,

    rel: Rel<'a>,

    title: Option<&'a str>,

    allow: Option<&'a str>,

    lubricant: Option<&'a str>,

    intensity: Option<&'a str>,

}

impl<'a> Link<'a> {

    fn new(href: &'a str, rel: Rel<'a>) -> Self {

        Self {

            href,

            rel,

            title: None,

            allow: None,

            lubricant: None,

            intensity: None,

        }

    }

    /// A relation of this game's own, named under `REL_BASE`.

    pub fn jelq(href: &'a str, rel: &'a str) -> Self {

        Self::new(href, Rel::Jelq(rel))

    }

    /// A relation from the IANA registry, such as `next` or `alternate`.

    pub fn registered(href: &'a str, rel: &'a str) -> Self {

        Self::new(href, Rel::Registered(rel))

    }

    pub fn title(self, title: &'a str) -> Self {

        Self {

            title: Some(title),

            ..self

        }

    }

    pub fn allow(self, allow: &'a str) -> Self {

        Self {

            allow: Some(allow),

            ..self

        }

    }

    pub fn lubricant(self, lubricant: Option<&'a str>) -> Self {

        Self { lubricant, ..self }

    }

    pub fn intensity(self, intensity: Option<&'a str>) -> Self {

        Self { intensity, ..self }

    }

}

impl fmt::Display for Link<'_> {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        write!(f, "<{}>; rel=\"", self.href)?;

        match self.rel {

            Rel::Jelq(rel) => write!(f, "{REL_BASE}{rel}\"")?,

            Rel::Registered(rel) => write!(f, "{rel}\"")?,

        }

        for (name, value) in [

            ("title", self.title),

            ("allow", self.allow),

            ("lubricant", self.lubricant),

            ("intensity", self.intensity),

        ] {

            if let Some(value) = value {

                write!(f, "; {name}=\"{value}\"")?;

            }

        }

        Ok(())

    }

}

/// A `Link` header value listing every link in order.

pub fn join<'a>(links: impl IntoIterator<Item = Link<'a>>) -> String {

    links

        .into_iter()

        .map(|link| link.to_string())

        .collect::<Vec<_>>()

        .join(", ")

}