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)] = &[

    ("Stop raiding the kitchen.", "Stop raiding the fridge."),

    (

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

    ("£", "$"),

];

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 {

    replace_matching(text, text, from, to)

}

/// Players type excuses in whatever case they like. ASCII lowering keeps byte offsets intact.

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

    let lowered = text.to_ascii_lowercase();

    replace_matching(text, &lowered, &from.to_ascii_lowercase(), to)

}

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

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

    let mut rest = 0;

    for (at, _) in haystack.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);

        crate::game::excuse_vocabulary().fold(text.to_owned(), |text, excuse| {

            let localised = local(excuse);

            if localised == excuse {

                return text;

            }

            replace_words_ignoring_case(&text, &localised, 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\""

        );

        assert_eq!(

            Locale::American.canonicalise("Excuse \"Studying\""),

            "Excuse \"revising\""

        );

        assert_eq!(

            Locale::American.canonicalise("Excuse \"helping grandma\""),

            "Excuse \"helping Nan\""

        );

    }

}