"""
arzuhal_cite.py — Serbest metindeki kanun atiflarini bulur ve mevzuatla denetler.

Desteklenen bicimler (ornekler):
  TBK m. 344 · TBK md.344/1 · TBK'nın 344. maddesi · Türk Borçlar Kanunu'nun 344 üncü maddesi
  6098 sayılı Türk Borçlar Kanunu'nun 315, 316 ve 344. maddeleri · 4857 sayılı Kanun'un 17/2 maddesi
  İş Kanunu'nun 17. maddesinin 2. fıkrası · TMK 166 · TBK m. 344-346 · aynı Kanun'un 18. maddesi
  TBK geçici madde 1 · İş Kanunu ek madde 2
Kanunu belirtilmeyen madde atiflari ('344. madde') ayri sayilir: dogrulanamaz.
"""
import re
from dataclasses import dataclass, asdict

from arzuhal_law import REPEALED_LAWS, fold

STATUSES = ["var", "mulga_madde", "uydurma_madde", "eski_kanun", "bilinmeyen_kanun"]
# 'bilinmeyen_kanun' uydurma DEGILDIR: korpus yalniz yururlukteki kanunlari icerir; islenmis degisiklik kanunlari
# (or. 7499 sayili) cogu zaman yoktur. Uydurma orani yalniz korpustaki kanunlara yapilan atiflarda hesaplanir.
VERIFIABLE = ["var", "mulga_madde", "uydurma_madde"]
STATUS_LABELS = {"var": "Var (yürürlükte)", "mulga_madde": "Mülga madde", "uydurma_madde": "Uydurma madde",
                 "eski_kanun": "Yürürlükten kalkmış kanun", "bilinmeyen_kanun": "Korpusta olmayan kanun"}
ORDINALS = {"birinci": 1, "ikinci": 2, "ucuncu": 3, "dorduncu": 4, "besinci": 5, "altinci": 6, "yedinci": 7,
            "sekizinci": 8, "dokuzuncu": 9, "onuncu": 10}
MAX_RANGE = 30
ARTICLE_WINDOW = 140  # kanun adindan sonra madde aranacak en fazla karakter


@dataclass
class Citation:
    law: int | None        # kanun no; yururlukten kalkmis kanun icin pozitif no + old_law=True
    article: str           # '344', '5/A', 'ek-2', 'gecici-1'
    paragraph: int | None
    start: int
    end: int
    surface: str
    old_law: bool = False
    group: str | None = None   # aralik ('m. 1045-1050') tek atif sayilir; ayni gruptaki maddeler birlikte degerlendirilir

    def key(self):
        return (self.law, self.article)


# ── Katlanmis (fold) metin uzerinde calisan desenler: fold uzunlugu korur, spanlar orijinale gecerli ──
_SUFFIX = r"(?:'?\s*(?:inci|nci|uncu|ncu|ci|cu)(?![a-z])|\.)"   # katlanmis metin: ıncı->inci, üncü->uncu
_ONE = r"(?!\d{1,4}\s+sayili)\d{1,4}(?:\s*/\s*[a-z](?![a-z]))?(?:\s*/\s*\d{1,2})?"
_ONE_S = _ONE + r"(?:" + _SUFFIX + r"(?=\s*(?:,|ve|ile|veya)\s*\d))?"   # '315 inci, 316 nci ve 344 uncu'
_LIST = _ONE_S + r"(?:\s*(?:,|ve|ile|veya|ila|-|–)\s*" + _ONE_S + r")*"
_KIND = r"(?:(?P<kind>ek|gecici)\s+)?"
_MADDE = r"madde(?:si|sinin|sine|sinde|leri|lerinin|lerine|lerinde|ler)?(?![a-z])"
_PARA = (r"(?:\s*(?:\(\s*)?(?P<para>\d{1,2})\s*" + _SUFFIX + r"?\s*\)?\s*fikra|\s+(?P<para_w>" + "|".join(ORDINALS)
         + r")\s+fikra|\s*,?\s*(?:f\.|fik\.)\s*(?P<para_f>\d{1,2}))?")
ART_PREFIX = re.compile(r"^[\s,]*" + _KIND + r"(?:m\.|md\.|mad\.|" + _MADDE + r")\s*(?P<nums>" + _LIST + r")" + _PARA)
ART_SUFFIX = re.compile(r"^[\s,]*" + _KIND + r"(?P<nums>" + _LIST + r")\s*" + _SUFFIX + r"?\s*" + _MADDE + _PARA)
ART_BARE = re.compile(r"^\s+(?!(?:19|20)\d\d(?!\d))(?P<nums>\d{1,4}(?:\s*/\s*\d{1,2})?)"
                      r"(?![\d.,]*\s*(?:yil|sayili|tarih|tl|lira|gun|ay(?![a-z])|saat|kisi|%|ocak|subat|mart|nisan|mayis|haziran|temmuz|agustos|eylul|ekim|kasim|aralik))(?=[\s,;.)']|$)")
# Kanun adindan sonra: tirnak/markdown, iyelik eki ve/veya parantezli kisaltma/numara — '"Kat Mülkiyeti Kanunu"nun 34.', — "Türk Medeni Kanunu'nun (TMK) 166.", "Borçlar Kanunu (6098) m. 344"
POSSESSIVE = re.compile(r"^[\"“”*_]*(?:'?(?:n[iu]n|[iu]n|nin|nun|in|un|de|da|te|ta|ye|ya|e|a)?(?![a-z]))[\"“”*_]*(?:\s*\([^()]{1,20}\)(?:'?[a-z]{0,4})?)?")
# Kanun adi apostrofsuz ekle bitisebilir: 'is kanununun', 'medeni kanunun', '... hakkinda kanunun'
_ALIAS_END = r"(?:(?![a-z0-9])|(?<=kanun)(?=(?:un|a|da|dan|daki)(?![a-z]))|(?<=kanunu)(?=(?:nun|na|nda|ndan|ndaki)(?![a-z])))"
SAYILI = re.compile(r"(?<![\d.])(?P<no>\d{1,4})\s+sayili(?P<rest>(?:\s+[a-z']+){0,10}?\s+kanun[a-z']{0,7}?(?=[^a-z']|$)|)")
SAME_LAW = re.compile(r"(?<![a-z])(?:ayni|bu|anilan|soz konusu|mezkur)\s+kanun[a-z']{0,7}?(?=[^a-z']|$)")
ORPHAN = re.compile(r"(?<![\d/])(?P<nums>\d{1,4}(?:\s*/\s*\d{1,2})?)\s*" + _SUFFIX + r"?\s*madde(?:si|de|ye)?(?![a-z])(?!\s*\d)")  # 'MADDE 10-' basligi degil


def trie_regex(words):
    """Binlerce kanun adini tek alternasyon yerine onek agaciyla derle (33 MB metinde hiz icin).
    Agacta uzun eslesme once denenir; sinir kontrolu basarisiz olursa regex kisa olana geri doner."""
    trie = {}
    for w in words:
        node = trie
        for ch in w:
            node = node.setdefault(ch, {})
        node[""] = True

    def build(node):
        end = "" in node
        alts = [re.escape(ch) + build(sub) for ch, sub in sorted(node.items()) if ch != ""]
        if not alts:
            return ""
        body = alts[0] if len(alts) == 1 else "(?:" + "|".join(alts) + ")"
        return f"(?:{body})?" if end else body
    return "(?:" + build(trie) + ")"


def _expand(nums_text):
    """'315, 316 ve 344' -> [['315',None,False],...]; '344-346' -> 344..346 (aralik_mi=True); '17/2' -> ['17',2,False]."""
    nums_text = re.sub(_SUFFIX, "", nums_text)
    parts = re.split(r"\s*(,|ve|ile|veya|ila|-|–)\s*", nums_text.strip())
    items, ops = parts[0::2], [None] + parts[1::2]
    out = []   # [madde, fikra, aralik_mi]
    for tok, op in zip(items, ops):
        m = re.fullmatch(r"(\d{1,4})(?:\s*/\s*([a-z]))?(?:\s*/\s*(\d{1,2}))?", tok)
        if not m:
            continue
        art = m.group(1).lstrip("0") or "0"
        art = art + (f"/{m.group(2).upper()}" if m.group(2) else "")
        para = int(m.group(3)) if m.group(3) else None
        if op in ("-", "–", "ila") and out and out[-1][0].isdigit() and art.isdigit():
            a, b = int(out[-1][0]), int(art)
            if 0 < b - a <= MAX_RANGE:
                out[-1][2] = True
                out.extend([str(x), None, True] for x in range(a + 1, b + 1))
                continue
        out.append([art, para, False])
    return out


class CitationExtractor:
    def __init__(self, registry, extra_aliases=None):
        """extra_aliases: {ad: kanun no} — elle dogrulanmis ek adlar (or. LLM'lerin 'Tapu Kanunu', 'Ticaret Kanunu' yazimlari).
        Kayitli adlari ezmez; negatif no yururlukten kalkmis kanun demektir."""
        self.registry = registry
        table = registry.alias_table()
        for a, n in (extra_aliases or {}).items():
            table.setdefault(fold(a), int(n))
        # 2 harfli kisaltmalar (BK, İK) yalniz orijinal metinde BUYUK harfle eslesir; digerleri katlanmis metinde
        self.short = {a: n for a, n in self._raw_aliases(registry) if len(a) <= 2}
        self.long = {k: v for k, v in table.items() if len(k) > 2}
        self.alias_re = re.compile(r"(?<![a-z0-9])" + trie_regex(self.long) + _ALIAS_END) if self.long else None
        self.short_re = (re.compile(r"(?<![\wÇĞİÖŞÜçğıöşü])(?:" + "|".join(map(re.escape, self.short)) + r")(?![A-Za-zÇĞİÖŞÜçğıöşü0-9])")
                         if self.short else None)

    @staticmethod
    def _raw_aliases(registry):
        for n, law in registry.laws.items():
            for a in law.aliases:
                yield a, n
        for n, (_, names, _) in REPEALED_LAWS.items():
            for a in names:
                yield a, -n

    def _law_mentions(self, text, ft):
        """[(start, end, law_no_signed)] — 'N sayili' her zaman kazanir; ortusen ad eslesmeleri atilir."""
        found = []
        for m in SAYILI.finditer(ft):
            no = int(m.group("no"))
            signed = -no if no in REPEALED_LAWS and no not in self.registry.laws else no
            found.append((m.start(), m.end(), signed, 0))
        for rx, src in ((self.alias_re, ft), (self.short_re, text)):
            if rx is None:
                continue
            for m in rx.finditer(src):
                key = fold(m.group(0)) if rx is self.alias_re else None
                no = self.long[key] if key is not None else self.short[m.group(0)]
                found.append((m.start(), m.end(), no, 1))
        for m in SAME_LAW.finditer(ft):
            this = m.group(0).startswith("bu ")
            found.append((m.start(), m.end(), "this" if this else None, 2))  # None: onceki kanun, "this": metnin kanunu
        found.sort(key=lambda x: (x[0], x[3], -(x[1] - x[0])))
        out, last_end = [], -1
        for s, e, no, _ in found:
            if s < last_end:
                continue
            out.append((s, e, no))
            last_end = e
        return out

    def extract(self, text, context_law=None):
        """-> (citations, orphan_count). Orphan: kanunu belirtilmemis madde atifi.
        context_law: metin bir kanunun kendisiyse 'bu Kanunun 17 nci maddesi' o kanuna baglanir."""
        ft = fold(text)
        cites, covered, prev_law = [], [], context_law
        for s, e, no in self._law_mentions(text, ft):
            if no == "this":  # 'bu Kanun': metin bir kanunsa o kanun, degilse (LLM cevabi) en son anilan kanun
                no = context_law if context_law is not None else prev_law
            elif no is None:
                no = prev_law
            if no is None:
                continue
            prev_law = no
            tail = ft[e:e + ARTICLE_WINDOW]
            pm = POSSESSIVE.match(tail)
            off = pm.end() if pm else 0
            m = None
            for rx in (ART_PREFIX, ART_SUFFIX, ART_BARE):
                m = rx.match(tail[off:])
                if m:
                    break
            if not m:
                continue
            gd = m.groupdict()
            kind = gd.get("kind")
            pnum = gd.get("para") or gd.get("para_f")
            para = int(pnum) if pnum else ORDINALS.get(gd.get("para_w") or "", None)
            items = _expand(m.group("nums"))
            end = e + off + m.end()
            for i, (art, p, in_range) in enumerate(items):
                aid = f"{kind}-{art}" if kind else art
                pp = p if p is not None else (para if len(items) == 1 else None)
                cites.append(Citation(abs(no), aid, pp, s, end, text[s:end], old_law=no < 0,
                                      group=f"{s}:{no}" if in_range else None))
            covered.append((s, end))
        orphans = 0
        for m in ORPHAN.finditer(ft):
            if not any(a <= m.start() < b for a, b in covered):
                orphans += 1
        return cites, orphans


@dataclass
class Verdict:
    citation: dict
    status: str
    paragraph_ok: bool | None   # None: fikra yok ya da dogrulanamiyor (numarasiz fikrali kanun)
    current_law: int | None = None  # eski kanun ise yerine gecen kanun
    note: str | None = None          # 'alt_bolum': 'm. 25/I', 'm. 12/C' gibi bent/baslik harfi gosterimi


def check(cite, registry):
    if cite.old_law:
        return Verdict(asdict(cite), "eski_kanun", None, REPEALED_LAWS.get(cite.law, (None, None, None))[2])
    law = registry.laws.get(cite.law)
    if law is None:
        return Verdict(asdict(cite), "bilinmeyen_kanun", None)
    art = law.articles.get(cite.article)
    note = None
    if art is None and "/" in cite.article and "-" not in cite.article:
        # 'İş Kanunu m. 25/I' (bent), 'KMK m. 12/C', 'TBK m. 392/D' (baslik harfi): ana madde varsa uydurma sayilmaz
        art, note = law.articles.get(cite.article.split("/")[0]), "alt_bolum"
    if art is None:
        return Verdict(asdict(cite), "uydurma_madde", None)
    if art["repealed"]:
        return Verdict(asdict(cite), "mulga_madde", None, note=note)
    pok = None
    if cite.paragraph is not None and art["paragraphs"]:
        pok = 1 <= cite.paragraph <= art["paragraphs"]
    return Verdict(asdict(cite), "var", pok, note=note)


_SEVERITY = {"uydurma_madde": 0, "mulga_madde": 1, "eski_kanun": 2, "bilinmeyen_kanun": 3, "var": 4}


def audit(text, extractor, context_law=None):
    """Metindeki tum atiflari denetle. Ayni (kanun, madde) bir kez sayilir."""
    cites, orphans = extractor.extract(text, context_law)
    seen, verdicts, groups = set(), [], {}
    for c in cites:
        if c.key() in seen:
            continue
        seen.add(c.key())
        v = check(c, extractor.registry)
        if c.group is None:
            verdicts.append(v)
        elif c.group not in groups or _SEVERITY[v.status] < _SEVERITY[groups[c.group].status]:
            groups[c.group] = v   # aralik: en kotu durum (bir ucu uydurmaysa aralik uydurma)
    verdicts.extend(groups.values())
    counts = {s: sum(v.status == s for v in verdicts) for s in STATUSES}
    return {"verdicts": verdicts, "counts": counts, "n": len(verdicts), "orphans": orphans}


# ═══ Taninmayan kanun adlari: '<Buyuk Harfli Ad> Kanunu m. N' ama ad hicbir gercek kanuna uymuyor ═══
# Ornek LLM ciktilari: 'Yurttaşlar Birliği Kanunu m. 27', 'Mülkiyet Hakkı Kanunu m. 69-71'. Bunlar extract()'in
# goremedigi atiflardir. Otomatik olarak 'uydurma' sayilmaz: once ad listesi elle gozden gecirilir (gercek bir kanunun
# farkli yazimi olabilir), sonra esleme tablosu (ad -> kanun no ya da UYDURMA) uygulanir.
_UP = "A-ZÇĞİÖŞÜÂÎÛ"
_LOW = "a-zçğıöşüâîû"
LAW_NAME = re.compile(
    r"(?P<name>(?:(?!Kanun)[" + _UP + r"][" + _LOW + r"]+\s+(?:(?:ve|ile)\s+)?){1,9}Kanun(?:u)?)(?:nun|un|na|a|da)?(?![" + _LOW + r"])"
    r"[\"“”*_]*(?:'?(?:n[ıiuü]n|[ıiuü]n|na|ne|da|de))?(?:\s*\([^()]{1,20}\))?"
    r"(?P<art>\s*,?\s*(?:m\.|md\.|[Mm]adde)\s*\d|\s+\d{1,4}\s*(?:\.|'?\s*(?:inci|ıncı|uncu|üncü|nci|ncı|ncu|ncü))?\s*[Mm]adde)")
_LEAD = re.compile(r"^(?:T\.?\s*C\.?\s+|Bu\s+|Aynı\s+|Söz\s+[Kk]onusu\s+|İlgili\s+|Anılan\s+|Ancak\s+|Çünkü\s+|Ayrıca\s+"
                   r"|Ama\s+|Fakat\s+|Yani\s+|Örneğin\s+|Ve\s+|Dolayısıyla\s+)+")


def normalize_law_name(name):
    return " ".join(_LEAD.sub("", name.strip()).split())


def unrecognized_law_spans(text, extractor):
    """-> [(start, end, ad)] : madde atfi iceren ama kayit defterindeki hicbir kanun adina/kisaltmasina uymayan kanun adlari.
    extract()'in zaten tanidigi kanun adlari (span ortusmesi) atlanir. Span, bastaki 'Ancak/Bu/...' atilmis ada aittir."""
    ft = fold(text)
    known_spans = [(s, e) for s, e, _ in extractor._law_mentions(text, ft)]
    out = []
    for m in LAW_NAME.finditer(text):
        s, e = m.start("name"), m.end("name")
        if any(a < e and s < b for a, b in known_spans):
            continue
        raw = m.group("name")
        lead = _LEAD.match(raw)
        name = normalize_law_name(raw)
        if "Hükmünde" in name or len(name.split()) < 2:
            continue
        out.append((s + (lead.end() if lead else 0), e, name))
    return out


def unrecognized_law_mentions(text, extractor):
    """-> [ad, ...] (unrecognized_law_spans'in yalniz adlari)."""
    return [n for _, _, n in unrecognized_law_spans(text, extractor)]