"""Normalisasi teks komentar Indonesia: slang, singkatan, typo, elongasi, leetspeak, sensor, dll.

Pakai:
    from normalisasi import Normalizer
    nz = Normalizer()                                   # baca kamus_normalisasi.json di folder ini
    nz("gw gk bs dtg krn ujan bgtttt, mkn2 di skolah anak2 enak bngt wkwkwk")
    -> 'saya tidak bisa datang karena ujan banget, makan-makan di sekolah anak-anak enak banget wkwk'

    nz.explain("ngerasain")  -> ('merasakan', 'kamus:informal')
    Normalizer(categories={'negasi','singkatan','ejaan'}, min_confidence='high')   # versi hemat

File yang dibutuhkan: normalisasi.py + kamus_normalisasi.json (tanpa dependensi luar).
Urutan per token: protected -> kamus -> angka+satuan -> tawa -> leet -> sensor(*) -> reduplikasi
-> elongasi -> klitik (-nya/-ku/-mu/-lah) -> imbuhan informal (-in, nge-) -> sisip vokal (typo).
"""
import html
import json
import re
from functools import lru_cache
from pathlib import Path

HERE = Path(__file__).parent
CONF_RANK = {'low': 0, 'medium': 1, 'high': 2}
DEFAULT_CATEGORIES = {'negasi', 'singkatan', 'ejaan', 'informal', 'imbuhan', 'kasar', 'daerah',
                      'interjeksi', 'domain', 'auto', 'eksternal'}
ALL_CATEGORIES = DEFAULT_CATEGORIES | {'inggris', 'emoji'}

LEET = str.maketrans({'0': 'o', '1': 'i', '3': 'e', '4': 'a', '5': 's', '6': 'g', '7': 't', '8': 'b',
                      '9': 'g', '@': 'a', '$': 's', '!': 'i', '|': 'l', '+': 't'})
UNITS = [(r'(rb|rbu|ribu|rebu|k)', 'ribu'), (r'(jt|jta|juta)', 'juta'), (r'(m|miliar|milyar|em)', None),
         (r'(t|t\b|triliun|trilyun)', 'triliun'), (r'(x|kali|kl)', 'kali'), (r'(th|thn|tahun|taun)', 'tahun'),
         (r'(bln|bulan)', 'bulan'), (r'(hr|hari)', 'hari'), (r'(mg|mgg|minggu)', 'minggu'), (r'(an)', '-an')]
CLITICS = ('nya', 'ny', 'nyaa', 'ku', 'mu', 'lah', 'kah', 'pun', 'tah', 'x', 'e')
CLITIC_MAP = {'ny': 'nya', 'nyaa': 'nya', 'x': 'nya', 'e': 'nya'}
AFFIX_PIECES = set('nya kan lah kah pun ber ter men mem meng meny per pen pem peng ke di se an in nan gan ngan han wan '
                   'san ran tan kas sme ing ers ion ser ana'.split())
SENSITIF = set('''korupsi koruptor goblok tolol bodoh bego bangsat anjing babi monyet kontol memek ngentot bajingan
setan iblis lonte pelacur porno bokep judi slot gacor togel bandar jancuk brengsek sialan keparat kampret tai tahi
bacot asu idiot dungu kafir sange bugil telanjang seks pantat jembut titit ngewe cabul mesum bencong banci'''.split())
NEG_BLOCK = set('ringan tuh mana pada kaya ringannya haha ngan peru ijin perah ruk mbar lak nja ntar jah ram ris'.split())
PREP_BLOCK = {'keluar'}                 # kata sah, bukan 'ke luar'
SEG_JUNK = set('''her how age able own did toy our are any sing king tik pin yalah loh enya iya ended ship war red pan pro
man may ama uring hat'''.split())
KBBI_PREFIX = re.compile(r'(?:me|di|ber|ter|pe|ke|se)')
DOTTED = re.compile(r'[a-z]{2,}(?:\.[a-z]{2,})+')
TLD = set('com id co net org go ac my sch or tv info io me biz web gov edu'.split())
# aturan yang tidak boleh menyentuh kata KBBI (hasil audit: gagang->tidak gang, timbangan->tim buangan, beling->beliung)
GUARDED = {'sisip_vokal', 'klitik', 'negasi_gabung', 'elongasi', 'leet', 'transposisi'}   # segmentasi: dijaga di _segment
DERIV_PRE = ('memper', 'diper', 'mem', 'men', 'meng', 'meny', 'me', 'di', 'ber', 'ter', 'ke', 'se', 'pe', 'pem',
             'pen', 'peng', 'per', 'pel')
DERIV_SUF = ('kannya', 'kanlah', 'kan', 'annya', 'an', 'inya', 'i', 'nya', 'lah', 'ku', 'mu', 'isme', 'is', 'isasi', 'itas',
             'alis', 'alisme', 'istik', 'tik', 'ik', 'wan', 'wati')
KE_TER_BLOCK = set('''banyak cepat kaya mudah nama bang pal nak besar kecil baik buruk tinggi rendah murah mahal
kuat lemah lama baru dekat jauh bagus enak indah pintar bodoh sedikit penting hebat parah luas sempit dalam'''.split())
PLACE = set("""sekolah sekolahan rumah kampung kantin kamar kota desa jalan atas bawah dalam luar
depan belakang samping dapur kelas pasar kantor daerah indonesia jakarta tempat hotel restoran warung pelosok lapangan
kampus masjid gereja provinsi kabupaten negeri negara pagi siang sore malam akhir awal tengah antara sekitar sebelah
mall rs puskesmas posyandu tv medsos sosmed hp internet youtube tiktok instagram twitter grup kota sawah pantai
""".split())

TOKEN_RE = re.compile(r"""
  (?P<url>https?://\S+|www\.\S+)
| (?P<email>[\w.+-]+@[\w-]+\.[\w.]+)
| (?P<tag>[@#][\w.]+)
| (?P<emo>[:;=8xX][-'^]?[)(DPpOo3/\\|\]\[*]+|<3+|[)(]:|T_T|\^_?\^)
| (?P<word>[^\W_]+(?:[*@$!.'_-][^\W_]+)*[*]*)
| (?P<other>\S)
""", re.X | re.U)
EMOTICON = {':)': 'senyum', ':-)': 'senyum', '=)': 'senyum', ':]': 'senyum', ';)': 'senyum', ':d': 'tertawa',
            ':-d': 'tertawa', 'xd': 'tertawa', '=d': 'tertawa', ':(': 'sedih', ':-(': 'sedih', ":'(": 'menangis',
            't_t': 'menangis', ':p': 'bercanda', ':-p': 'bercanda', '<3': 'cinta', ':*': 'cium', ':o': 'kaget',
            '^_^': 'senyum', '^^': 'senyum', ':/': 'bingung', ':3': 'imut'}
EMOJI = {'😂': 'tertawa', '🤣': 'tertawa', '😆': 'tertawa', '😁': 'senyum', '😀': 'senyum', '😊': 'senyum',
         '🙂': 'senyum', '😍': 'suka', '🥰': 'suka', '😘': 'cinta', '❤': 'cinta', '❤️': 'cinta', '♥': 'cinta',
         '💕': 'cinta', '👍': 'bagus', '👌': 'bagus', '💯': 'sempurna', '🔥': 'keren', '👏': 'tepuk tangan',
         '🙏': 'mohon', '😭': 'menangis', '😢': 'sedih', '😞': 'kecewa', '😔': 'sedih', '😡': 'marah',
         '😠': 'marah', '🤬': 'marah', '😤': 'kesal', '😒': 'kesal', '🙄': 'kesal', '🤮': 'jijik',
         '🤢': 'jijik', '💩': 'tahi', '🐷': 'babi', '🐶': 'anjing', '🐒': 'monyet', '🐵': 'monyet',
         '🤔': 'bingung', '😱': 'kaget', '😮': 'kaget', '🥺': 'memohon', '😴': 'mengantuk', '🤤': 'enak',
         '😋': 'enak', '👎': 'buruk', '💪': 'semangat', '🤲': 'berdoa', '😅': 'canggung', '🤦': 'kecewa'}
EMOJI_NAME = {'facewithtearsofjoy': 'tertawa', 'rollingonthefloorlaughing': 'tertawa', 'loudlycryingface': 'menangis',
              'redheart': 'cinta', 'thumbsup': 'bagus', 'clappinghands': 'tepuk tangan', 'foldedhands': 'mohon',
              'poutingface': 'marah', 'smilingfacewithhearteyes': 'suka', 'pileofpoo': 'tahi', 'thinkingface': 'bingung',
              'enragedface': 'marah', 'facewithrollingeyes': 'kesal', 'pleadingface': 'memohon', 'fire': 'keren'}


_PAIRS = ('gonta ganti|bolak balik|mondar mandir|kocar kacir|porak poranda|compang camping|serba serbi|sayur mayur|'
          'lauk pauk|tanya jawab|teka teki|plin plan|ceplas ceplos|huru hara|carut marut|kucar kacir|morat marit|'
          'lika liku|seluk beluk|corat coret|hiruk pikuk|simpang siur|warna warni|ramah tamah|basa basi|'
          'iming iming|ujug ujug|ecek ecek|mencak mencak|unek unek|omon omon|boro boro|semena mena|bertele tele|utak atik')
_PAIR_RE = re.compile(r'\b(?:' + _PAIRS + r')\b')


def _decode_bytes(m):
    try:
        return ' ' + bytes.fromhex(m[0].replace('\\x', '')).decode('utf-8') + ' '
    except (UnicodeDecodeError, ValueError):
        return ' '


class Normalizer:
    def __init__(self, path=None, categories=None, min_confidence='medium', rules=True, split_prep=True,
                 lowercase=True, emoticon=True, segment=True, join_nya=True, join_redup=True, vokal_e=False, extra=None,
                 guard=True):
        self.join_nya, self.join_redup, self.vokal_e, self.guard = join_nya, join_redup, vokal_e, guard
        path = Path(path) if path else HERE / 'kamus_normalisasi.json'
        data = json.loads(path.read_text(encoding='utf-8'))
        self.categories = set(categories) if categories else set(DEFAULT_CATEGORIES)
        self.min_rank = CONF_RANK[min_confidence]
        self.rules, self.split_prep, self.lowercase, self.emoticon = rules, split_prep, lowercase, emoticon
        self.vocab = data['vocab']                                   # kata baku -> frekuensi
        self.protected = set(data['protected'])
        self.ambiguous = set(data['ambiguous'])
        self.map, self.why, self.phrases = {}, {}, {}
        order = data['category_order']
        best = {}
        for v, c, cat, conf, src in data['entries']:
            if cat not in self.categories or CONF_RANK[conf] < self.min_rank:
                continue
            key = (CONF_RANK[conf], -order.index(cat) if cat in order else -99)
            if v not in best or key > best[v][0]:
                best[v] = (key, c, f'{src}:{cat}')
        for v, (_, c, why) in best.items():
            if ' ' in v:
                self.phrases[v] = c
            else:
                self.map[v], self.why[v] = c, why
        for v, c in (extra or {}).items():
            self.map[v.lower()], self.why[v.lower()] = c, 'extra'
        self.known = set(self.vocab) | set(self.map.values()) | self.protected
        self._phrase_re = (re.compile(r'(?<!\w)(' + '|'.join(sorted(map(re.escape, self.phrases), key=len, reverse=True)) + r')(?!\w)')
                           if self.phrases else None)
        self.vocab_en = data.get('vocab_en', {})
        self.valid = set(data.get('valid', []))
        self.caps = set(data.get('caps', [])) - set(self.map)     # nama/akronim (sering ditulis kapital): aturan tidak menyentuh
        self.known |= set(self.vocab_en) | self.valid
        self.kbbi = set(data.get('kbbi', []))                      # kata KBBI: dilindungi dari aturan rawan (GUARDED)
        self.block = set(data.get('block', [])) - set(self.map)    # token yang ditolak audit: dibiarkan apa adanya
        self.known |= self.block
        self.segment_long = segment
        total = sum(self.vocab.values()) or 1
        import math
        cand = {w: f + self.vocab_en.get(w, 0) for w, f in self.vocab.items()}
        for w, f in self.vocab_en.items():
            cand.setdefault(w, f)
        vfreq = data.get('vfreq', {})                                # frekuensi korpus varian slang (makasih 7rb)
        self._canon = {v for v in self.map.values() if v.isalpha()}
        for k in list(self.map) + list(self.protected):
            cand.setdefault(k, max(30, vfreq.get(k, 0)))
        for v in set(self.map.values()):
            if v.isalpha():
                cand.setdefault(v, 30)                               # masyaallah, insyaallah: kanonik juga potongan sah
        for w in self.kbbi:
            if len(w) >= 5 and w.isalpha() and not KBBI_PREFIX.match(w):
                cand.setdefault(w, 5)                                # suntik: kata dasar sah walau jarang di berita (bukan memper-, menge-)
        self._cost = {w: -math.log(f / total) for w, f in cand.items() if w.isalpha() and self._seg_ok(w)}
        self._maxlen = max(map(len, self._cost)) if self._cost else 0
        skel = {}
        for w in data.get('common', []):      # kata Indonesia yang umum di komentar & berita
            skel.setdefault(self._skeleton(w), []).append(w)
        self.skel = {k: sorted(v, key=lambda w: -self.vocab[w]) for k, v in skel.items()}
        self.kasar = {c for v, c, cat, *_ in data['entries'] if cat == 'kasar'}

    # ------------------------------------------------------------------ public
    def __call__(self, text):
        return self.normalize(text)

    def normalize(self, text):
        if not isinstance(text, str):
            return ''
        t = re.sub(r'(?:\\x[0-9a-fA-F]{2})+', _decode_bytes, text)        # '\xf0\x9f\x98\x82' -> emoji
        t = html.unescape(t).replace('\\n', ' ').replace('\\t', ' ')
        if self.lowercase:
            t = t.lower()
        if 'emoji' in self.categories:
            for e, w in EMOJI.items():
                t = t.replace(e, f' {w} ')
        t = self._join_spaced(t)
        if self._phrase_re:
            t = self._phrase_re.sub(lambda m: self.phrases[m[1]], t)
        out = []
        for m in TOKEN_RE.finditer(t):
            kind, tok = m.lastgroup, m[0]
            if kind == 'word':
                out.append(self.word(tok))
            elif kind == 'tag' and tok[0] == '#' and self.segment_long:
                body = tok[1:].lower()
                seg = self.map.get(body) or self._segment(body, 0)
                out.append(seg or tok)
            elif kind == 'emo' and self.emoticon and tok.lower() in EMOTICON and 'emoji' in self.categories:
                out.append(EMOTICON[tok.lower()])
            else:
                out.append(tok)
        s = ' '.join(x for x in out if x)
        s = re.sub(r'\s+([,.!?;](?=\s|$))', r'\1', s)
        if self.join_nya:
            s = re.sub(r'(?<=\w) (nya)\b', r'\1', s)       # "rumah nya" -> "rumahnya"
        if self.join_redup:
            # reduplikasi berspasi: "gara gara" -> "gara-gara", "berkali kali", "ugal ugalan", "gonta ganti"
            s = re.sub(r'\b(?!wk|ha|he|hi|hu)([a-z]{2,}) \1(an|nya)?\b', r'\1-\1\2', s)
            s = re.sub(r'\b(ber|se|ter|di|me)([a-z]{3,}) \2(an|nya)?\b', r'\1\2-\2\3', s)
            s = _PAIR_RE.sub(lambda m: m[0].replace(' ', '-'), s)
        return re.sub(r'\s+', ' ', s).strip()

    def explain(self, token):
        return self._norm(token.lower())

    def word(self, tok):
        low = tok.lower()
        if '.' in low and DOTTED.fullmatch(low) and low.rsplit('.', 1)[1] not in TLD:
            return '. '.join(self.word(p) for p in low.split('.'))   # 'sama aja.tak kira' (spasi setelah titik hilang)
        res, _ = self._norm(low)
        if res == low:
            return tok
        return res

    # ------------------------------------------------------------------ core
    @lru_cache(maxsize=200_000)
    def _norm(self, w, depth=0):
        if w in self.protected:
            return w, 'protected'
        if w in self.map:
            res = self.map[w]
            if res in self.map and self.map[res] != res and ' ' not in res:
                res = self.map[res]          # recomended -> recommended -> direkomendasikan (bila kategori inggris aktif)
            return res, 'kamus:' + self.why[w]
        if not self.rules or depth > 2:
            return w, 'tetap'
        if 'emoji' in self.categories and w in EMOJI_NAME:
            return EMOJI_NAME[w], 'emoji'
        r = self._number_unit(w)
        if r:
            return r, 'angka'
        r = self._laugh(w)
        if r:
            return r, 'tawa'
        r = self._prep(w, depth)
        if r:
            return r, 'preposisi'
        if w in self.caps:
            return w, 'nama'
        if w in self.known and w not in self.ambiguous:
            # kata informal yang kebetulan ada di korpus berita: pesen/bales -> pesan/balas bila jauh lebih umum
            if self.vokal_e and w in self.vocab and w.isalpha() and w not in self.valid:
                c = re.sub(r'e(?=[^aeiou]+$)', 'a', w, count=1)
                if c != w and self.vocab.get(c, 0) >= 30 * max(self.vocab[w], 1) and self.vocab[w] < 50:
                    return c, 'vokal_e'
            return w, 'baku'
        for fn, name in ((self._leet, 'leet'), (self._censor, 'sensor'), (self._redup, 'reduplikasi'),
                         (self._elong, 'elongasi'), (self._transpose, 'transposisi'), (self._clitic, 'klitik'), (self._prep, 'preposisi'),
                         (self._affix, 'imbuhan'), (self._ke_ter, 'ke_ter'), (self._vokal_e, 'vokal_e'),
                         (self._neg_compound, 'negasi_gabung'),
                         (self._devowel, 'sisip_vokal'), (self._segment, 'segmentasi')):
            if name == 'vokal_e' and not self.vokal_e:
                continue
            if self.guard and w in self.kbbi and (name in GUARDED or (name == 'imbuhan' and w[0] == 'm')):
                continue        # mujur/merem/mulas/mantu: kata sah ber-m, bukan me- informal
            r = fn(w, depth)
            if r and r != w:
                return r, name
        return w, 'tetap'

    def _ok(self, w):
        return w in self.known or w in self.map

    def _lookup(self, w, depth):
        if w in self.map:
            return self.map[w]
        if w in self.known:
            return w
        r, why = self._norm(w, depth + 1)
        return r if why not in ('tetap',) else None

    # ------------------------------------------------------------------ rules
    def _number_unit(self, w):
        m = re.fullmatch(r'(\d+(?:[.,]\d+)?)([a-z]+)', w)
        if not m:
            return None
        num, unit = m.groups()
        for pat, rep in UNITS:
            if re.fullmatch(pat, unit):
                if rep is None:
                    return None
                return f'{num}{rep}' if rep.startswith('-') else f'{num} {rep}'
        return None

    @staticmethod
    def _laugh(w):
        if len(w) < 3:
            return None
        if re.fullmatch(r'(?:a?w?k)?(?:w+k+|k+w+)+[wkaskjh]*', w) and w.count('w') >= 2 and w.count('k') >= 1:
            return 'wkwk'
        if re.fullmatch(r'(?:[bw]?a?(?:ha|ah|hah|hha|aha){2,}h*a*)', w) and w.count('h') >= 2:
            return 'haha'                     # wahh/waahh = 'wah', bukan tawa
        if re.fullmatch(r'k{4,}', w):
            return 'haha'                     # kkkk (tawa ala Korea), bukan 'oke'
        if re.fullmatch(r'w?a?k?(?:ak|ka){2,}[ka]*', w) and w.startswith(('wa', 'wk')):
            return 'wkwk'                     # wakakakak, wkakakak -> bukan 'wkwk kakak'
        if re.fullmatch(r'(?:he){2,}h?e*|(?:eh){2,}e?', w):
            return 'hehe'
        if re.fullmatch(r'(?:hi){2,}h?i*|(?:xi){2,}', w):
            return 'hihi'
        if re.fullmatch(r'(?:hu){2,}h?u*', w):
            return 'huhu'
        if re.fullmatch(r'h*e*m{2,}|h+m+|e+m{2,}', w):
            return 'hmm'
        if re.fullmatch(r'(?:ck){2,}', w):
            return 'ckck'
        if re.fullmatch(r'(?:oh?)?m[ae]?[iy]?gh?[ao]+[dt]+h?|omg+|ohmy?god+', w):     # omaygottt, omaigot, omayghot
            return 'ya ampun'
        return None

    def _leet(self, w, depth):
        if not re.search(r'[a-z]', w) or not re.search(r'[0-9@$!|+]', w):
            return None
        if not re.search(r'[a-z][0-9@$!|+]+[a-z]|^[0-9@$][a-z]+[0-9@$]', w):
            return None   # 10rb, s1, md3, im3, trans7, user02 bukan leet
        if len(w) < 4 or sum(c.isalpha() for c in w) < 2:
            return None   # 4x4, 3x3: bukan kata
        t = w.translate(LEET)
        if t == w or re.search(r'\d', t):
            return None
        if t in self.map:                                  # hanya kamus / kata dikenal, tanpa rantai aturan lain
            return self.map[t]
        if (t in self.known and (self.vocab.get(t, 0) >= 50 or t in self.kasar or t in self.valid)):
            return t
        e = self._elong(t, depth)                          # g0bl00000k -> gobloook -> goblok
        return e if e and (e in self.known or e in self.map.values()) else None

    def _censor(self, w, depth):
        if '*' not in w:
            return None
        core = w.strip('*')
        if not core:
            return None
        letters = sum(ch.isalpha() for ch in core)
        if letters < 3 or core.count('*') > letters / 2:
            return None
        pat = re.compile('^' + re.escape(core).replace(r'\*', '[a-z]{1,2}') + ('[a-z]{1,2}' if w.endswith('*') else '') + '$')
        hits = [c for c in self.kasar | SENSITIF if pat.match(c)]   # sensor hanya untuk kata kasar/sensitif
        return hits[0] if len(hits) == 1 else None

    def _redup(self, w, depth):
        m = re.fullmatch(r'([a-z]{2,})(?:2|-\1)(an|nya|ku|mu|lah|kah)?', w)
        if not m:
            return None
        base = self._lookup(m[1], depth) or m[1]
        if ' ' in base:
            return None          # judol2 -> bukan 'online-online'
        suf = m[2] or ''
        if base == 'makan' and suf == 'an':
            return 'makan-makanan'
        return f'{base}-{base}{suf}'

    def _elong(self, w, depth):
        # hanya run >=3, huruf ganda di akhir, atau ee/oo/uu/hh di tengah (aa/ii sah: maaf, kerjaan, diikuti)
        if not (re.search(r'(.)\1\1', w) or re.search(r'([a-z])\1$', w) or re.search(r'ee|oo|uu|yy|hh|ww', w)):
            return None
        if not re.search(r'[aeiou]', w) or (len(w) <= 4 and not re.search(r'(.)\1\1', w)):
            return None          # pjj, tnn, ccdss, afff: singkatan/akronim, bukan elongasi
        cands = []
        base = re.sub(r'(.)\1{2,}', r'\1\1', w)
        runs = [(m[0][0], len(m[0])) for m in re.finditer(r'(.)\1*', base)]
        opts = ['']
        for ch, n in runs:
            opts = [o + ch * k for o in opts for k in ((1, 2) if n >= 2 else (1,))]
            if len(opts) > 512:
                break
        for o in opts:
            if o != w and len(o) >= 2 and (o in self.map or o in self.known or (len(o) >= 5 and o in self.kbbi)):
                cands.append(o)
        if not cands:
            return None
        o = max(cands, key=lambda c: (c in self.map, self.vocab.get(c, 0) + self.vocab_en.get(c, 0), c in self.kbbi))
        return self.map.get(o, o)

    def _transpose(self, w, depth):
        """Dua huruf terakhir tertukar: bangte -> banget, yagn -> yang (hasil harus kata sangat umum)."""
        if len(w) < 4 or not w.isalpha():
            return None
        t = w[:-2] + w[-1] + w[-2]
        if t != w and self.vocab.get(t, 0) >= 2000:
            return t
        return None

    def _clitic(self, w, depth):
        # makananya -> makanannya, bangunanya -> bangunannya (n ganda hilang)
        # tapi kartunya/susunya/tandanya = kartu/susu/tanda + -nya: hanya bila bentuk ber-n jauh lebih umum
        V = self.vocab
        if w.endswith('anya') and len(w) > 6 and w[:-3] + 'n' in self.known and len(w[:-3]) >= 4:
            if V.get(w[:-3] + 'n', 0) > 5 * V.get(w[:-3], 0) and w[:-3] not in self.map:
                return w[:-3] + 'nnya'                                         # makananya -> makanannya
            return None
        if w.endswith('nya') and len(w) > 6 and w[:-2] in self.vocab and w[:-2].endswith('n'):
            if V.get(w[:-2], 0) > 5 * V.get(w[:-3], 0) and w[:-3] not in self.map:
                return w[:-2] + 'nya'                                          # presidenya -> presidennya
        for suf in sorted(CLITICS, key=len, reverse=True):
            if w.endswith(suf) and len(w) - len(suf) >= 2:
                base = w[:-len(suf)]
                if suf in ('x', 'e') and len(base) < 3:
                    continue
                if suf == 'e' and base[-1] in 'aeiou':
                    continue      # -e Jawa hanya setelah konsonan (ibuk-e, omah-e); ajee/masie/waee = elongasi/typo
                if base in self.map and ' ' not in base:
                    b = self.map[base]
                elif suf == 'ny' and len(base) >= 4 and base in self.kbbi and self.vocab.get(base, 0) >= 20:
                    b = base      # henny/jhonny (nama) bukan hen+nya
                else:
                    continue
                if b.endswith('nya') or (b.startswith('tidak') and suf != 'nya'):
                    continue      # harusnye -> bukan harusnyanya; gamu/gatah -> bukan tidakmu/tidaktah
                return b + CLITIC_MAP.get(suf, suf)
        return None

    def _prep(self, w, depth):
        if not self.split_prep or w in PREP_BLOCK:
            return None
        for p in ('di', 'ke', 'dr'):
            if w.startswith(p) and len(w) > len(p) + 2:
                rest = w[len(p):]
                rest_n = self.map.get(rest, rest)
                if rest_n in PLACE or rest in PLACE:
                    return f"{'dari' if p == 'dr' else p} {rest_n}"
        return None

    # imbuhan informal -> baku: masukin/ngerasain/nyalahin/nolak/mikir
    @staticmethod
    def _men(root):
        c = root[0]
        if len(re.findall('[aeiou]+', root)) == 1:
            return ['menge' + root]
        if c in 'aeiou':
            return ['meng' + root]
        if c == 'k':
            return ['meng' + root[1:], 'meng' + root]
        if c in 'gh':
            return ['meng' + root]
        if c == 'p':
            return ['mem' + root[1:], 'mem' + root]
        if c in 'bfv':
            return ['mem' + root]
        if c == 't':
            return ['men' + root[1:], 'men' + root]
        if c in 'dcjz':
            return ['men' + root]
        if c == 's':
            return ['meny' + root[1:], 'men' + root]
        return ['me' + root]

    def _roots(self, stem):
        """Akar kata dari bentuk nasal informal: ngatur->atur, nyari->cari/sari, nolak->tolak, mikir->pikir."""
        roots = []
        if stem.startswith('nge'):
            roots += [stem[3:]]
        if stem.startswith('ng'):
            roots += [stem[2:], 'k' + stem[2:]]
        if stem.startswith('ny'):
            roots += ['s' + stem[2:], 'c' + stem[2:]]
        if stem.startswith('n') and not stem.startswith(('ng', 'ny')):
            roots += ['t' + stem[1:]]
        if stem.startswith('m'):
            roots += ['p' + stem[1:], 'b' + stem[1:], stem[1:]]
        if stem.startswith('me'):
            roots += [stem[2:]]
        return [r for r in roots if len(r) >= 3]

    def _affix(self, w, depth):
        if len(w) < 5 or not w.isalpha():
            return None
        V = self.vocab
        cands = []
        if w.startswith(('pe', 'pem', 'pen', 'per')) and not w.startswith('pesen'):
            return None                                          # kata benda pe-an (pemakain = typo pemakaian)
        m = re.fullmatch(r'(di|ke|ter)?([a-z]{3,}?)(in|ken)(nya|lah)?', w)
        bare = []
        if m and len(m[2]) >= 4 and (m[1] or m[2] in V or m[2] in self.map):    # mimpin: 'mimp' bukan kata
            pre, b, _, suf = m[1] or '', m[2], m[3], m[4] or ''
            for bb in {b, self.map.get(b, b)}:                   # e->a hanya lewat kamus (diledekin != diledakkan)
                cands += [pre + bb + 'kan' + suf, pre + bb + 'i' + suf]
                if bb.endswith('i') and pre:
                    bare += [pre + bb + suf]                                        # dikunciin -> dikunci (cadangan)
                if not pre and re.match(r'(nge|ng|ny)', bb):
                    for r in self._roots(bb):
                        if r in V:
                            cands += [x + 'kan' + suf for x in self._men(r)] + [x + 'i' + suf for x in self._men(r)]
            if not any(c in V for c in cands):
                cands += bare                                                       # gantiin -> gantikan dulu
        if re.match(r'(nge|ng|ny|n|m)', w):
            stem, suf = w, ''
            mm = re.fullmatch(r'(.+?)(in|nya)', w)
            variants = [] if w.endswith('nya') and not w.startswith(('ng', 'ny')) else [(w, '')]
            if mm and (mm[2] == 'in' or w.startswith(('ng', 'ny'))):
                variants.append((mm[1], mm[2]))
            for stem, suf in variants:
                if len(stem) < 4:
                    continue
                for r in self._roots(stem):
                    r2 = self.map.get(r, r)
                    if r2 not in V or V.get(r2, 0) < 5:
                        continue
                    for x in self._men(r2):
                        if suf == 'in':
                            cands += [x + 'kan', x + 'i']
                        elif suf == 'nya':
                            cands += [x + 'nya', x]
                        else:
                            cands += [x]
        cands = [c for c in dict.fromkeys(cands) if c in V and c != w]
        if not cands:
            return None
        return max(cands, key=lambda c: V[c])

    def _neg_compound(self, w, depth):
        """Negasi menempel: gaguna/gabagus/gasemua/gakpeduli/gkada -> 'tidak X' (sisa kata harus umum)."""
        if 'negasi' not in self.categories or not w.isalpha():
            return None
        for pre, minlen in (('gak', 3), ('gk', 3), ('nggak', 3), ('ngga', 3), ('ga', 4)):
            if w.startswith(pre) and len(w) - len(pre) >= minlen:
                rest = w[len(pre):]
                if rest in self.kasar or rest in NEG_BLOCK or self._laugh(rest):
                    return None
                r = self.map.get(rest, rest)
                need = 200 if pre == 'ga' else 50
                if (rest in self.map and ' ' not in rest and len(rest) >= 4) or self.vocab.get(rest, 0) >= need or rest in self.valid:
                    return f'tidak {r}'
        return None

    def _ke_ter(self, w, depth):
        """Pasif tak sengaja informal: kepotong->terpotong, kesedot->tersedot, kebayang->terbayang."""
        if not w.startswith('ke') or len(w) < 6 or not w.isalpha():
            return None
        root = w[2:]
        if root in KE_TER_BLOCK or root.rstrip('n') in KE_TER_BLOCK:
            return None          # ter+sifat = superlatif (tercepat, terkaya), bukan pasif
        for cand in ('ter' + w[2:], 'ter' + w[2:].replace('in', 'kan') if w.endswith('in') else None):
            if cand and self.vocab.get(cand, 0) >= 5:
                return cand
        return None

    def _vokal_e(self, w, depth):
        """Ejaan Betawi/Jawa e->a di suku akhir: pesen->pesan, bales->balas, dipesen->dipesan, temen->teman."""
        if not w.isalpha() or len(w) < 4:
            return None
        cand = re.sub(r'e(?=[^aeiou]+$)', 'a', w, count=1)
        if cand != w and self.vocab.get(cand, 0) >= 20:
            return self.map.get(cand, cand)
        m = re.fullmatch(r'(.+?)(nya|ku|mu|lah)', w)                      # pesennya -> pesannya
        if m:
            b = re.sub(r'e(?=[^aeiou]+$)', 'a', m[1], count=1)
            if b != m[1] and self.vocab.get(b, 0) >= 20:
                return b + m[2]
        return None

    @staticmethod
    def _skeleton(w):
        return re.sub(r'[aeiou]', '', w)

    def _devowel(self, w, depth):
        """Typo vokal hilang: kluarga->keluarga, brsih->bersih, bnyk->banyak (harus dominan)."""
        if not w.isalpha() or len(w) < 4 or w in self.ambiguous or w in self.vocab_en:
            return None
        nv = sum(c in 'aeiou' for c in w)
        if nv / len(w) > 0.34 or (nv > 0 and len(w) < 6):
            return None          # token pendek bervokal (pusk, skat, kary) terlalu ambigu
        sk = self._skeleton(w)
        if len(sk) < 3:
            return None
        maxins = 4 if len(w) >= 5 else 2                     # token pendek: maksimal sisip 2 huruf (assl != asusila)
        cands = [c for c in self.skel.get(sk, []) if c[0] == w[0] and self._subseq(w, c) and 0 < len(c) - len(w) <= maxins]
        if not cands:
            return None
        top = cands[0]
        if len(cands) > 1 and self.vocab[top] < 3 * self.vocab[cands[1]]:
            return None
        return self.map.get(top, top)

    def _segment(self, w, depth):
        """Kata gabung / hashtag: liburpanjang -> libur panjang (Viterbi unigram)."""
        if not self.segment_long or depth > 0 or len(w) < 9 or not re.fullmatch(r'[a-z0-9]+', w) or w in self.vocab_en:
            return None
        if re.search(r'([a-z])\1\1', w) or w[:-1] in self.vocab or w[:-1] in self.kbbi:
            return None          # lengketttt, sekaleeee (elongasi); terhadapa, sempurnah (huruf lebih di akhir)
        mi = re.fullmatch(r'(.+?)i?in(?:nya|lah)?', w)
        if mi and (mi[1] in self.kbbi or mi[1] in self.vocab or mi[1] in self.map):
            return None          # rundingin, masanginnya: verba -in (runding+in), bukan gabungan (run dingin)
        m = re.fullmatch(r'(.{5,}?)(nya+h?|ku+|mu+)', w)
        if m:                    # pigmentnya, facewashnya: potong akhiran dulu, lalu pasang lagi di potongan terakhir
            if m[1] in self.map or m[1] in self.known:
                return None
            seg = self._segment_core(m[1])
            if not seg:
                return None
            return seg + {'k': 'ku', 'm': 'mu'}.get(m[2][0], 'nya')
        return self._segment_core(w)

    def _segment_core(self, w):
        if len(w) < 6:
            return None
        m = re.fullmatch(r'(.+?)(isasi|itas|iasi|asi|an|nya|kan|lah|ku|mu)', w)
        if m and (m[1] in self.known or m[1] in self.map):
            return None          # kata turunan (formalitas, depresiasi), bukan gabungan
        if self._derived(w):
            return None          # didamaikan, dianalogikan, menggadaikan: imbuhan + kata dasar, bukan gabungan
        n, INF = len(w), float('inf')
        best = [(0.0, -1)] + [(INF, -1)] * n
        for i in range(1, n + 1):
            for j in range(max(0, i - self._maxlen), i):
                if j == 0 and i == n:
                    continue                                  # minimal 2 potongan (lalulintas ada di KBBI utuh)
                piece = w[j:i]
                c = self._cost.get(piece)
                if c is None and piece.isdigit():
                    c = 8.0
                if c is not None and best[j][0] + c < best[i][0]:
                    best[i] = (best[j][0] + c, j)
        if best[n][0] == INF:
            return None
        parts, i = [], n
        while i > 0:
            j = best[i][1]
            parts.append(w[j:i])
            i = j
        parts.reverse()
        if len(parts) < 2 or len(parts) > 6:
            return None
        if w in self.kbbi and not all(len(p) >= 4 and p not in self.map for p in parts):
            return None          # kata KBBI: hanya majemuk utuh (lalulintas, sumberdaya), bukan gelembung->gelem bung
        if any(p in SEG_JUNK for p in parts) or 'com' in parts[:-1] or parts[-1] == 'akan':
            return None          # commenter -> com menteri, slideshow -> slides how, potongany -> potong any
        return ' '.join(self.map.get(p, p) for p in parts)

    def _derived(self, w):
        """w = awalan + kata dasar (+ akhiran) dengan kata dasar dikenal (>= 4 huruf)."""
        V, K = self.vocab, self.kbbi
        ok = lambda r: len(r) >= 4 and (V.get(r, 0) >= 5 or r in K)
        for p in ('',) + DERIV_PRE:
            if not w.startswith(p):
                continue
            rest = w[len(p):]
            roots = [rest]
            if p in ('meny', 'peny'):
                roots.append('s' + rest)
            if p in ('men', 'pen'):
                roots.append('t' + rest)
            if p in ('mem', 'pem'):
                roots.append('p' + rest)
            if p in ('meng', 'peng'):
                roots.append('k' + rest)
            for r in roots:
                for s in ('',) + DERIV_SUF:
                    if (p or s) and r.endswith(s) and ok(r[:len(r) - len(s)] if s else r):
                        return True
        return False

    def _seg_ok(self, p):
        if len(p) < 3 or p in AFFIX_PIECES:
            return False
        if p in self.protected:
            return True
        if p in self.map:
            return len(p) >= 5                            # potongan slang pendek (ngeh, masi, kasi, ngga) terlalu ambigu
        if len(p) >= 5 and p in self.kbbi and not KBBI_PREFIX.match(p):
            return True                                   # suntik, timbangan
        if len(p) >= 5 and p in self._canon:
            return True                                   # masyaallah, insyaallah (kanonik kamus)
        f = self.vocab.get(p, 0) + self.vocab_en.get(p, 0)
        return f >= (3000 if len(p) == 3 else 1000 if len(p) == 4 else 50)

    @staticmethod
    def _subseq(a, b):
        it = iter(b)
        return all(ch in it for ch in a)

    def _join_spaced(self, t):
        """'a n j i n g' / 'k.o.r.u.p.s.i' -> 'anjing' bila hasilnya kata dikenal."""
        def rep(m):
            joined = re.sub(r'[\s.\-_]', '', m[0])
            j = joined.lower()
            return joined if (j in self.known or j in self.map or j in self.kasar) else m[0]
        return re.sub(r'(?<!\w)(?:[a-zA-Z][\s.\-_]){2,}[a-zA-Z](?!\w)', rep, t)


_default = None


def normalize(text, **kw):
    """Shortcut: normalize(text). Kwargs membuat Normalizer baru (lebih lambat)."""
    global _default
    if kw:
        return Normalizer(**kw)(text)
    if _default is None:
        _default = Normalizer()
    return _default(text)


def normalize_series(series, **kw):
    nz = Normalizer(**kw)
    return series.map(nz)