"""
Heuristics for spoken language preference (English / Hindi / Kannada) on MCube calls.

Used by ws_bridge and ai_worker: explicit phrases, then Indic script, else STT default.
"""

from __future__ import annotations

import re
from typing import Optional

# Devanagari (Hindi, etc.) vs Kannada script blocks (must not treat Latin "hi" as Hindi).
_DEVANAGARI_RE = re.compile(r"[\u0900-\u097F]")
_KANNADA_RE = re.compile(r"[\u0C80-\u0CFF]")

# Explicit spoken preference (avoid matching greeting "hi" as Hindi).
_PREF_EN = re.compile(
    r"\b("
    r"english|inglish|"
    r"in\s+english|speak\s+english|talk\s+in\s+english|english\s+please|please\s+english"
    r")\b",
    re.IGNORECASE,
)
_PREF_HI = re.compile(
    r"\b("
    r"hindi|hinglish|hindustani|"
    r"in\s+hindi|speak\s+hindi|talk\s+in\s+hindi|hindi\s+please|please\s+hindi"
    r")\b",
    re.IGNORECASE,
)
_PREF_KN = re.compile(
    r"\b("
    r"kannada|canara|"
    r"in\s+kannada|speak\s+kannada|talk\s+in\s+kannada|kannada\s+please|please\s+kannada"
    r")\b|ಕನ್ನಡ",
    re.IGNORECASE,
)


def _only_greeting_latin(text: str) -> bool:
    low = text.strip().lower()
    if not low:
        return True
    tokens = set(re.findall(r"[a-zA-Z']+", low))
    return bool(tokens) and tokens <= {"hello", "hi", "hey"}


def _stt_base(stt_default: str) -> str:
    s = (stt_default or "en").strip().lower()
    if not s:
        return "en"
    primary = s.split("-", 1)[0].split("_", 1)[0]
    if primary in ("en", "hi", "kn"):
        return primary
    if primary == "hin":
        return "hi"
    if primary in ("kan", "kn"):
        return "kn"
    if primary in ("eng",):
        return "en"
    return "en"


def detect_language_preference(text: str) -> Optional[str]:
    """
    If the caller clearly asks for English, Hindi, or Kannada, return that code.
    Returns None when there is no explicit preference (including lone 'hi' / 'hello' greetings).
    """
    if not text or not text.strip():
        return None
    raw = text.strip()
    if _only_greeting_latin(raw) and not _KANNADA_RE.search(raw) and not _DEVANAGARI_RE.search(raw):
        return None
    if _PREF_KN.search(raw):
        return "kn"
    if _PREF_HI.search(raw):
        return "hi"
    if _PREF_EN.search(raw):
        return "en"
    # One-word / noisy STT answers (no word-boundary "hindi" substring, e.g. glued tokens).
    letters_only = re.sub(r"[^a-z]", "", raw.lower())
    if letters_only:
        if letters_only in {
            "hindi",
            "hindhi",
            "hindee",
            "hinthi",
            "hinglish",
            "hindustani",
            "hindy",
            "hendi",
        }:
            return "hi"
        if letters_only in {"english", "inglish"}:
            return "en"
        if letters_only in {"kannada", "kanada"}:
            return "kn"
    return None


def resolve_detected_language(stt_default: str, user_text: str) -> str:
    """
    Merge STT default with explicit preference, then Indic script, else canonical STT base.
    """
    base = _stt_base(stt_default)
    t = user_text or ""
    pref = detect_language_preference(t)
    if pref:
        return pref
    if _KANNADA_RE.search(t):
        return "kn"
    if _DEVANAGARI_RE.search(t):
        return "hi"
    return base

# """Language helpers for MCube ws_bridge (preference + resolution)."""

# from __future__ import annotations


# def detect_language_preference(text: str) -> str | None:
#     """
#     Return ``\"hi\"`` or ``\"en\"`` when the caller *explicitly* asks for a language.
#     Otherwise ``None`` (no clear preference).
#     """
#     t = (text or "").strip().lower()
#     if not t:
#         return None
#     if any(k in t for k in ("hindi", "hinglish", "हिंदी")):
#         return "hi"
#     if any(
#         phrase in t
#         for phrase in (
#             "english only",
#             "in english",
#             "speak english",
#             "talk in english",
#             "english please",
#         )
#     ):
#         return "en"
#     if t in ("english", "en") or t.split() == ["english"]:
#         return "en"
#     return None


# def _classify_text_language(text: str) -> str:
#     """``hi`` vs ``en`` from script / Hinglish cues (aligned with ai_worker heuristics)."""
#     if not text:
#         return "en"

#     hindi_chars = sum(1 for char in text if "\u0900" <= char <= "\u097F")
#     if hindi_chars > 0:
#         return "hi"

#     hinglish_words = (
#         "namaste",
#         "kaise",
#         "aap",
#         "main",
#         "kya",
#         "nahi",
#         "ji",
#         "bhai",
#         "yaar",
#         "acha",
#         "theek",
#         "sahi",
#         "galat",
#         "batao",
#         "samajh",
#         "kripya",
#         "dhanyawad",
#         "shukriya",
#         "haan",
#         "bolo",
#         "hindi",
#         "hinglish",
#     )
#     text_lower = text.lower()
#     if sum(1 for word in hinglish_words if word in text_lower.split()) >= 1:
#         return "hi"

#     return "en"


# def resolve_detected_language(stt_language_code: str, text: str) -> str:
#     """
#     Pick STT / downstream language: prefer content-derived ``hi`` / ``en``,
#     else ``stt_language_code`` (normalized to ``en`` if empty).
#     """
#     base = (stt_language_code or "en").strip() or "en"
#     if not (text or "").strip():
#         return base
#     return _classify_text_language(text)