//! UI language (Tim t1004u): English (default) or Dutch.
//!
//! Source strings are Dutch; [`t`] translates any displayed text at the UI
//! boundary through [`crate::i18n_table::TABLE`]. Entries may be format
//! templates whose `{…}` holes are matched and translated recursively.
use std::collections::HashMap;
use std::path::Path;
use std::sync::atomic::{AtomicU8, Ordering};
use std::sync::{Mutex, OnceLock};

use crate::i18n_table::TABLE;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Lang {
    #[default]
    En,
    Nl,
}

impl Lang {
    pub const ALL: [Lang; 2] = [Lang::En, Lang::Nl];
    pub fn code(self) -> &'static str {
        match self {
            Lang::En => "en",
            Lang::Nl => "nl",
        }
    }
    pub fn from_code(code: &str) -> Option<Self> {
        Self::ALL.into_iter().find(|l| l.code() == code)
    }
    /// Name of the language in that language.
    pub fn native_name(self) -> &'static str {
        match self {
            Lang::En => "English",
            Lang::Nl => "Nederlands",
        }
    }
}

static LANG: AtomicU8 = AtomicU8::new(0);

pub fn lang() -> Lang {
    if LANG.load(Ordering::Relaxed) == 1 {
        Lang::Nl
    } else {
        Lang::En
    }
}

pub fn set_lang(lang: Lang) {
    LANG.store(u8::from(lang == Lang::Nl), Ordering::Relaxed);
}

/// Display text in the current language.
pub fn t(text: impl AsRef<str>) -> String {
    tr(lang(), text.as_ref())
}

/// Display text in `lang`.
pub fn tr(lang: Lang, text: &str) -> String {
    match lang {
        Lang::Nl => text.to_string(),
        Lang::En => to_english(text),
    }
}

struct Template {
    /// Literal parts; holes sit between consecutive parts.
    parts: Vec<String>,
    holes: Vec<String>,
    english: &'static str,
    weight: usize,
}

struct Tables {
    exact: HashMap<&'static str, &'static str>,
    templates: Vec<Template>,
}

/// Split a format string into literal parts and `{…}` hole tokens.
fn split_template(text: &str) -> (Vec<String>, Vec<String>) {
    let mut parts = vec![String::new()];
    let mut holes = Vec::new();
    let mut chars = text.chars().peekable();
    while let Some(c) = chars.next() {
        match c {
            '{' if chars.peek() == Some(&'{') => {
                chars.next();
                parts.last_mut().unwrap().push('{');
            }
            '}' if chars.peek() == Some(&'}') => {
                chars.next();
                parts.last_mut().unwrap().push('}');
            }
            '{' => {
                let mut token = String::from("{");
                for d in chars.by_ref() {
                    token.push(d);
                    if d == '}' {
                        break;
                    }
                }
                holes.push(token);
                parts.push(String::new());
            }
            _ => parts.last_mut().unwrap().push(c),
        }
    }
    (parts, holes)
}

fn tables() -> &'static Tables {
    static T: OnceLock<Tables> = OnceLock::new();
    T.get_or_init(|| {
        let mut exact = HashMap::new();
        let mut templates = Vec::new();
        for (nl, en) in TABLE {
            let (parts, holes) = split_template(nl);
            if holes.is_empty() {
                exact.insert(*nl, *en);
                // `{{`/`}}`-free literal; also index its unescaped form.
                continue;
            }
            let weight: usize = parts.iter().map(|p| p.chars().count()).sum();
            if weight == 0 {
                continue;
            }
            templates.push(Template {
                parts,
                holes,
                english: en,
                weight,
            });
        }
        templates.sort_by_key(|t| std::cmp::Reverse(t.weight));
        Tables { exact, templates }
    })
}

/// Match `msg` against literal `parts` (holes in between, non-greedy, backtracking).
fn match_parts<'m>(msg: &'m str, parts: &[String]) -> Option<Vec<&'m str>> {
    let rest = msg.strip_prefix(parts[0].as_str())?;
    if parts.len() == 1 {
        return rest.is_empty().then(Vec::new);
    }
    let next = &parts[1];
    let mut start = 0;
    loop {
        let found = if next.is_empty() {
            if parts.len() == 2 {
                Some(rest.len())
            } else {
                // Empty separator between two holes: not supported (ambiguous).
                return None;
            }
        } else {
            rest[start..].find(next.as_str()).map(|i| start + i)
        };
        let at = found?;
        let hole = &rest[..at];
        let mut tail_parts = parts[1..].to_vec();
        tail_parts[0] = next.clone();
        if let Some(mut more) = match_parts(&rest[at..], &tail_parts) {
            let mut out = vec![hole];
            out.append(&mut more);
            return Some(out);
        }
        if next.is_empty() {
            return None;
        }
        // Advance to the next occurrence (keep char boundaries).
        start = at + next.chars().next().map_or(1, char::len_utf8);
        if start > rest.len() {
            return None;
        }
    }
}

fn to_english(text: &str) -> String {
    static CACHE: OnceLock<Mutex<HashMap<String, String>>> = OnceLock::new();
    let cache = CACHE.get_or_init(|| Mutex::new(HashMap::new()));
    if let Some(hit) = cache.lock().ok().and_then(|c| c.get(text).cloned()) {
        return hit;
    }
    let out = translate(text, 0);
    if let Ok(mut c) = cache.lock() {
        if c.len() > 4096 {
            c.clear();
        }
        c.insert(text.to_string(), out.clone());
    }
    out
}

fn translate(text: &str, depth: u32) -> String {
    let tables = tables();
    if let Some(en) = tables.exact.get(text) {
        return (*en).to_string();
    }
    if depth > 6 || text.is_empty() {
        return text.to_string();
    }
    // Multi-line text: translate per line.
    if text.contains('\n') {
        return text
            .split('\n')
            .map(|line| translate(line, depth + 1))
            .collect::<Vec<_>>()
            .join("\n");
    }
    for template in &tables.templates {
        let Some(captures) = match_parts(text, &template.parts) else {
            continue;
        };
        let translated: Vec<String> = captures.iter().map(|c| translate(c, depth + 1)).collect();
        let (en_parts, en_holes) = split_template(template.english);
        let mut used = vec![false; template.holes.len()];
        let mut out = en_parts[0].clone();
        for (k, token) in en_holes.iter().enumerate() {
            let pick = (0..template.holes.len())
                .find(|&i| !used[i] && template.holes[i] == *token)
                .or_else(|| (0..template.holes.len()).find(|&i| !used[i]));
            if let Some(i) = pick {
                used[i] = true;
                out.push_str(&translated[i]);
            }
            out.push_str(&en_parts[k + 1]);
        }
        return out;
    }
    text.to_string()
}

/// Settings file in the user config dir.
pub const SETTINGS_FILE: &str = "settings.json";

/// Read the stored language (English when missing or unreadable).
pub fn load_language(dir: &Path) -> Lang {
    std::fs::read(dir.join(SETTINGS_FILE))
        .ok()
        .and_then(|b| serde_json::from_slice::<serde_json::Value>(&b).ok())
        .and_then(|v| v.get("language")?.as_str().and_then(Lang::from_code))
        .unwrap_or_default()
}

/// Store the language atomically.
pub fn save_language(dir: &Path, lang: Lang) -> Result<(), String> {
    std::fs::create_dir_all(dir).map_err(|e| e.to_string())?;
    let bytes = serde_json::to_vec_pretty(&serde_json::json!({ "language": lang.code() }))
        .map_err(|e| e.to_string())?;
    let temp = dir.join(format!("{SETTINGS_FILE}.tmp-{}", std::process::id()));
    std::fs::write(&temp, bytes).map_err(|e| e.to_string())?;
    std::fs::rename(&temp, dir.join(SETTINGS_FILE)).map_err(|e| e.to_string())
}

#[cfg(test)]
mod tests {
    use super::*;

    fn holes(s: &str) -> Vec<String> {
        let mut h = split_template(s).1;
        h.sort();
        h
    }

    #[test]
    fn every_entry_has_both_languages_with_the_same_placeholders() {
        let mut seen = std::collections::HashSet::new();
        for (nl, en) in TABLE {
            assert!(
                !nl.is_empty() && !en.trim().is_empty(),
                "empty entry {nl:?}"
            );
            assert!(seen.insert(*nl), "duplicate key {nl:?}");
            assert_eq!(holes(nl), holes(en), "placeholders differ: {nl:?} / {en:?}");
        }
    }

    #[test]
    fn exact_templates_nested_and_runtime_switch() {
        assert_eq!(tr(Lang::En, "Project laden"), "Load project");
        assert_eq!(tr(Lang::Nl, "Project laden"), "Project laden");
        assert_eq!(
            tr(Lang::En, "Oude onvoltooide render verwijderd: inprogress-1"),
            "Old unfinished render removed: inprogress-1"
        );
        // Nested: outer template with a translated inner message.
        assert_eq!(
            tr(Lang::En, "atlas: raw files/x.png: PNG groter dan limiet"),
            "atlas: raw files/x.png: PNG larger than the limit"
        );
        assert_eq!(
            tr(
                Lang::En,
                "voltooide render faalt controle: .ppda: ongeldige fps"
            ),
            "completed render fails verification: .ppda: invalid fps"
        );
        // Unknown text passes through.
        assert_eq!(tr(Lang::En, "xyz 123"), "xyz 123");
        set_lang(Lang::Nl);
        assert_eq!(t("Opslaan"), "Opslaan");
        set_lang(Lang::En);
        assert_eq!(t("Opslaan"), "Save");
    }

    #[test]
    fn settings_round_trip_and_default_english() {
        let dir = std::env::temp_dir().join(format!("paperdoll-i18n-{}", std::process::id()));
        let _ = std::fs::remove_dir_all(&dir);
        assert_eq!(load_language(&dir), Lang::En);
        save_language(&dir, Lang::Nl).unwrap();
        assert_eq!(load_language(&dir), Lang::Nl);
        std::fs::write(dir.join(SETTINGS_FILE), b"garbage").unwrap();
        assert_eq!(load_language(&dir), Lang::En);
        let _ = std::fs::remove_dir_all(dir);
    }

    /// Minimal Rust string-literal scanner for the coverage test.
    fn literals(code: &str) -> Vec<String> {
        let b = code.as_bytes();
        let mut out = Vec::new();
        let mut i = 0;
        while i < b.len() {
            if code[i..].starts_with("//") {
                i = code[i..].find('\n').map_or(b.len(), |j| i + j);
                continue;
            }
            if b[i] == b'\'' {
                // char literal like '"' or '\\'
                let rest = &code[i..];
                let len = if rest.starts_with("'\\") { 4 } else { 3 };
                if rest.len() >= len && rest.as_bytes()[len - 1] == b'\'' {
                    i += len;
                    continue;
                }
            }
            if b[i] == b'r'
                && (i == 0 || !(b[i - 1].is_ascii_alphanumeric() || b[i - 1] == b'_'))
                && code[i + 1..].starts_with(['"', '#'])
            {
                let hashes = code[i + 1..].chars().take_while(|c| *c == '#').count();
                if code[i + 1 + hashes..].starts_with('"') {
                    let end = format!("\"{}", "#".repeat(hashes));
                    let start = i + 2 + hashes;
                    let j = code[start..].find(&end).map_or(b.len(), |j| start + j);
                    i = j + end.len();
                    continue;
                }
            }
            if b[i] == b'"' {
                let byte_lit = i > 0 && b[i - 1] == b'b';
                let mut j = i + 1;
                let mut s = String::new();
                while j < b.len() && b[j] != b'"' {
                    if b[j] == b'\\' {
                        s.push_str(&code[j..j + 2]);
                        j += 2;
                    } else {
                        let c = code[j..].chars().next().unwrap();
                        s.push(c);
                        j += c.len_utf8();
                    }
                }
                if !byte_lit {
                    out.push(s);
                }
                i = j + 1;
                continue;
            }
            i += code[i..].chars().next().map_or(1, char::len_utf8);
        }
        out
    }

    fn unescape(s: &str) -> String {
        let mut out = String::new();
        let mut chars = s.chars().peekable();
        while let Some(c) = chars.next() {
            if c != '\\' {
                out.push(c);
                continue;
            }
            match chars.next() {
                Some('n') => out.push('\n'),
                Some('t') => out.push('\t'),
                Some('\n') => {
                    while chars.peek().is_some_and(|c| c.is_whitespace()) {
                        chars.next();
                    }
                }
                Some(other) => out.push(other),
                None => {}
            }
        }
        out
    }

    #[test]
    fn every_user_visible_source_string_has_a_translation() {
        let keys: std::collections::HashSet<&str> = TABLE.iter().map(|(nl, _)| *nl).collect();
        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
        let mut missing = Vec::new();
        for entry in std::fs::read_dir(dir).unwrap() {
            let path = entry.unwrap().path();
            let name = path.file_name().unwrap().to_string_lossy().to_string();
            if !name.ends_with(".rs")
                || name == "main.rs"
                || name == "i18n_table.rs"
                || name == "i18n.rs"
            {
                continue;
            }
            let code = std::fs::read_to_string(&path).unwrap();
            let code = code
                .find("\n#[cfg(test)]\nmod tests")
                .map_or(code.as_str(), |i| &code[..i]);
            for lit in literals(code) {
                let text = unescape(&lit);
                let letters = text.chars().filter(|c| c.is_alphabetic()).count() >= 3;
                let wordy = text.contains(' ') || text.contains(['é', 'ë', 'ï']);
                if letters && wordy && !keys.contains(text.as_str()) {
                    missing.push(format!("{name}: {text:?}"));
                }
            }
        }
        assert!(missing.is_empty(), "untranslated:\n{}", missing.join("\n"));
    }
}