robinpath_modules/modules/

i18n_mod.rs

use robinpath::{RobinPath, Value};
use std::sync::{LazyLock, Mutex};
use std::collections::HashMap;

struct I18nState {
    locale: String,
    translations: HashMap<String, HashMap<String, String>>,
}

static STATE: LazyLock<Mutex<I18nState>> = LazyLock::new(|| Mutex::new(I18nState {
    locale: "en".to_string(),
    translations: HashMap::new(),
}));

pub fn register(rp: &mut RobinPath) {
    // i18n.setLocale locale → bool
    rp.register_builtin("i18n.setLocale", |args, _| {
        let locale = args.first().map(|v| v.to_display_string()).unwrap_or_else(|| "en".to_string());
        STATE.lock().unwrap().locale = locale;
        Ok(Value::Bool(true))
    });

    // i18n.getLocale → string
    rp.register_builtin("i18n.getLocale", |_args, _| {
        Ok(Value::String(STATE.lock().unwrap().locale.clone()))
    });

    // i18n.loadTranslations locale translations → bool
    rp.register_builtin("i18n.loadTranslations", |args, _| {
        let locale = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let translations = args.get(1).cloned().unwrap_or(Value::Null);
        if let Value::Object(obj) = translations {
            let mut state = STATE.lock().unwrap();
            let entry = state.translations.entry(locale).or_default();
            for (key, val) in obj {
                entry.insert(key, val.to_display_string());
            }
            Ok(Value::Bool(true))
        } else {
            Err("Translations must be an object".to_string())
        }
    });

    // i18n.t key locale? interpolation? → translated string
    rp.register_builtin("i18n.t", |args, _| {
        let key = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let locale = args.get(1).map(|v| v.to_display_string());
        let interpolation = args.get(2).cloned().unwrap_or(Value::Null);
        let state = STATE.lock().unwrap();
        let loc = locale.as_deref().unwrap_or(&state.locale);
        let translated = state.translations.get(loc)
            .and_then(|t| t.get(&key))
            .cloned()
            .unwrap_or(key.clone());
        // Apply interpolation {{var}}
        let mut result = translated;
        if let Value::Object(obj) = &interpolation {
            for (k, v) in obj {
                let placeholder = format!("{{{{{}}}}}", k);
                result = result.replace(&placeholder, &v.to_display_string());
            }
        }
        Ok(Value::String(result))
    });

    // i18n.formatNumber number locale? → formatted string
    rp.register_builtin("i18n.formatNumber", |args, _| {
        let num = args.first().map(|v| v.to_number()).unwrap_or(0.0);
        let locale = args.get(1).map(|v| v.to_display_string())
            .unwrap_or_else(|| STATE.lock().unwrap().locale.clone());
        let (thousands_sep, decimal_sep) = get_number_separators(&locale);
        let formatted = format_number(num, thousands_sep, decimal_sep);
        Ok(Value::String(formatted))
    });

    // i18n.formatCurrency amount currency locale? → formatted string
    rp.register_builtin("i18n.formatCurrency", |args, _| {
        let amount = args.first().map(|v| v.to_number()).unwrap_or(0.0);
        let currency = args.get(1).map(|v| v.to_display_string()).unwrap_or_else(|| "USD".to_string());
        let locale = args.get(2).map(|v| v.to_display_string())
            .unwrap_or_else(|| STATE.lock().unwrap().locale.clone());
        let symbol = currency_symbol(&currency);
        let (thousands_sep, decimal_sep) = get_number_separators(&locale);
        let formatted = format_number(amount, thousands_sep, decimal_sep);
        Ok(Value::String(format!("{}{}", symbol, formatted)))
    });

    // i18n.pluralize count singular plural → string
    rp.register_builtin("i18n.pluralize", |args, _| {
        let count = args.first().map(|v| v.to_number() as i64).unwrap_or(0);
        let singular = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        let plural = args.get(2).map(|v| v.to_display_string())
            .unwrap_or_else(|| format!("{}s", singular));
        if count == 1 {
            Ok(Value::String(format!("{} {}", count, singular)))
        } else {
            Ok(Value::String(format!("{} {}", count, plural)))
        }
    });

    // i18n.direction locale → "ltr" or "rtl"
    rp.register_builtin("i18n.direction", |args, _| {
        let locale = args.first().map(|v| v.to_display_string())
            .unwrap_or_else(|| STATE.lock().unwrap().locale.clone());
        let lang = locale.split('-').next().unwrap_or(&locale);
        let rtl = matches!(lang, "ar" | "he" | "fa" | "ur" | "ps" | "yi" | "sd" | "ug");
        Ok(Value::String(if rtl { "rtl" } else { "ltr" }.to_string()))
    });

    // i18n.listLocales → array of locale strings
    rp.register_builtin("i18n.listLocales", |_args, _| {
        let state = STATE.lock().unwrap();
        let locales: Vec<Value> = state.translations.keys()
            .map(|k| Value::String(k.clone()))
            .collect();
        Ok(Value::Array(locales))
    });

    // i18n.hasTranslation key locale? → bool
    rp.register_builtin("i18n.hasTranslation", |args, _| {
        let key = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let locale = args.get(1).map(|v| v.to_display_string());
        let state = STATE.lock().unwrap();
        let loc = locale.as_deref().unwrap_or(&state.locale);
        let has = state.translations.get(loc)
            .map(|t| t.contains_key(&key))
            .unwrap_or(false);
        Ok(Value::Bool(has))
    });

    // i18n.formatList items locale? → "a, b, and c"
    rp.register_builtin("i18n.formatList", |args, _| {
        let items = args.first().cloned().unwrap_or(Value::Null);
        if let Value::Array(arr) = items {
            let strings: Vec<String> = arr.iter().map(|v| v.to_display_string()).collect();
            let result = match strings.len() {
                0 => String::new(),
                1 => strings[0].clone(),
                2 => format!("{} and {}", strings[0], strings[1]),
                _ => {
                    let last = strings.last().unwrap();
                    let rest = &strings[..strings.len() - 1];
                    format!("{}, and {}", rest.join(", "), last)
                }
            };
            Ok(Value::String(result))
        } else {
            Ok(Value::String(items.to_display_string()))
        }
    });
}

fn get_number_separators(locale: &str) -> (char, char) {
    let lang = locale.split('-').next().unwrap_or(locale);
    match lang {
        "de" | "fr" | "es" | "it" | "pt" | "nl" | "pl" | "cs" | "sk" | "hu" | "ro" | "bg" | "hr" | "sl" | "et" | "lv" | "lt" => ('.', ','),
        _ => (',', '.'),
    }
}

fn format_number(num: f64, thousands_sep: char, decimal_sep: char) -> String {
    let is_negative = num < 0.0;
    let abs = num.abs();
    let integer_part = abs as u64;
    let frac = abs - integer_part as f64;
    // Format integer part with thousands separator
    let int_str = integer_part.to_string();
    let mut formatted = String::new();
    for (i, c) in int_str.chars().rev().enumerate() {
        if i > 0 && i % 3 == 0 { formatted.push(thousands_sep); }
        formatted.push(c);
    }
    let formatted: String = formatted.chars().rev().collect();
    // Add decimal part if needed
    let result = if frac > 0.0001 {
        let decimal_str = format!("{:.2}", frac);
        format!("{}{}{}", formatted, decimal_sep, &decimal_str[2..])
    } else {
        formatted
    };
    if is_negative { format!("-{}", result) } else { result }
}

fn currency_symbol(code: &str) -> &'static str {
    match code.to_uppercase().as_str() {
        "USD" => "$", "EUR" => "\u{20ac}", "GBP" => "\u{00a3}", "JPY" => "\u{00a5}",
        "CNY" | "RMB" => "\u{00a5}", "KRW" => "\u{20a9}", "INR" => "\u{20b9}",
        "BRL" => "R$", "RUB" => "\u{20bd}", "TRY" => "\u{20ba}", "CHF" => "CHF ",
        "CAD" => "CA$", "AUD" => "A$", "MXN" => "MX$", "SEK" => "kr",
        _ => "$",
    }
}