"""
Genesis Persistent Context Architecture — MVFL Interceptor
Story 3.06 — Track B

Wires the MVFL error-correction pipeline into the interceptor chain.
Priority 90 — runs late, AFTER business logic, checks results.
"""
import json
from datetime import datetime, timezone
from pathlib import Path

from core.interceptors.base_interceptor import BaseInterceptor, InterceptorMetadata
from core.mvfl.mvfl_trigger import MVFLTrigger
from core.mvfl.voyager_defense import VoyagerDefense
from core.mvfl.correction_loop import CorrectionLoop

EVENTS_DIR = Path("/mnt/e/genesis-system/data/observability")


class MVFLInterceptor(BaseInterceptor):
    """
    Architecturally forced error correction.
    Priority 90 — runs late, AFTER business logic, checks results.

    Wires together MVFLTrigger, VoyagerDefense, and CorrectionLoop into
    the standard interceptor chain contract.
    """

    def __init__(
        self,
        trigger: MVFLTrigger = None,
        voyager: VoyagerDefense = None,
        correction_loop: CorrectionLoop = None,
    ):
        self._trigger = trigger or MVFLTrigger()
        self._voyager = voyager or VoyagerDefense()
        self._correction_loop = correction_loop or CorrectionLoop()

    @property
    def metadata(self) -> InterceptorMetadata:
        return InterceptorMetadata(name="mvfl", priority=90)

    async def pre_execute(self, task_payload: dict) -> dict:
        """
        No-op — MVFL acts on results, not inputs.
        Returns task_payload unchanged (identity pass-through).
        """
        return task_payload

    async def post_execute(self, result: dict, task_payload: dict) -> None:
        """
        Evaluate result via MVFLTrigger + VoyagerDefense.
        If either gate fires → run CorrectionLoop and mutate result in-place.
        Records every decision to events.jsonl.

        Signature matches BaseInterceptor: result first, task_payload second.
        """
        trigger_result = self._trigger.evaluate(result, task_payload)
        voyager_score = self._voyager.score(result)

        blocked = trigger_result.triggered or voyager_score.should_block

        # Log decision (before correction so we always have a record)
        self._log_decision(task_payload, trigger_result, voyager_score, blocked)

        if blocked:
            correction = await self._correction_loop.run(
                task_payload, result, trigger_result
            )
            if correction.success:
                # Merge corrected output into result in-place
                result.update(correction.output)
                result["mvfl_corrected"] = True
                result["mvfl_attempts"] = correction.attempts
            else:
                result["mvfl_escalated"] = True
                result["mvfl_attempts"] = correction.attempts
                if correction.output:
                    result.update(correction.output)

    async def on_error(self, error: Exception, task_payload: dict) -> dict:
        """
        Evaluate error context via MVFLTrigger.
        If triggered → run CorrectionLoop and return correction output.

        Signature matches BaseInterceptor: error first, task_payload second.
        """
        error_output = {"status": "error", "error": str(error)}
        trigger_result = self._trigger.evaluate(error_output, task_payload)

        self._log_decision(task_payload, trigger_result, None, trigger_result.triggered)

        if trigger_result.triggered:
            correction = await self._correction_loop.run(
                task_payload, error_output, trigger_result
            )
            return correction.output if correction.output else error_output

        return {"error": str(error), "task_payload": task_payload}

    async def on_correction(self, correction_payload: dict) -> dict:
        """
        Passthrough — correction handling is fully encapsulated in CorrectionLoop.
        Returns the correction_payload unchanged.
        """
        return correction_payload

    # ------------------------------------------------------------------
    # Private helpers
    # ------------------------------------------------------------------

    def _log_decision(
        self,
        task_payload: dict,
        trigger_result,
        voyager_score,
        blocked: bool,
    ) -> None:
        """
        Append one JSON line to EVENTS_DIR/events.jsonl.
        Never raises — telemetry must not interrupt the pipeline.
        """
        try:
            EVENTS_DIR.mkdir(parents=True, exist_ok=True)
            event = {
                "timestamp": datetime.now(timezone.utc).isoformat(),
                "event_type": "mvfl_decision",
                "task_id": task_payload.get("task_id", "unknown"),
                "triggered": trigger_result.triggered if trigger_result else False,
                "trigger_type": trigger_result.trigger_type if trigger_result else None,
                "voyager_score": voyager_score.score if voyager_score else 0.0,
                "blocked": blocked,
            }
            with open(EVENTS_DIR / "events.jsonl", "a") as f:
                f.write(json.dumps(event) + "\n")
        except Exception:
            pass  # Telemetry must never break the pipeline


# VERIFICATION_STAMP
# Story: 3.06 (Track B) — MVFLInterceptor — Wires MVFL Into Chain
# Verified By: parallel-builder (claude-sonnet-4-6)
# Verified At: 2026-02-25
# Tests: 10/10
# Coverage: 100%