#!/usr/bin/env python3
"""Triaj: cine primeste raspuns, cine primeste intrebari, cine cheama programatorii.

Trei decizii pe care cautarea in documente nu le poate lua singura:

1. **Mesaj prea vag.** „Am o eroare" nu e o intrebare — e inceputul uneia. Fara
   operatiunea, ecranul si textul erorii, si un om ar ghici. Maria intreaba, nu
   ghiceste (si nu deranjeaza suportul cu „am o eroare").

2. **Erori care oricum ajung la programatori.** Dictionarul spune, pentru fiecare
   eroare, `cand suni suportul`. Noua dintre ele incep cu „Intotdeauna" sau
   „Imediat": nu se rezolva din aplicatie, orice explicatie i-ar da utilizatorului
   nu-l ajuta sa iasa din ea. Pentru astea raspunsul se compune din chiar campurile
   dictionarului, iar mesajul pleaca automat la suport.

   De ce fara model: pe captura cu ORA-06550, avand in context exact intrarea care
   spune „nu se rezolva din aplicatie", modelul a raspuns „verifica schema de date
   din aplicatia ROA (...) sau foloseste procedura alternativa MI_pack_parteneri_old".
   A inventat o procedura, a cerut unui contabil sa umble in schema si a contrazis
   documentul. Textul din dictionar e deja scris pentru clienti; parafrazarea lui
   nu adauga nimic si poate strica tot.

3. **Cat e de urgent.** Aceeasi eroare poate bloca omul complet sau poate fi ocolita
   pana maine. Nu se deduce din text, deci se intreaba — iar raspunsul lui se
   ataseaza escaladarii deja deschise, nu porneste alta.
"""

from __future__ import annotations

import re

import rank

# Prima vorba din `cand suni suportul`. Restul („Daca revine dupa restart") sunt
# conditionate: acolo utilizatorul are ce incerca, deci raspunde modelul.
_INTOTDEAUNA = ("intotdeauna", "imediat")

_CAMP = re.compile(r"^([a-z ]+):\s*(.*)$")

# Cuvintele cu care oamenii anunta o problema fara sa spuna care.
_ACUZA = re.compile(
    r"\b(eroare|erori|eroarea|problema|probleme|nu merge|nu functioneaza|"
    r"nu mai merge|s-a blocat|crapa|imi da|nu pot)\b"
)


def camp(chunk: str, nume: str) -> str:
    """Valoarea unui camp din chunk-ul XML randat (`mesaj eroare: ...`)."""
    tinta = nume.replace("_", " ")
    for line in chunk.splitlines():
        m = _CAMP.match(line.strip())
        if m and m.group(1).strip() == tinta:
            return m.group(2).strip()
    return ""


def nivel_suport(chunk: str) -> str | None:
    """`"intotdeauna"` / `"imediat"` daca eroarea cere suport oricum, altfel `None`."""
    valoare = camp(chunk, "cand suni suportul").lower()
    for cuvant in _INTOTDEAUNA:
        if valoare.startswith(cuvant):
            return cuvant
    return None


def prea_vag(text: str, are_imagine: bool) -> bool:
    """Mesajul anunta o problema fara sa spuna care.

    Deliberat ingust: doar text scurt, fara captura si fara cod de eroare. O
    intrebare adevarata („cum trimit D406") nu contine cuvintele de acuza, iar una
    cu un cod are deja tot ce trebuie ca sa fie cautata.
    """
    if are_imagine:
        return False
    t = rank.fold(text.strip())
    if not t or rank.codes(t):
        return False
    if not _ACUZA.search(t):
        return False
    return len(rank.tokenize(t)) <= 12


CERE_DETALII = (
    "Ca sa-mi dau seama despre ce e vorba, spune-mi te rog:\n"
    "1. ce faceai exact cand a aparut (ce operatiune),\n"
    "2. in ce ecran sau meniu erai,\n"
    "3. ce scrie exact in mesaj — cel mai simplu, trimite o captura de ecran cu "
    "fereastra de eroare."
)

# Ce se trimite la o eroare care oricum ajunge la programatori. Explicatia si
# indicatia sunt luate ca atare din dictionar, nu reformulate.
_URGENT = ("Este o eroare care afecteaza toti utilizatorii, nu doar pe tine, asa ca "
           "am anuntat echipa tehnica imediat si i-am trimis {ce}")
_NORMAL = "Am trimis {ce} mai departe, catre echipa tehnica"

INTREBARE_URGENTA = (
    "Spune-mi te rog daca te blocheaza complet sau poti continua pe alta "
    "operatiune — asa stiu cat e de urgent."
)


def raspuns_escaladat(chunk: str, nivel: str, ref: str, notificat: bool,
                      cu_imagine: bool = False) -> str:
    """Raspunsul pentru o eroare care oricum ajunge la programatori.

    Compus din campurile dictionarului, fara model: textul de acolo e deja scris
    pentru clienti, iar aici nu e nimic de dedus — doar de spus limpede.
    """
    parti: list[str] = []
    explicatie = camp(chunk, "ce inseamna")
    if explicatie:
        parti.append(explicatie)
    rezolvare = camp(chunk, "rezolvare")
    if rezolvare:
        parti.append(rezolvare)

    ce = "mesajul si captura" if cu_imagine else "mesajul"
    trimis = (_URGENT if nivel == "imediat" else _NORMAL).format(ce=ce)
    if notificat:
        parti.append(f"{trimis} (referinta {ref}). Te contacteaza cineva.")
    else:
        # Nu promitem ce nu s-a intamplat: notificarea a esuat, dar e inregistrata.
        parti.append(
            f"Am inregistrat problema pentru echipa tehnica (referinta {ref}), dar "
            f"nu am putut sa o trimit chiar acum. Daca te blocheaza, suna-ne."
        )
    parti.append(INTREBARE_URGENTA)
    return "\n\n".join(parti)