from __future__ import annotations

from typing import Any

from solarchain_eval.config import BenchmarkConfig

from .prompts import planner_messages
from .schemas import (
    ActionBounds,
    AuditPolicy,
    PlannerOutput,
    safe_default_plan,
    validate_planner_output,
)


class SafeDefaultPlanner:
    def __init__(self, config: BenchmarkConfig):
        self.config = config
        self.last_valid = True
        self.failure_count = 0

    def plan(self, episode_context: dict[str, Any]) -> PlannerOutput:
        self.last_valid = True
        return safe_default_plan(self.config)


class RulePlanner:
    def __init__(self, config: BenchmarkConfig):
        self.config = config
        self.last_valid = True
        self.failure_count = 0

    def plan(self, episode_context: dict[str, Any]) -> PlannerOutput:
        market = self.config.market
        max_violation = float(episode_context.get("max_violation_rate", 0.0))
        min_gap = float(episode_context.get("min_gap", 0.0))
        mean_slippage = float(episode_context.get("mean_static_slippage", 0.0))

        risk_high = max_violation > 0.01 or min_gap < -0.10 or mean_slippage > 0.75
        if risk_high:
            raw = PlannerOutput(
                governance_mode="rule_conservative",
                action_bounds=ActionBounds(
                    reward_ratio=[market.min_reward_ratio, min(0.45, market.max_reward_ratio)],
                    liquidity_ratio=[max(0.35, market.min_liquidity_ratio), market.max_liquidity_ratio],
                    burn_rate=[0.02, min(0.18, market.max_burn_rate)],
                ),
                audit_policy=AuditPolicy(
                    force_audit_if_violation_rate_above=0.005,
                    force_audit_if_gap_below=-0.05,
                    force_audit_if_action_jitter_above=0.18,
                    force_audit_if_static_slippage_above=0.60,
                    max_audits_per_episode=min(6, int(self.config.episode_steps)),
                    target_audit_rate=0.25,
                    audit_cooldown_steps=2,
                ),
                rationale="Rule planner selected conservative bounds due to episode-level risk signals.",
            )
        else:
            raw = PlannerOutput(
                governance_mode="rule_balanced",
                action_bounds=ActionBounds(
                    reward_ratio=[market.min_reward_ratio, market.max_reward_ratio],
                    liquidity_ratio=[market.min_liquidity_ratio, market.max_liquidity_ratio],
                    burn_rate=[0.0, market.max_burn_rate],
                ),
                audit_policy=AuditPolicy(
                    force_audit_if_violation_rate_above=0.01,
                    force_audit_if_gap_below=-0.10,
                    force_audit_if_action_jitter_above=0.25,
                    force_audit_if_static_slippage_above=0.75,
                    max_audits_per_episode=min(6, int(self.config.episode_steps)),
                    target_audit_rate=0.25,
                    audit_cooldown_steps=2,
                ),
                rationale="Rule planner selected balanced bounds for a lower-risk episode.",
            )
        plan, valid, _ = validate_planner_output(raw, self.config)
        self.last_valid = valid
        return plan


class LLMPlanner:
    def __init__(self, llm_client: Any, config: BenchmarkConfig):
        self.llm_client = llm_client
        self.config = config
        self.last_valid = True
        self.failure_count = 0

    def plan(self, episode_context: dict[str, Any]) -> PlannerOutput:
        payload = self.llm_client.plan_structured(planner_messages(episode_context))
        plan, valid, error = validate_planner_output(payload, self.config)
        self.last_valid = valid
        if not valid:
            self.failure_count += 1
            self.last_valid = False
            raise RuntimeError(f"LLM planner structured output validation failed: {error}")
        return plan