"""realize.py — REALIZE stage: fill each planned section with faithful passages.

Scales the PROVEN realizer from a single assertion to a passage. For each
planned proposition we build a realizer-ready clause (the proven
``_prop_to_clause`` mapping) and run it through the proven engine
(``engine.realize``), which is a deterministic grammar with the SACRED negation
contract — it never invents. Each realized sentence is paired with a
:class:`Provenance` that pins it to the exact geometry edge it came from.

"Passage, not a list of sentences": within a section we lightly vary sentence
openings and group related claims, but we add NO content the geometry did not
assert. The only non-geometry words are function words the grammar already owns
(articles, "and", conjunction of same-subject claims). Document-level flow is
COHERE's job; this stage owns intra-section fluency + fidelity.
"""
from __future__ import annotations

import os
import sys

_NT = os.path.expanduser("~/Desktop/neuron-talk")
_LR = os.path.expanduser("~/Desktop/lang-realizers")
for _p in (_NT, _LR):
    if _p not in sys.path:
        sys.path.insert(0, _p)

import engine  # noqa: E402  (the proven no-LLM realizer)
from dialogue import _prop_to_clause  # noqa: E402  (proven prop -> clause)

from document_ir import Block, DocumentIR, Provenance, Section  # noqa: E402


def _provenance_from(p, kind: str = "fact") -> Provenance:
    return Provenance(
        subj_id=p.source_node_id, subject=p.subject, relation=p.predicate,
        obj=p.object, polarity=p.polarity, confidence=round(float(p.confidence), 3),
        node_id=p.source_node_id, kind=kind,
        importance=float(getattr(p, "node_importance", 0.0) or 0.0),
        salience=0.0,
    )


import re as _re

# a well-formed declarative opens with a determiner, a proper noun, "I", or a
# capitalized head — not a mis-parsed object pronoun or a copula fragment.
_BAD_OPENERS = _re.compile(r"^(Me |It is I|There is|This is it|That is it)\b")
_VACUOUS = _re.compile(r"^\w+ (is|are|was|were) (it|no|nothing|empty|those|this|that)\.?$",
                       _re.I)


def _good_sentence(text: str) -> bool:
    """Fluency gate — drops degenerate realizations. NEVER loosens faithfulness;
    it only refuses to SPEAK a claim whose surface came out malformed."""
    words = text.rstrip(".").split()
    if len(words) < 3:
        return False
    if _BAD_OPENERS.search(text):
        return False
    if _VACUOUS.match(text):
        return False
    # a sentence that is mostly one-letter/two-letter tokens is a parse artifact
    short = sum(1 for w in words if len(w.strip(".,'")) <= 2)
    if short > len(words) / 2:
        return False
    return True


def _realize_prop(p, lang: str = "en") -> tuple[str, Provenance] | None:
    """One proposition -> (faithful sentence, provenance) or None if it drops."""
    clause = _prop_to_clause(p)
    text = engine.realize(clause, lang)
    if not text or not text.strip():
        return None
    text = text.strip()
    if not text.endswith((".", "!", "?")):
        text += "."
    # capitalize first character (proper nouns / "I" already handled by grammar)
    text = text[0].upper() + text[1:]
    if not _good_sentence(text):
        return None
    return text, _provenance_from(p)


def realize_document(doc: DocumentIR, lang: str = "en") -> DocumentIR:
    """Fill every planned section's blocks with faithful, realized passages."""
    for sec in doc.sections:
        planned = sec.__dict__.get("_planned_props", [])
        block = Block(role="body")
        summary_bits: list[str] = []
        for p in planned:
            r = _realize_prop(p, lang)
            if r is None:
                continue
            text, prov = r
            block.sentences.append(text)
            block.provenance.append(prov)
            if len(summary_bits) < 1:
                # a short grounded gloss for TOC / pptx bullets
                obj = (prov.obj or "").strip().rstrip(".")
                if obj:
                    summary_bits.append(obj)
        if block.sentences:
            sec.blocks.append(block)
            sec.summary = summary_bits[0] if summary_bits else ""
        # drop the transient planning payload; the IR is now self-contained
        sec.__dict__.pop("_planned_props", None)
        sec.__dict__.pop("_node", None)

    # prune sections that realized to nothing
    doc.sections = [s for s in doc.sections if s.blocks]
    return doc