import re
from typing import Tuple, List

DIGRAPHS = { 'CH', 'KH', 'GH', 'PH', 'BH', 'JH', 'TH', 'DH', 'SH', 'NG', 'X' }
VOWELS = set('aeiou')
PRIMARY_MAP = {
    'CH': 'C', 'KH': 'K', 'GH': 'G', 'PH': 'P', 'BH': 'B', 'JH': 'J', 'TH': 'T', 'DH': 'D', 'SH': 'S', 'NG': 'N', 'X': 'K',
    'k': 'K', 'q': 'K', 'c': 'K', 'g': 'G', 'j': 'J', 't': 'T', 'd': 'D', 'p': 'P', 'b': 'B',
    'm': 'M', 'n': 'N', 'y': 'Y', 'r': 'R', 'l': 'L', 's': 'S', 'h': 'H', 'v': 'B', 'w': 'W', 'f': 'F', 'z': 'S', 'x': 'K'
}
ALTERNATE_MAP = PRIMARY_MAP.copy()
ALTERNATE_MAP['X'] = 'X'

def _normalize_unicode(s: str) -> str:
    if not s:
        return ''
    s = s.strip().lower()
    s = s.replace('ā', 'a').replace('ī', 'i').replace('ū', 'u')
    s = s.replace('ṁ', 'm').replace('ṃ', 'm').replace('ñ', 'n').replace('ṙ', 'r')
    return s


def _preprocess(word: str) -> str:
    if not word:
        return ''
    
    if len(word) == 2:
        return word.upper()
    w = _normalize_unicode(word)
    w = re.sub(r'[^a-z]', '', w)
    w = re.sub(r'xo', 'cho', w)
    w = re.sub(r'xh', 'ch', w)
    w = re.sub(r'a{2,}', 'a', w)
    w = re.sub(r'e{2,}', 'e', w) 
    w = re.sub(r'i{2,}', 'i', w)
    w = re.sub(r'o{2,}', 'o', w)
    w = re.sub(r'u{2,}', 'u', w)
    w = re.sub(r'ae', 'ai', w)
    w = w.replace('chh', 'CH')
    w = w.replace('ch', 'CH')
    w = w.replace('kh', 'KH')
    w = w.replace('gh', 'GH')
    w = w.replace('ph', 'PH')
    w = w.replace('bh', 'BH')
    w = w.replace('jh', 'JH')
    w = w.replace('th', 'TH')
    w = w.replace('dh', 'DH')
    w = w.replace('sh', 'SH')
    w = w.replace('ng', 'NG')
    w = w.replace('f', 'PH')
    w = w.replace('x', 'X')
    w = re.sub(r'(.)\1{2,}', r'\1\1', w)

    return w


def _tokenize(pre: str) -> List[str]:
    tokens = []
    i = 0
    L = len(pre)
    while i < L:
        if i + 1 < L:
            two = pre[i:i+2]
            if two in DIGRAPHS:
                tokens.append(two)
                i += 2
                continue
        tokens.append(pre[i])
        i += 1
    return tokens

def _encode_tokens(tokens: List[str], mapping: dict, max_len: int = 6) -> str:
    if not tokens:
        return ''
    code = []
    last_sym = None
    i = 0
    if tokens and isinstance(tokens[0], str) and tokens[0] and tokens[0][0] in VOWELS:
        first_vowel = tokens[0].upper()
        code.append(first_vowel)
        last_sym = first_vowel
        i = 1

    while i < len(tokens) and len(code) < max_len:
        tok = tokens[i]
        if len(tok) == 1 and tok in VOWELS:
          i += 1
          continue

        sym = mapping.get(tok, None)
        if sym is None and len(tok) == 1:
            sym = mapping.get(tok.lower(), tok.upper())

        if not sym:
            i += 1
            continue

        if sym != last_sym:
            code.append(sym)
            last_sym = sym
        i += 1

    if tokens and tokens[-1] in VOWELS:
        last_vowel = tokens[-1].upper()
        if last_vowel != last_sym and len(code) < max_len:
            code.append(last_vowel)


    return ''.join(code)


def nepali_dmetaphone(source: str) -> Tuple[str, str]:
    if not source:
        return ('', '')

    pre = _preprocess(source)
    tokens = _tokenize(pre)

    primary = _encode_tokens(tokens, PRIMARY_MAP)

    alternate = _encode_tokens(tokens, ALTERNATE_MAP)

    if primary == alternate:
        alternate = ''

    return (primary, alternate)