"""v3.6 Runtime Harness — Runtime Decision Logger (layer 1-4 helper).

chair_authorization_id=CHAIR-AUTH-TASK-2704-V36-CONTROL-PLANE-P0-MVP-260528

Contract:
- log_runtime_event(event_type, task_id, payload) -> None  (safe-fail)
- Reuses scripts/harness/v36/logger.py JSONL writer.
- Each record validates against memory/schemas/v36_runtime_harness_decision.schema.json.
- ANU_V36_HARNESS_TEST_MODE=1 redirects writes to /tmp.

Schema required fields injected automatically:
  schema_version, decision_id, ts, task_id, contract_layer,
  decision_class, evidence, decision_outcome, actor_attribution,
  reason_code, chair_authorization_id
"""
from __future__ import annotations

import hashlib
import json
import os
import time
import uuid
from datetime import datetime, timezone
from typing import Optional

CHAIR_AUTHORIZATION_ID = "CHAIR-AUTH-TASK-2704-V36-CONTROL-PLANE-P0-MVP-260528"
SCHEMA_VERSION = "v36.runtime_harness.decision.v1"

# Map event_type → (contract_layer, decision_class, reason_code)
_EVENT_MAP = {
    "marker_written": (
        "layer_1_dispatch_marker",
        "STATE_TRANSITION",
        "spawn_state_progressed_normal",
    ),
    "state_transition": (
        "layer_2_spawn_detection",
        "STATE_TRANSITION",
        "spawn_state_progressed_normal",
    ),
    "spawn_unknown": (
        "layer_2_spawn_detection",
        "UNKNOWN",
        "spawn_signals_insufficient_unknown",
    ),
    "chat_suppressed": (
        "layer_3_watchdog",
        "SUPPRESSED",
        "watchdog_suppressed_by_escalate_marker",
    ),
    "alert_info": (
        "layer_3_watchdog",
        "ALERT_INFO",
        "watchdog_silently_stalled_cycle_1",
    ),
    "alert_warn": (
        "layer_3_watchdog",
        "ALERT_WARN",
        "watchdog_silently_stalled_cycle_2",
    ),
    "escalate_chair": (
        "layer_3_watchdog",
        "ESCALATE_CHAIR",
        "watchdog_escalate_chair_explicit",
    ),
    "closeout_detected": (
        "layer_4_callback_closeout",
        "STATE_TRANSITION",
        "closeout_marker_observed_anu_signal_required",
    ),
    "anu_signal_written": (
        "layer_4_callback_closeout",
        "STATE_TRANSITION",
        "closeout_marker_observed_anu_signal_required",
    ),
    "callback_received": (
        "layer_4_callback_closeout",
        "STATE_TRANSITION",
        "callback_normal_received",
    ),
}

_DEFAULT_EVENT_MAP = (
    "layer_1_dispatch_marker",
    "STATE_TRANSITION",
    "spawn_state_progressed_normal",
)


def log_runtime_event(
    event_type: str,
    task_id: str,
    payload: dict,
    decision_outcome_override: Optional[dict] = None,
) -> None:
    """Log a runtime harness event to the JSONL decision audit log.

    Args:
        event_type: One of the known event types (marker_written, state_transition, etc.)
        task_id: Task identifier.
        payload: Event-specific data (stored in evidence.payload).
        decision_outcome_override: Override the auto-generated decision_outcome.

    Safe-fail: silently swallows all exceptions.
    """
    try:
        _log_runtime_event_impl(event_type, task_id, payload, decision_outcome_override)
    except Exception:
        # Absolute safe-fail: never raise from logger
        pass


def _log_runtime_event_impl(
    event_type: str,
    task_id: str,
    payload: dict,
    decision_outcome_override: Optional[dict],
) -> None:
    layer, decision_class, reason_code = _EVENT_MAP.get(event_type, _DEFAULT_EVENT_MAP)

    now_utc = datetime.now(timezone.utc)
    ts_iso = now_utc.isoformat()

    # decision_id: deterministic from task_id + event_type + timestamp
    raw_id = f"{task_id}.{event_type}.{ts_iso}"
    decision_id = hashlib.sha256(raw_id.encode()).hexdigest()[:24]

    # Build evidence dict from payload
    evidence: dict = {"event_type": event_type, "payload": payload}

    # Map known payload fields to schema evidence fields
    if "marker_path" in payload:
        evidence["dispatch_marker"] = {
            "marker_path": payload.get("marker_path"),
            "schedule_id": payload.get("schedule_id"),
            "dispatch_method": payload.get("dispatch_method"),
            "bot_key_hash": payload.get("bot_key_hash"),
        }
    if "closeout_state" in payload:
        evidence["closeout_state"] = payload["closeout_state"]
    if "watchdog_state" in payload:
        evidence["watchdog_state"] = payload["watchdog_state"]
    if "spawn_state" in payload:
        evidence["spawn_state"] = payload["spawn_state"]

    # Build decision_outcome
    next_action_map = {
        "STATE_TRANSITION": "PROCEED",
        "UNKNOWN": "POLL_NEXT_SAMPLE",
        "ALERT_INFO": "POLL_NEXT_SAMPLE",
        "ALERT_WARN": "POLL_NEXT_SAMPLE",
        "ESCALATE_CHAIR": "REPORT_TO_CHAIR",
        "SUPPRESSED": "SUPPRESS",
        "ALLOW": "PROCEED",
        "DENY": "BLOCK_TOOL_CALL",
        "HOLD_FOR_CHAIR": "HOLD_AWAIT_DECISION",
    }
    decision_outcome = decision_outcome_override or {
        "next_state": payload.get("next_state", decision_class),
        "next_action": next_action_map.get(decision_class, "PROCEED"),
        "tool_call_decision": None,
    }

    record = {
        "schema_version": SCHEMA_VERSION,
        "decision_id": decision_id,
        "ts": ts_iso,
        "task_id": task_id,
        "contract_layer": layer,
        "decision_class": decision_class,
        "evidence": evidence,
        "decision_outcome": decision_outcome,
        "actor_attribution": {
            "evidence_level": "L3_RUNTIME_HOOK_EVIDENCE",
            "claimed_actor": "v36_control_plane",
            "verifiable": True,
            "evidence_path": "memory/system/.v36_harness_decision.jsonl",
        },
        "reason_code": reason_code,
        "chair_authorization_id": CHAIR_AUTHORIZATION_ID,
        "dry_run": False,
        "linked_decision_ids": [],
    }

    # Delegate to the existing logger.py JSONL writer
    from scripts.harness.v36.logger import log_decision
    log_decision(record)