//! antimixedutf8 — blocks spam that mixes Unicode scripts within words (Latin
//! letters swapped for Cyrillic/Greek look-alikes: "ＦᏒｅe Ⅴ1аgrа"). The scoring
//! rules and the confusable / fancy-Latin / zero-width tables define what counts as
//! spam.
//!
//! Per word: letters from more than one script score; so do words that are ASCII
//! mixed with Latin-confusable letters, words built almost entirely of confusables,
//! and "fancy" styled-Latin words. Zero-width chars score too. At/above the
//! configured threshold the action fires (block | kill | gline | kline | zline).

use crate::module::{ModResult, Module};
use crate::server::Server;
use crate::xline::XKind;
use crate::Uid;

#[derive(Clone, Copy, PartialEq, Eq)]
enum Script {
    Other = 0, // digits, punctuation, symbols — ignored for mixing
    Latin,
    Cyrillic,
    Greek,
    Armenian,
    Hebrew,
    Arabic,
    Cjk,
}

/// Map a codepoint to a script; `Other` for anything that isn't a letter we track.
fn classify_script(cp: u32) -> Script {
    match cp {
        0x41..=0x5A | 0x61..=0x7A => Script::Latin, // ASCII A-Z a-z
        0x00C0..=0x024F => Script::Latin,           // Latin-1 suppl + extended
        0x0370..=0x03FF => Script::Greek,
        0x0400..=0x04FF => Script::Cyrillic,
        0x0530..=0x058F => Script::Armenian,
        0x0590..=0x05FF => Script::Hebrew,
        0x0600..=0x06FF => Script::Arabic,
        0x4E00..=0x9FFF => Script::Cjk, // CJK unified
        0x3040..=0x30FF => Script::Cjk, // hiragana / katakana
        _ => Script::Other,
    }
}

/// A non-Latin letter that looks like an ASCII Latin letter (a homoglyph). Catches
/// pure-homoglyph words that script-mixing misses, without tripping on genuine
/// monolingual text.
fn is_latin_confusable(cp: u32) -> bool {
    matches!(
        cp,
        // Cyrillic look-alikes
        0x0430 | 0x0410 | 0x0435 | 0x0415 | 0x043E | 0x041E | 0x0440 | 0x0420 |
        0x0441 | 0x0421 | 0x0443 | 0x0423 | 0x0445 | 0x0425 | 0x0456 | 0x0406 |
        0x0455 | 0x0405 | 0x0458 | 0x0408 | 0x043A | 0x041A | 0x043C | 0x041C |
        0x043D | 0x041D | 0x0432 | 0x0412 | 0x0442 | 0x0422 |
        // Greek look-alikes
        0x03BF | 0x039F | 0x03B1 | 0x0391 | 0x03B5 | 0x0395 | 0x03C1 | 0x03A1 |
        0x03C5 | 0x03A5 | 0x03BD | 0x03BA | 0x039A | 0x03B9 | 0x0399 | 0x03BC |
        0x0392 | 0x039D | 0x03A4 | 0x0397 | 0x03A7 | 0x0396
    )
}

/// "Fancy" Latin: fullwidth, mathematical alphanumerics, enclosed/circled letters.
/// These render as styled ASCII ("𝐅𝐫𝐞𝐞", "Ｆｒｅｅ", "🅵🆁🅴🅴") — pure obfuscation.
fn is_fancy_latin(cp: u32) -> bool {
    matches!(
        cp,
        0xFF21..=0xFF5A     // fullwidth A-Z a-z
        | 0x1D400..=0x1D7FF // mathematical alphanumeric symbols
        | 0x1F130..=0x1F189 // squared/enclosed latin
        | 0x24B6..=0x24E9   // circled latin
        | 0x2460..=0x24FF   // enclosed alphanumerics (loose)
    )
}

/// Invisible / zero-width characters used to split words and evade filters.
fn is_invisible(cp: u32) -> bool {
    matches!(
        cp,
        0x00AD | 0x200B | 0x200C | 0x200D | 0x2060 | 0xFEFF | 0x180E
    )
}

/// Per-message tally, folded word by word.
#[derive(Default)]
struct Scorer {
    mixedwords: u32,     // words mixing >1 real script
    homoglyphwords: u32, // ASCII + confusable letters in one word
    purehomowords: u32,  // word made (almost) entirely of confusables
    fancywords: u32,     // words containing fancy/styled latin
    invisibles: u32,     // zero-width chars anywhere
    totalletters: u32,
    latinletters: u32,
    wordhas: [bool; 8],
    word_has_ascii: bool,
    word_has_confusable: bool,
    word_has_fancy: bool,
    word_letters: u32,
    word_confusables: u32,
}

impl Scorer {
    fn word_scripts(&self) -> u32 {
        (1..8).filter(|&s| self.wordhas[s]).count() as u32
    }

    fn reset_word(&mut self) {
        self.wordhas = [false; 8];
        self.word_has_ascii = false;
        self.word_has_confusable = false;
        self.word_has_fancy = false;
        self.word_letters = 0;
        self.word_confusables = 0;
    }

    fn end_word(&mut self) {
        // Confusable mixed with real ASCII in one word: count once here so a single
        // stray homoglyph doesn't also score as script-mixing.
        if self.word_has_confusable && self.word_has_ascii {
            self.homoglyphwords += 1;
        } else if self.word_scripts() >= 2 {
            self.mixedwords += 1;
        } else if !self.word_has_ascii
            && self.word_scripts() == 1
            && self.word_letters >= 4
            && self.word_confusables * 100 / self.word_letters >= 80
        {
            // single-script word with no ASCII, ≥80% confusables = Latin in disguise
            self.purehomowords += 1;
        }
        if self.word_has_fancy {
            self.fancywords += 1;
        }
        self.reset_word();
    }
}

/// Score a message for look-alike / obfuscated-text spam. Higher = worse; genuine
/// monolingual text (any script) stays at 0.
fn score_message(text: &str) -> u32 {
    let mut sc = Scorer::default();
    for cp in text.chars().map(|c| c as u32) {
        if is_invisible(cp) {
            sc.invisibles += 1;
            continue; // not a word boundary
        }
        let fancy = is_fancy_latin(cp);
        let confusable = is_latin_confusable(cp);
        let script = classify_script(cp);
        let isletter = script != Script::Other || fancy;
        let isboundary = matches!(cp, 0x20 | 0x09 | 0x2C | 0x2E | 0x21 | 0x3F | 0xFFFD);

        if isletter {
            if script != Script::Other {
                sc.wordhas[script as usize] = true;
            }
            sc.totalletters += 1;
            sc.word_letters += 1;
            if script == Script::Latin {
                sc.latinletters += 1;
                sc.word_has_ascii = true;
            }
            if confusable {
                sc.word_has_confusable = true;
                sc.word_confusables += 1;
            }
            if fancy {
                sc.word_has_fancy = true;
            }
        }
        if isboundary {
            sc.end_word();
        }
    }
    sc.end_word(); // final word

    // One disguised word is usually an accident (a pasted Cyrillic letter); real
    // attacks disguise MANY. Grant a 1-word grace.
    let disguised = sc.homoglyphwords + sc.mixedwords + sc.purehomowords + sc.fancywords;
    let effective = disguised.saturating_sub(1);

    let mut score = 0u32;
    score += effective * 5; // each disguised word past the first
    score += sc.fancywords; // styled unicode is rarely innocent
    score += sc.invisibles * 3; // zero-width evasion is always suspicious

    // Ratio bonus: only with real disguise (≥2 words) and non-Latin dominance.
    if sc.totalletters >= 8 && disguised >= 2 {
        let nonlatin = sc.totalletters - sc.latinletters;
        if nonlatin > 0 && sc.latinletters > 0 && nonlatin * 100 / sc.totalletters >= 40 {
            score += 3;
        }
    }
    score
}

/// If `text` is a CTCP, return the ACTION body to check, else `None` to skip
/// (non-ACTION CTCPs aren't scanned). Plain messages return the text unchanged.
fn checkable(text: &str) -> Option<&str> {
    let Some(inner) = text.strip_prefix('\u{01}') else {
        return Some(text);
    };
    let inner = inner.strip_suffix('\u{01}').unwrap_or(inner);
    let (name, body) = inner.split_once(' ').unwrap_or((inner, ""));
    if name.eq_ignore_ascii_case("ACTION") {
        Some(body)
    } else {
        None
    }
}

/// A single-line, length-capped snippet of a blocked message for the oper
/// snotice. Keeps the look-alike glyphs visible (that's the point) but neutralises
/// every control byte (CR/LF, mIRC formatting) so it can't inject into or break
/// the protocol line the snotice is embedded in.
fn snippet(text: &str) -> String {
    const MAX: usize = 120;
    let mut out = String::new();
    for (i, ch) in text.chars().enumerate() {
        if i >= MAX {
            out.push('…');
            break;
        }
        if (ch as u32) < 0x20 || ch == '\u{7f}' {
            out.push(' ');
        } else {
            out.push(ch);
        }
    }
    out
}

pub struct AntiMixedUtf8;

impl Module for AntiMixedUtf8 {
    fn name(&self) -> &'static str {
        "antimixedutf8"
    }

    fn on_pre_message(
        &mut self,
        srv: &mut Server,
        uid: Uid,
        target: &str,
        text: &str,
    ) -> ModResult {
        if !srv.amu.enable {
            return ModResult::Passthru;
        }
        // exempt opers and users logged into an account
        if srv.is_oper(uid) || srv.is_logged_in(uid) {
            return ModResult::Passthru;
        }
        let is_channel = target.starts_with('#');
        if (is_channel && !srv.amu.check_channel) || (!is_channel && !srv.amu.check_private) {
            return ModResult::Passthru;
        }
        let Some(body) = checkable(text) else {
            return ModResult::Passthru;
        };
        if body.chars().count() < srv.amu.minlen {
            return ModResult::Passthru;
        }
        let score = score_message(body);
        if score < srv.amu.threshold {
            return ModResult::Passthru;
        }

        let (nick, mask, host, ip) = {
            let Some(u) = srv.users.get(&uid) else {
                return ModResult::Passthru;
            };
            (
                u.nick.clone(),
                u.prefix(),
                u.host.clone(),
                u.addr.ip().to_string(),
            )
        };
        // Snotice a sanitized snippet so opers can judge the catch / spot false positives.
        srv.snotice(&format!(
            "ANTIMIXEDUTF8: blocked spam from {mask} to {target} (score {score} >= {}): {}",
            srv.amu.threshold,
            snippet(body)
        ));

        // Notify the sender even for punitive actions: the writer flushes queued
        // lines before a disconnect.
        srv.send(
            uid,
            format!(
                ":{} NOTICE {nick} :*** {} (Flagged by the spam filter; network operators have been notified.)",
                srv.name, srv.amu.block_msg
            ),
        );

        let action = srv.amu.action.to_ascii_lowercase();
        let (dur, reason, setter) = (
            srv.amu.duration,
            srv.amu.reason.clone(),
            format!("antimixedutf8@{}", srv.name),
        );
        match action.as_str() {
            "gline" => srv.add_xline(XKind::Gline, &format!("*@{host}"), dur, &setter, &reason),
            "kline" => srv.add_xline(XKind::Kline, &format!("*@{host}"), dur, &setter, &reason),
            "zline" => srv.add_xline(XKind::Zline, &ip, dur, &setter, &reason),
            "kill" => srv.remove_user(uid, &reason),
            // "block": also emit the standard channel-failure numeric so clients
            // render the drop inline; the explanatory NOTICE above covers the rest.
            _ if is_channel => srv.numeric(
                uid,
                crate::numeric::ERR_CANNOTSENDTOCHAN,
                &format!("{target} :Message blocked by the spam filter"),
            ),
            _ => {}
        }
        ModResult::Deny
    }
}

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

    #[test]
    fn genuine_monolingual_text_scores_zero() {
        assert_eq!(score_message("hello everyone how are you today"), 0); // Latin
        assert_eq!(score_message("привет всем как у вас дела сегодня"), 0); // Russian
        assert_eq!(score_message("γεια σας πως ειστε ολοι σημερα εδω"), 0); // Greek
    }

    #[test]
    fn mixed_script_spam_scores_high() {
        // Cyrillic look-alikes swapped into Latin words (multi-word disguise)
        assert!(score_message("Ѕесurіtу аlеrt сlісk hеrе nоw рlеаѕе") >= 8);
        // fancy/fullwidth styled word run
        assert!(score_message("Ｆｒｅｅ Ｖ１ａｇｒａ ｎｏｗ ｃｌｉｃｋ ｈｅｒｅ") >= 8);
    }

    #[test]
    fn one_stray_homoglyph_is_tolerated() {
        // a single disguised word gets the 1-word grace → stays under threshold
        assert!(score_message("hello wоrld this is a normal message") < 8);
    }

    #[test]
    fn zero_width_evasion_scores() {
        // three zero-width joiners = 3*3 = 9
        assert!(score_message("buy\u{200b}now\u{200b}cheap\u{200b}deal") >= 8);
    }

    #[test]
    fn snippet_is_one_clean_line_and_capped() {
        // CR/LF and mIRC control bytes are neutralised (no protocol injection)
        assert_eq!(snippet("hi\r\nthere"), "hi  there");
        assert!(!snippet("x\u{03}04red").contains('\u{03}'));
        // look-alike glyphs survive so opers can see what was caught
        assert!(snippet("Ѕесurіtу").contains('Ѕ'));
        // long input is capped with an ellipsis
        let s = snippet(&"a".repeat(200));
        assert!(s.ends_with('…') && s.chars().count() == 121);
    }
}