"""
Ovozli kunlik hisobot: admin(lar)ga har kuni (masalan 10:00 va 18:00)
haqiqiy telefon qo'ng'irog'i orqali davomat hisobotini o'qib beradi.

Qo'ng'iroqni Vapi (https://vapi.ai) ovozli AI platformasi amalga oshiradi:
  - Telefon raqam: Twilio (Vapi'ga import qilingan)
  - Nutqni tanish (STT): Azure, til = uz-UZ
  - Ovoz (TTS): Azure uz-UZ-MadinaNeural yoki uz-UZ-SardorNeural
  - "Miya": LLM (masalan gpt-4o) - hisobotni o'qiydi va savollarga javob beradi

Bot faqat bitta HTTPS so'rov yuboradi (POST https://api.vapi.ai/call) va
hisobot matnini `variableValues` orqali uzatadi. Sozlash: VOICE_REPORT.md
"""

import asyncio
import logging
import os
from dataclasses import dataclass, field

import aiohttp

logger = logging.getLogger("attendance_bot.voice")

VAPI_BASE_URL = "https://api.vapi.ai"

NO_ANSWER_REASONS = {
    "customer-did-not-answer",
    "customer-busy",
    "voicemail",
    "twilio-failed-to-connect-call",
    "customer-did-not-give-microphone-permission",
}


# ================= SOZLAMALAR =================
@dataclass
class VoiceConfig:
    api_key: str = ""
    assistant_id: str = ""
    phone_number_id: str = ""
    to_numbers: list = field(default_factory=list)
    times: list = field(default_factory=lambda: ["10:00", "18:00"])
    days: str = "mon-sat"
    max_attempts: int = 2
    retry_after_minutes: int = 5

    @property
    def enabled(self) -> bool:
        return bool(self.api_key and self.assistant_id and self.phone_number_id and self.to_numbers)

    @classmethod
    def from_env(cls) -> "VoiceConfig":
        def _list(name, default=""):
            return [x.strip() for x in os.getenv(name, default).split(",") if x.strip()]

        return cls(
            api_key=os.getenv("VAPI_API_KEY", "").strip(),
            assistant_id=os.getenv("VAPI_ASSISTANT_ID", "").strip(),
            phone_number_id=os.getenv("VAPI_PHONE_NUMBER_ID", "").strip(),
            to_numbers=_list("VOICE_REPORT_PHONE"),
            times=_list("VOICE_REPORT_TIMES", "10:00,18:00") or ["10:00", "18:00"],
            days=os.getenv("VOICE_REPORT_DAYS", "mon-sat").strip() or "mon-sat",
            max_attempts=int(os.getenv("VOICE_REPORT_MAX_ATTEMPTS", "2")),
            retry_after_minutes=int(os.getenv("VOICE_REPORT_RETRY_MINUTES", "5")),
        )


def kind_for(hhmm: str) -> str:
    return "ertalab" if hhmm < "13:00" else "kechqurun"


# ================= O'ZBEKCHA SONLAR (TTS uchun) =================
_ONES = ["", "bir", "ikki", "uch", "to'rt", "besh", "olti", "yetti", "sakkiz", "to'qqiz"]
_TENS = ["", "o'n", "yigirma", "o'ttiz", "qirq", "ellik", "oltmish", "yetmish", "sakson", "to'qson"]


def son_sozda(n: int) -> str:
    n = int(n)
    if n == 0:
        return "nol"
    if n < 0:
        return "minus " + son_sozda(-n)
    parts = []
    thousands, n = divmod(n, 1000)
    if thousands:
        parts.append(("ming" if thousands == 1 else son_sozda(thousands) + " ming"))
    hundreds, n = divmod(n, 100)
    if hundreds:
        parts.append(("yuz" if hundreds == 1 else _ONES[hundreds] + " yuz"))
    tens, ones = divmod(n, 10)
    if tens:
        parts.append(_TENS[tens])
    if ones:
        parts.append(_ONES[ones])
    return " ".join(parts)


def vaqt_sozda(hhmm) -> str:
    if not hhmm:
        return ""
    try:
        h, m = (int(x) for x in str(hhmm).split(":")[:2])
    except ValueError:
        return str(hhmm)
    if m == 0:
        return son_sozda(h)
    if m < 10:
        return f"{son_sozda(h)} nol {son_sozda(m)}"
    return f"{son_sozda(h)} {son_sozda(m)}"


def soat_sozda(hours: float) -> str:
    total_min = int(round((hours or 0) * 60))
    h, m = divmod(total_min, 60)
    if m == 0:
        return f"{son_sozda(h)} soat"
    if m == 30:
        return f"{son_sozda(h)} yarim soat" if h else "yarim soat"
    if h == 0:
        return f"{son_sozda(m)} daqiqa"
    return f"{son_sozda(h)} soat {son_sozda(m)} daqiqa"


def _ismlar(names) -> str:
    names = list(names)
    if not names:
        return ""
    if len(names) == 1:
        return names[0]
    return ", ".join(names[:-1]) + " va " + names[-1]


_ABS_SOZ = {"tatil": "ta'tilda", "kasal": "kasal", "otgul": "ruxsat olgan"}


# ================= MA'LUMOT YIG'ISH =================
def collect_day_data(date_str: str) -> dict:
    """repo.employee_status natijasini qo'ng'iroq uchun qulay ko'rinishga keltiradi."""
    import repo
    st = repo.employee_status(date_str)

    def rec(x):
        return {"name": x["name"], "check_in": (x.get("check_in") or "")[:5],
                "check_out": (x.get("check_out") or "")[:5], "lateness": x.get("lateness", 0),
                "reason": (x.get("reason") or "").strip(), "work_hours": x.get("work_hours", 0),
                "on_break": x.get("on_break", False)}

    return {"date": date_str, "ishda": [rec(x) for x in st["ishda"]], "ketgan": [rec(x) for x in st["ketgan"]],
            "kelmagan": [{"name": x["name"]} for x in st["kelmagan"]],
            "sababli": [{"name": x["name"], "absence": x["absence"]} for x in st["sababli"]]}


# ================= HISOBOT MATNI =================
def build_report(data: dict, kind: str) -> dict:
    ishda, ketgan, kelmagan = data["ishda"], data["ketgan"], data["kelmagan"]
    sababli = data.get("sababli", [])
    kelganlar = ishda + ketgan
    jami = len(kelganlar) + len(kelmagan) + len(sababli)
    kechikkanlar = sorted([x for x in kelganlar if x["lateness"] > 0], key=lambda x: -x["lateness"])

    s = []
    if jami == 0:
        s.append("Bugun ish kuni belgilangan xodim yo'q.")
    else:
        s.append(f"Bugun {son_sozda(jami)} nafar xodimdan {son_sozda(len(kelganlar))} nafari ishga keldi.")

    if kechikkanlar:
        bolaklar = []
        for x in kechikkanlar:
            b = f"{x['name']} {son_sozda(x['lateness'])} daqiqa"
            if x["reason"]:
                b += f", sababi: {x['reason']}"
            bolaklar.append(b)
        s.append(f"Kech qolganlar {son_sozda(len(kechikkanlar))} nafar: " + "; ".join(bolaklar) + ".")
    elif kelganlar:
        s.append("Hech kim kech qolmadi.")

    if kelmagan:
        s.append(f"Kelmaganlar {son_sozda(len(kelmagan))} nafar: {_ismlar(x['name'] for x in kelmagan)}.")
    elif jami:
        s.append("Sababsiz kelmagan xodim yo'q.")
    if sababli:
        s.append("Sababli: " + ", ".join(f"{x['name']} {_ABS_SOZ.get(x['absence'], '')}" for x in sababli) + ".")

    if kind == "kechqurun" and kelganlar:
        if ketgan:
            s.append(f"Ishdan ketganlar {son_sozda(len(ketgan))} nafar.")
        if ishda:
            s.append(f"Hali ishda: {_ismlar(x['name'] for x in ishda)}.")
        jami_soat = sum(x["work_hours"] for x in ketgan)
        if jami_soat:
            s.append(f"Ketganlarning jami ish vaqti {soat_sozda(jami_soat)}.")
    elif kind == "ertalab" and ishda:
        tanaffusda = [x["name"] for x in ishda if x["on_break"]]
        if tanaffusda:
            s.append(f"Hozir tanaffusda: {_ismlar(tanaffusda)}.")

    t = []
    for x in kelganlar:
        line = f"{x['name']}: soat {vaqt_sozda(x['check_in'])} da keldi"
        if x["lateness"]:
            line += f", {son_sozda(x['lateness'])} daqiqa kech"
            if x["reason"]:
                line += f" (sababi: {x['reason']})"
        if x["check_out"]:
            line += f", soat {vaqt_sozda(x['check_out'])} da ketdi, {soat_sozda(x['work_hours'])} ishladi"
        else:
            line += ", hozir ham ishda" + (" (tanaffusda)" if x["on_break"] else "")
        t.append(line + ".")
    for x in kelmagan:
        t.append(f"{x['name']}: bugun kelmadi.")
    for x in sababli:
        t.append(f"{x['name']}: bugun {_ABS_SOZ.get(x['absence'], 'sababli')}.")

    m = [f"Kelganlar: {len(kelganlar)}/{jami}"]
    for x in kechikkanlar:
        m.append(f"⚠️ {x['name']} — {x['lateness']} daq." + (f" ({x['reason']})" if x["reason"] else ""))
    for x in kelmagan:
        m.append(f"⏳ {x['name']} — kelmadi")
    for x in sababli:
        m.append(f"📝 {x['name']} — {_ABS_SOZ.get(x['absence'], 'sababli')}")

    return {"hisobot": " ".join(s), "tafsilot": "\n".join(t) or "Ma'lumot yo'q.", "matn": "\n".join(m)}


# ================= VAPI QO'NG'IROQ =================
async def vapi_create_call(cfg: VoiceConfig, to_number: str, variables: dict) -> dict:
    payload = {
        "assistantId": cfg.assistant_id,
        "phoneNumberId": cfg.phone_number_id,
        "customer": {"number": to_number},
        "assistantOverrides": {"variableValues": variables},
    }
    headers = {"Authorization": f"Bearer {cfg.api_key}", "Content-Type": "application/json"}
    async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=30)) as s:
        async with s.post(f"{VAPI_BASE_URL}/call", json=payload, headers=headers) as resp:
            body = await resp.json(content_type=None)
            if resp.status >= 300:
                raise RuntimeError(f"Vapi xatosi {resp.status}: {body}")
            return body


async def vapi_get_call(cfg: VoiceConfig, call_id: str) -> dict:
    headers = {"Authorization": f"Bearer {cfg.api_key}"}
    async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=30)) as s:
        async with s.get(f"{VAPI_BASE_URL}/call/{call_id}", headers=headers) as resp:
            return await resp.json(content_type=None)


async def call_with_retry(cfg: VoiceConfig, to_number: str, variables: dict, on_fail=None):
    reason = "noma'lum"
    for attempt in range(1, cfg.max_attempts + 1):
        try:
            call = await vapi_create_call(cfg, to_number, variables)
            call_id = call.get("id")
            logger.info(f"Ovozli hisobot: qo'ng'iroq #{attempt} boshlandi ({to_number}), id={call_id}")
        except Exception as e:
            reason = str(e)
            logger.error(f"Ovozli hisobot: qo'ng'iroq yaratilmadi: {e}")
            call_id = None

        if call_id:
            reason = "holat-noma'lum"
            for _ in range(40):
                await asyncio.sleep(15)
                try:
                    info = await vapi_get_call(cfg, call_id)
                except Exception as e:
                    logger.warning(f"Qo'ng'iroq holatini olishda xatolik: {e}")
                    continue
                if info.get("status") == "ended":
                    reason = info.get("endedReason") or "ended"
                    break
            if reason not in NO_ANSWER_REASONS and not reason.startswith(("twilio-", "call.start.error")):
                logger.info(f"Ovozli hisobot yetkazildi ({to_number}): {reason}")
                return True

        if attempt < cfg.max_attempts:
            await asyncio.sleep(cfg.retry_after_minutes * 60)

    logger.warning(f"Ovozli hisobot yetkazilmadi ({to_number}): {reason}")
    if on_fail:
        await on_fail(reason)
    return False
