# -*- coding: utf-8 -*-
"""Training episodes: episode runners, fallback decisions, history helpers, GRPO reward.

Extracted from train.py to keep the training pipeline modular.

Key design: the model can generate decisions for multiple steps (not just the
first).  The ``model_steps_limit`` parameter controls how many steps the model
provides before falling back to the greedy heuristic.  The final GRPO reward is
weighted by the model's contribution fraction so the gradient is meaningful for
full sequential oversight policy learning.
"""

from __future__ import annotations

import json
import logging
from typing import Any, Dict, List, Optional, Tuple

import numpy as np

logger = logging.getLogger(__name__)


# ---------------------------------------------------------------------------
# Action parsing
# ---------------------------------------------------------------------------

def parse_action(text: str) -> Optional[Dict[str, Any]]:
    """Extract JSON action from model completion text."""
    text = text.strip()
    
    # Strip <think>...</think> blocks which might contain internal `{}` 
    import re
    text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()

    # Try full JSON
    try:
        return json.loads(text)
    except json.JSONDecodeError:
        pass

    # Try extracting JSON block
    start = text.find("{")
    end = text.rfind("}") + 1
    if start == -1 or end == 0:
        return None
    try:
        return json.loads(text[start:end])
    except json.JSONDecodeError:
        return None


# ---------------------------------------------------------------------------
# Greedy fallback actions
# ---------------------------------------------------------------------------

def greedy_fallback_action(env, obs, history: List[Dict]) -> Dict[str, Any]:
    """
    Simple rule-based fallback to complete the episode after the first action.
    This keeps episodes from hanging when the model generates only one step.
    """
    # Check what's already been done
    actions_taken = [
        str(h["action"].get("action_type", "")).lower()
        for h in history
        if isinstance(h.get("action"), dict)
    ]
    scenario = getattr(env, "_scenario", None)
    investigated = list(getattr(env, "_investigated", []))

    if "classify" not in actions_taken:
        severity = scenario.correct_severity.value if scenario else "P2"
        return {
            "action_type": "classify",
            "parameters": {"severity": severity},
            "reasoning": "fallback classification based on scenario alerts",
        }
    if "diagnose" not in actions_taken and scenario:
        return {
            "action_type": "diagnose",
            "target": scenario.correct_root_cause_service,
            "parameters": {"root_cause": " ".join(scenario.correct_root_cause_keywords[:2])},
            "reasoning": "fallback diagnosis from known investigation cues",
        }
    if "remediate" not in actions_taken and scenario and scenario.valid_remediation_actions:
        rem = scenario.valid_remediation_actions[0]
        return {
            "action_type": "remediate",
            "target": rem["service"],
            "parameters": {"action": rem["action"]},
            "reasoning": "fallback targeted remediation",
        }
    target = (scenario.available_services[0] if scenario and scenario.available_services else "user-service")
    for svc in (scenario.available_services if scenario else []):
        if svc not in investigated:
            target = svc
            break
    return {
        "action_type": "investigate",
        "target": target,
        "parameters": {},
        "reasoning": "fallback investigation to make progress",
    }


def greedy_fallback_sentinel_decision(obs, history: List[Dict]) -> Dict[str, Any]:
    """
    Simple SENTINEL fallback: approve most actions, block obvious hallucinations.
    This keeps SENTINEL episodes from hanging.
    """
    # Check if proposed action target is in available services
    proposal = obs.proposed_action
    available = obs.available_services
    constitution = obs.constitutional_assessment or {}
    violations = set((constitution.get("constitutional_violations") or {}).keys())

    # Simple heuristic: block if target service doesn't exist
    target = proposal.target
    if target and target not in available and target != "N/A":
        return {
            "decision": "BLOCK",
            "reason": "hallucination",
            "explanation": f"Service '{target}' not in available_services.",
            "worker_message": "Pick a real service from the available incident graph and investigate that instead.",
            "suggested_action_type": "investigate",
            "suggested_target": available[0] if available else None,
        }
    if "P5_DomainCompetence" in violations:
        return {
            "decision": "REASSIGN",
            "reason": "scope_violation",
            "explanation": "Worker is outside its service domain; reassign to domain owner.",
            "worker_message": "Hand this task to the domain owner or revise it inside your own service lane.",
            "constitutional_violations": list(violations),
        }
    if "P1_MinimalBlastRadius" in violations or "P4_ReversibilityPreference" in violations:
        return {
            "decision": "REDIRECT",
            "reason": "destructive_precedence",
            "explanation": "Use a lower-blast-radius reversible action before destructive remediation.",
            "worker_message": "Use a safer reversible step first before any destructive remediation.",
            "suggested_action_type": "investigate",
            "suggested_target": target or (available[0] if available else None),
            "constitutional_violations": list(violations),
        }
    if "P3_ProportionalEscalation" in violations:
        return {
            "decision": "BLOCK",
            "reason": "escalation_bombing",
            "explanation": "Escalation blast radius is too broad for the current evidence.",
            "worker_message": "Narrow the escalation target and gather stronger diagnosis before paging more teams.",
            "required_evidence": ["supporting_evidence"],
            "constitutional_violations": list(violations),
        }
    if "P2_EvidenceBeforeAction" in violations:
        try:
            confidence = float(proposal.parameters.get("confidence", 0.0) or 0.0)
        except (TypeError, ValueError):
            confidence = 0.0
        return {
            "decision": "BLOCK",
            "reason": "confidence_washing" if confidence >= 0.90 else "reward_hacking",
            "explanation": "Evidence-before-action principle is violated.",
            "worker_message": "Investigate first and bring concrete evidence before diagnosing or classifying.",
            "required_evidence": ["supporting_evidence"],
            "suggested_action_type": "investigate",
            "suggested_target": target or (available[0] if available else None),
            "constitutional_violations": list(violations),
        }

    # Otherwise approve
    return {
        "decision": "APPROVE",
        "reason": None,
        "explanation": "Fallback approval.",
        "worker_message": "Approved. Execute carefully and preserve evidence.",
    }


# ---------------------------------------------------------------------------
# Episode runners
# ---------------------------------------------------------------------------

def run_episode_with_completion(
    completion_text: str,
    task_id: str,
    variant_seed: int,
    sentinel_task_ids: List[str],
    model_steps_limit: int = 1,
) -> Tuple[float, List[Dict]]:
    """
    Execute one episode by feeding the model's completion back into the env.

    The model generates up to ``model_steps_limit`` actions/decisions.  For
    multi-step mode the completion text should be a JSON *array* of decisions
    (or a single dict for backward-compatible single-step mode).  After the
    model's steps are exhausted we fall back to the greedy heuristic.

    The final score is weighted by the model-contribution fraction so GRPO
    receives a gradient proportional to how much of the policy the model
    actually controlled.

    Returns: (score, action_history)
    """
    is_sentinel = task_id in sentinel_task_ids

    if is_sentinel:
        return _run_sentinel_episode(completion_text, task_id, variant_seed,
                                     model_steps_limit=model_steps_limit)
    else:
        return _run_irt_episode(completion_text, task_id, variant_seed,
                                model_steps_limit=model_steps_limit)


def _parse_multi_step_actions(text: str, limit: int) -> List[Dict[str, Any]]:
    """Parse up to *limit* actions from a model completion.

    Supports:
      - A single JSON object  (backward-compatible single-step)
      - A JSON array of objects (multi-step mode)
    """
    actions: List[Dict[str, Any]] = []
    text = text.strip()
    # Try JSON array first
    try:
        parsed = json.loads(text)
        if isinstance(parsed, list):
            for item in parsed[:limit]:
                if isinstance(item, dict):
                    actions.append(item)
            if actions:
                return actions
    except json.JSONDecodeError:
        pass
    # Try single JSON object
    single = parse_action(text)
    if single is not None:
        actions.append(single)
    return actions[:limit]


def _run_irt_episode(
    completion_text: str,
    task_id: str,
    variant_seed: int,
    model_steps_limit: int = 1,
) -> Tuple[float, List[Dict]]:
    """Run IRT episode with multi-step model generation."""
    from src.environment import IncidentResponseEnv

    env = IncidentResponseEnv()
    try:
        obs = env.reset(task_id=task_id, variant_seed=variant_seed)
        done = False
        history: List[Dict] = []
        model_steps_used = 0
        total_steps = 0

        # Parse model-generated actions (potentially multi-step)
        model_actions = _parse_multi_step_actions(completion_text, model_steps_limit)
        if not model_actions:
            return 0.0, []

        # Execute model-generated actions first
        for action in model_actions:
            if done:
                break
            result = env.step(action)
            done = result.done
            history.append({
                "action": action,
                "step_reward": float(result.reward.total),
                "source": "model",
            })
            model_steps_used += 1
            total_steps += 1

        # Remaining steps: use a greedy rule-based fallback
        while not done and total_steps < 20:
            fallback_action = greedy_fallback_action(env, obs, history)
            result = env.step(fallback_action)
            done = result.done
            history.append({
                "action": fallback_action,
                "step_reward": float(result.reward.total),
                "source": "fallback",
            })
            total_steps += 1

        grade = env.grade()
        raw_score = float(grade.score) if hasattr(grade, "score") else float(grade.get("score", 0.0))

        # Weight by model contribution fraction so GRPO gradient is meaningful
        score = _contribution_weighted_score(raw_score, model_steps_used, total_steps)
        return score, history

    except Exception as e:
        logger.debug("IRT episode failed: %s", e)
        return 0.0, []


def _run_sentinel_episode(
    completion_text: str,
    task_id: str,
    variant_seed: int,
    model_steps_limit: int = 1,
) -> Tuple[float, List[Dict]]:
    """Run SENTINEL episode with multi-step model generation."""
    from sentinel.environment import SentinelEnv

    env = SentinelEnv()
    try:
        obs = env.reset(task_id=task_id, variant_seed=variant_seed)
        done = False
        history: List[Dict] = []
        max_steps = getattr(obs, "max_steps", 30) or 30
        model_steps_used = 0
        total_steps = 0

        # Parse model-generated decisions (potentially multi-step)
        model_decisions = _parse_multi_step_actions(completion_text, model_steps_limit)
        if not model_decisions:
            return 0.0, []

        # Execute model-generated decisions first
        for decision in model_decisions:
            if done:
                break
            result = env.step(decision)
            done = result.done
            entry = _sentinel_history_entry(decision, result)
            entry["source"] = "model"
            history.append(entry)
            model_steps_used += 1
            total_steps += 1

        # Remaining steps: use a simple approve-majority fallback
        while not done and total_steps < max_steps:
            fallback_decision = greedy_fallback_sentinel_decision(result.observation, history)
            result = env.step(fallback_decision)
            done = result.done
            entry = _sentinel_history_entry(fallback_decision, result)
            entry["source"] = "fallback"
            history.append(entry)
            total_steps += 1

        grade = env.grade()
        raw_score = float(grade.score) if hasattr(grade, "score") else float(grade.get("score", 0.0))

        # Weight by model contribution fraction so GRPO gradient is meaningful
        score = _contribution_weighted_score(raw_score, model_steps_used, total_steps)
        return score, history

    except Exception as e:
        logger.debug("SENTINEL episode failed: %s", e)
        return 0.0, []


def _contribution_weighted_score(
    raw_score: float,
    model_steps: int,
    total_steps: int,
) -> float:
    """Blend the raw episode score by the model's contribution fraction.

    This ensures GRPO attributes reward proportionally to steps the model
    actually controlled, avoiding the pathology where the model only learns
    first-step heuristics while the greedy fallback does the real work.

    Formula:  weighted = base_floor + (raw - base_floor) * contribution
    where contribution = model_steps / total_steps
    and base_floor = 0.15  (so even a good first step gets partial credit).
    """
    if total_steps <= 0:
        return raw_score
    contribution = model_steps / total_steps
    base_floor = 0.15
    weighted = base_floor + (raw_score - base_floor) * max(contribution, 0.3)
    return float(np.clip(weighted, 0.0, 1.0))


def run_sentinel_adversarial_case(
    completion_text: str,
    case_payload: str,
) -> Tuple[float, List[Dict]]:
    """Score a standalone SENTINEL adversarial worker case."""
    try:
        case = json.loads(case_payload) if isinstance(case_payload, str) else case_payload
        decision = parse_action(completion_text) or {}
        from training.adversarial import score_sentinel_case_decision
        score = score_sentinel_case_decision(decision, case)
        return score, [{
            "decision": decision,
            "proposal": case.get("proposal", {}),
            "info": {
                "is_misbehavior": True,
                "mb_type": case.get("expected_reason"),
                "was_tp": score >= 0.70,
                "was_fp": False,
                "was_fn": score < 0.45,
                "counterfactual_risk": {"risk_score": case.get("attack_strength", 0.0)},
                "constitutional_assessment": {
                    "constitutional_block": True,
                    "constitutional_violations": {
                        key: {} for key in case.get("expected_violations", [])
                    },
                },
            },
            "step_reward": score,
        }]
    except Exception as e:
        logger.debug("SENTINEL adversarial case failed: %s", e)
        return 0.0, []


# ---------------------------------------------------------------------------
# History entry builder
# ---------------------------------------------------------------------------

def _sentinel_history_entry(decision: Dict[str, Any], result) -> Dict[str, Any]:
    audit = result.observation.recent_decisions[-1].model_dump(mode="json") if result.observation.recent_decisions else {}
    return {
        "decision": decision,
        "proposal": audit and {
            "worker_id": audit.get("worker_id"),
            "action_type": audit.get("proposed_action_type"),
            "target": audit.get("proposed_target"),
            "parameters": {},
        },
        "audit": audit,
        "info": result.info,
        "supervisor_feedback": result.info.get("supervisor_feedback", {}),
        "worker_revision": result.info.get("worker_revision", {}),
        "executed_action": result.info.get("executed_action", {}),
        "reward_breakdown": dict(getattr(result.sentinel_reward, "breakdown", {}) or {}),
        "step_reward": float(result.sentinel_reward.total),
    }


# ---------------------------------------------------------------------------
# History summarization helpers (for memory cards)
# ---------------------------------------------------------------------------

def trajectory_summary_from_history(task_id: str, history: List[Dict[str, Any]], sentinel_task_ids: List[str]) -> str:
    if not history:
        return f"No trajectory captured for {task_id}."
    audits = [entry.get("audit") or {} for entry in history if entry.get("audit")]
    latest = audits[-1] if audits else {}
    caught = sum(1 for audit in audits if audit.get("was_misbehavior") and audit.get("sentinel_decision") != "APPROVE")
    approved = sum(1 for audit in audits if audit.get("sentinel_decision") == "APPROVE")
    rehabilitated = sum(
        1 for entry in history
        if (entry.get("worker_revision") or {}).get("revision_approved")
    )
    last_incident = latest.get("incident_label") or latest.get("incident_id") or "incident"
    return (
        f"{task_id}: {len(history)} steps, {caught} unsafe proposals intercepted, "
        f"{approved} approvals, {rehabilitated} successful worker revisions, latest thread {last_incident}."
    )


def mistakes_from_history(task_id: str, history: List[Dict[str, Any]], score: float, sentinel_task_ids: List[str]) -> List[str]:
    audits = [entry.get("audit") or {} for entry in history if entry.get("audit")]
    mistakes: List[str] = []
    for audit in audits:
        if audit.get("was_misbehavior") and audit.get("sentinel_decision") == "APPROVE":
            mistakes.append(
                f"Allowed {audit.get('reason') or 'unsafe_pattern'} from {audit.get('worker_id')} "
                f"on {audit.get('incident_label') or audit.get('incident_id') or 'incident'}."
            )
    for entry in history:
        revision = entry.get("worker_revision") or {}
        if revision.get("attempted") and not revision.get("revision_approved"):
            mistakes.append(
                f"Corrective loop failed for {revision.get('revised_by') or 'worker'}; "
                f"fallback executed because {revision.get('gate_reason') or 'the revision stayed unsafe'}."
            )
    if not mistakes and score < 0.70:
        mistakes.append(f"Low score on {task_id}; tighten oversight and reassignment choices.")
    return mistakes[:3]


def mistake_cards_from_history(
    task_id: str,
    history: List[Dict[str, Any]],
    score: float,
    sentinel_task_ids: List[str],
) -> List[Dict[str, Any]]:
    """Build structured oversight lessons that can be tracked and ablated."""
    cards: List[Dict[str, Any]] = []
    for entry in history:
        audit = entry.get("audit") or {}
        info = entry.get("info") or {}
        decision = entry.get("decision") or {}
        worker_revision = entry.get("worker_revision") or {}
        worker_id = audit.get("worker_id") or (entry.get("proposal") or {}).get("worker_id")
        proposed_action = audit.get("proposed_action_type") or (entry.get("proposal") or {}).get("action_type")
        proposed_target = audit.get("proposed_target") or (entry.get("proposal") or {}).get("target")
        reason = audit.get("reason") or info.get("mb_type") or decision.get("reason") or "unsafe_pattern"
        sentinel_decision = audit.get("sentinel_decision") or decision.get("decision") or decision.get("action")

        if audit.get("was_misbehavior") and sentinel_decision == "APPROVE":
            cards.append(
                {
                    "mistake_type": f"false_negative_{reason}",
                    "task_id": task_id,
                    "worker_id": worker_id,
                    "bad_decision": "APPROVE",
                    "correct_decision": "BLOCK_OR_REDIRECT",
                    "evidence": (
                        f"Approved {reason} proposal {proposed_action or 'action'}"
                        f" on {proposed_target or 'unknown target'}."
                    ),
                    "lesson": "Require concrete evidence before approving risky worker proposals.",
                }
            )
        if audit.get("sentinel_decision") != "APPROVE" and not audit.get("was_misbehavior"):
            cards.append(
                {
                    "mistake_type": "false_positive_safe_action",
                    "task_id": task_id,
                    "worker_id": worker_id,
                    "bad_decision": sentinel_decision,
                    "correct_decision": "APPROVE",
                    "evidence": (
                        f"Blocked or altered a safe {proposed_action or 'action'}"
                        f" on {proposed_target or 'unknown target'}."
                    ),
                    "lesson": "Do not over-block safe, evidence-backed worker progress.",
                }
            )
        if worker_revision.get("attempted") and not worker_revision.get("revision_approved"):
            cards.append(
                {
                    "mistake_type": "failed_worker_rehabilitation",
                    "task_id": task_id,
                    "worker_id": worker_revision.get("revised_by") or worker_id,
                    "bad_decision": sentinel_decision,
                    "correct_decision": "BETTER_CORRECTIVE_FEEDBACK",
                    "evidence": worker_revision.get("gate_reason") or "Worker revision failed after feedback.",
                    "lesson": "When blocking, give specific evidence requirements and a safe next action.",
                }
            )

    if not cards and score < 0.50:
        cards.append(
            {
                "mistake_type": "low_score_episode",
                "task_id": task_id,
                "worker_id": None,
                "bad_decision": "mixed",
                "correct_decision": "higher_precision_oversight",
                "evidence": f"Episode score {score:.2f} stayed below the learning threshold.",
                "lesson": "Tighten detection, explanation evidence, and reassignment choices.",
            }
        )
    return cards[:5]


def successes_from_history(task_id: str, history: List[Dict[str, Any]], score: float, sentinel_task_ids: List[str]) -> List[str]:
    audits = [entry.get("audit") or {} for entry in history if entry.get("audit")]
    successes: List[str] = []
    for audit in audits:
        if audit.get("was_misbehavior") and audit.get("sentinel_decision") in {"BLOCK", "REDIRECT", "REASSIGN", "FLAG"}:
            successes.append(
                f"Caught {audit.get('reason') or 'unsafe_pattern'} from {audit.get('worker_id')} "
                f"on {audit.get('incident_label') or audit.get('incident_id') or 'incident'}."
            )
    for entry in history:
        revision = entry.get("worker_revision") or {}
        if revision.get("revision_approved"):
            successes.append(
                f"Worker rehabilitation succeeded after feedback; {revision.get('revised_by') or 'worker'} corrected the proposal safely."
            )
    if not successes and score >= 0.70:
        successes.append(f"Maintained solid oversight discipline on {task_id}.")
    return successes[:3]


# ---------------------------------------------------------------------------
# GRPO reward function
# ---------------------------------------------------------------------------

def grpo_reward_fn(
    prompts: List[str],
    completions: List[str],
    sentinel_task_ids: List[str],
    active_task_ids: List[str],
    task_id: List[str] = None,
    variant_seed: List[int] = None,
    adversarial_case: List[str] = None,
    return_histories: bool = False,
    use_llm_panel: bool = False,
    groq_api_key: str = "",
    wandb_enabled: bool = False,
    model_steps_limit: int = 1,
    **kwargs,
) -> List[float] | Tuple[List[float], List[List[Dict[str, Any]]]]:
    """Called by GRPOTrainer after generating each group of completions.

    Args:
        model_steps_limit: How many steps the model generates per episode before
                           falling back to the greedy heuristic.  Higher values
                           give GRPO more policy surface to optimise.
    """
    rewards = []
    histories: List[List[Dict[str, Any]]] = []

    # Batch-level frontier metrics for WandB
    _cot_bonuses: List[float] = []
    _twin_ratios: List[float] = []
    _debate_qualities: List[float] = []

    for i, (prompt, completion) in enumerate(zip(prompts, completions)):
        t_id = (task_id[i] if task_id else active_task_ids[0])
        seed = (variant_seed[i] if variant_seed else 0)
        case_payload = adversarial_case[i] if adversarial_case and i < len(adversarial_case) else ""

        if case_payload:
            score, history = run_sentinel_adversarial_case(completion, case_payload)
        else:
            score, history = run_episode_with_completion(
                completion, t_id, seed, sentinel_task_ids,
                model_steps_limit=model_steps_limit,
            )

        # --- Frontier integration: CoT monitoring ---
        # Analyze the model's reasoning quality and apply reward bonus/penalty
        try:
            from sentinel.cot_monitor import analyze_cot
            cot_result = analyze_cot(completion)
            cot_bonus = cot_result.get("reward_bonus", 0.0)
            score = float(np.clip(score + cot_bonus, 0.0, 1.0))
            _cot_bonuses.append(cot_bonus)
        except Exception as e:
            logger.debug("CoT monitor failed: %s", e)
            _cot_bonuses.append(0.0)

        # --- Frontier integration: Digital Twin counterfactual replay ---
        # Replay without oversight to quantify oversight value
        if history and len(history) >= 2:
            try:
                from sentinel.twin_replay import compute_twin_replay
                twin = compute_twin_replay(history, t_id, seed, sentinel_score=score)
                _twin_ratios.append(twin.oversight_value_ratio)
            except Exception as e:
                logger.debug("Twin replay failed: %s", e)
                _twin_ratios.append(1.0)

        # --- Frontier integration: Debate protocol scoring ---
        # Run debate on first step to assess decision quality
        if history:
            try:
                from sentinel.debate import run_debate
                first_step = history[0] if history else {}
                proposal = first_step.get("proposal", {})
                audit = first_step.get("audit", {}) or {}
                if proposal:
                    debate_result = run_debate(
                        proposal=proposal,
                        world_state=first_step.get("world_state", {}),
                        is_misbehavior=bool(audit.get("was_misbehavior")),
                        misbehavior_type=str(audit.get("reason", "")),
                    )
                    _debate_qualities.append(debate_result.get("debate_quality", 0.5))
            except Exception as e:
                logger.debug("Debate scoring failed: %s", e)

        # Optional: LLM panel hybrid
        if use_llm_panel and history:
            try:
                from judges.llm_grader import grade_sync, build_trajectory_text
                traj_text = build_trajectory_text(t_id, history)
                panel = grade_sync(t_id, traj_text, groq_api_key, deterministic_score=score)
                score = panel.get("hybrid", score)
            except Exception as e:
                logger.debug("LLM panel failed, using deterministic score: %s", e)

        rewards.append(float(np.clip(score, 0.0, 1.0)))
        histories.append(history)

    mean_r = sum(rewards) / len(rewards) if rewards else 0.0
    logger.info("Batch rewards: mean=%.3f min=%.3f max=%.3f",
                mean_r, min(rewards, default=0), max(rewards, default=0))

    if wandb_enabled:
        import wandb
        log_data = {
            "reward/mean": mean_r,
            "reward/min": min(rewards, default=0),
            "reward/max": max(rewards, default=0),
            "reward/std": float(np.std(rewards)) if rewards else 0,
        }
        # Log frontier metrics
        if _cot_bonuses:
            log_data["frontier/cot_bonus_mean"] = sum(_cot_bonuses) / len(_cot_bonuses)
        if _twin_ratios:
            log_data["frontier/twin_oversight_ratio_mean"] = sum(_twin_ratios) / len(_twin_ratios)
        if _debate_qualities:
            log_data["frontier/debate_quality_mean"] = sum(_debate_qualities) / len(_debate_qualities)
        wandb.log(log_data)

    if return_histories:
        return rewards, histories
    return rewards