jelq

//! The game is written in en-GB. Other locales are produced by rewriting regional phrases.

use serde_json::Value;

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

pub enum Locale {

    #[default]

    British,

    American,

    Australian,

}

/// Ordered so that longer phrases are rewritten before the words inside them.

const EN_US: &[(&str, &str)] = &[

    (

        "Nan's house at Christmas",

        "Grandma's house for Thanksgiving",

    ),

    ("Christmas dinner", "Thanksgiving dinner"),

    (

        "The King's speech is about to start.",

        "The game is about to start.",

    ),

    ("wrapping presents", "carving the turkey"),

    ("folding the washing", "folding laundry"),

    ("your washing", "your laundry"),

    ("changing room", "locker room"),

    ("authorisation", "authorization"),

    ("revising", "studying"),

    ("neighbour", "neighbor"),

    ("cupboard", "pantry"),

    ("Christmas", "Thanksgiving"),

    ("Mum", "Mom"),

    ("mum", "mom"),

    ("Nan", "Grandma"),

    ("nan", "grandma"),

    ("zip", "zipper"),

    ("£", "$"),

];

const EN_AU: &[(&str, &str)] = &[

    ("Christmas dinner", "Christmas lunch"),

    (

        "The King's speech is about to start.",

        "The cricket is about to start.",

    ),

    ("wrapping presents", "getting ice from the servo"),

    ("changing room", "change rooms"),

    ("cupboard", "pantry"),

    ("zip", "fly"),

    ("£", "$"),

];

const EXCUSES: &[&str] = &["wrapping presents", "folding the washing"];

fn bounded(text: &str, at: usize, len: usize) -> bool {

    let before = text[..at].chars().next_back();

    let after = text[at + len..].chars().next();

    let edge = |c: Option<char>| c.is_none_or(|c| !c.is_alphanumeric());

    edge(before) && edge(after)

}

fn replace_words(text: &str, from: &str, to: &str) -> String {

    let mut out = String::with_capacity(text.len());

    let mut rest = 0;

    for (at, _) in text.match_indices(from) {

        if at < rest || !bounded(text, at, from.len()) {

            continue;

        }

        out.push_str(&text[rest..at]);

        out.push_str(to);

        rest = at + from.len();

    }

    out.push_str(&text[rest..]);

    out

}

impl Locale {

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

        match self {

            Self::British => "en-GB",

            Self::American => "en-US",

            Self::Australian => "en-AU",

        }

    }

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

        match tag.trim().to_ascii_lowercase().as_str() {

            "en-gb" | "en" => Some(Self::British),

            "en-us" => Some(Self::American),

            "en-au" => Some(Self::Australian),

            _ => None,

        }

    }

    /// Picks the most preferred supported locale from an `Accept-Language` header (RFC 9110 §12.5.4).

    pub fn negotiate(accept_language: Option<&str>) -> Self {

        let Some(header) = accept_language else {

            return Self::default();

        };

        header

            .split(',')

            .filter_map(|range| {

                let mut parts = range.split(';');

                let locale = Self::parse(parts.next()?)?;

                let quality = parts

                    .find_map(|p| p.trim().strip_prefix("q="))

                    .and_then(|q| q.parse::<f32>().ok())

                    .unwrap_or(1.0);

                (quality > 0.0).then_some((locale, quality))

            })

            .max_by(|a, b| a.1.total_cmp(&b.1))

            .map_or_else(Self::default, |(locale, _)| locale)

    }

    fn phrases(self) -> &'static [(&'static str, &'static str)] {

        match self {

            Self::British => &[],

            Self::American => EN_US,

            Self::Australian => EN_AU,

        }

    }

    pub fn localise(self, text: &str) -> String {

        self.phrases()

            .iter()

            .fold(text.to_owned(), |text, (from, to)| {

                replace_words(&text, from, to)

            })

    }

    /// Translates the excuses a player types back into the en-GB phrases the game checks against.

    pub fn canonicalise(self, text: &str) -> String {

        let local = |excuse: &str| self.localise(excuse);

        EXCUSES.iter().fold(text.to_owned(), |text, excuse| {

            replace_words(&text, &local(excuse), excuse)

        })

    }

    pub fn localise_json(self, value: &mut Value) {

        match value {

            Value::String(text) if !text.starts_with('/') && !text.starts_with("http") => {

                *text = self.localise(text);

            }

            Value::Array(items) => items.iter_mut().for_each(|item| self.localise_json(item)),

            Value::Object(fields) => {

                for (key, field) in fields.iter_mut() {

                    if !matches!(key.as_str(), "href" | "type" | "instance") {

                        self.localise_json(field);

                    }

                }

            }

            _ => {}

        }

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn negotiates_by_quality() {

        assert_eq!(Locale::negotiate(None), Locale::British);

        assert_eq!(Locale::negotiate(Some("en-US")), Locale::American);

        assert_eq!(

            Locale::negotiate(Some("fr, en-AU;q=0.8, en-US;q=0.5")),

            Locale::Australian

        );

        assert_eq!(Locale::negotiate(Some("de")), Locale::British);

    }

    #[test]

    fn rewrites_whole_words_only() {

        let us = Locale::American;

        assert_eq!(

            us.localise("Mum's zip, not gzip."),

            "Mom's zipper, not gzip."

        );

        assert_eq!(us.localise("1.1 mum"), "1.1 mom");

        assert_eq!(

            Locale::Australian.localise("The request conflicts with the current state of the zip."),

            "The request conflicts with the current state of the fly."

        );

    }

    #[test]

    fn excuses_come_back_to_en_gb() {

        assert_eq!(

            Locale::American.canonicalise("Digest username=\"carving the turkey\""),

            "Digest username=\"wrapping presents\""

        );

    }

}