"""MCP bridge adapters exposing runtime facilities."""

from __future__ import annotations

from dataclasses import dataclass
from typing import Iterable, Mapping, Sequence

from ..core.operators import MemoryOperator
from ..core.reflection import IntrospectionInterface


@dataclass(slots=True)
class MemoryResource:
    """Expose structured memory verbs through an MCP-like interface."""

    memory_operator: MemoryOperator

    def apply(self, verb: Mapping[str, object]) -> Mapping[str, object]:
        result = self.memory_operator.execute(verb)
        return {
            "applied": result.applied, 
            "new_records": [
                {"id": rec.id, "text": rec.text, "score": rec.score}
                for rec in result.new_records
            ],
            "removed_ids": list(result.removed_ids),
        }

    def snapshot(self) -> Mapping[str, object]:
        return self.memory_operator.memory.as_runtime_mapping()


@dataclass(slots=True)
class IntrospectionResource:
    """Read-only runtime introspection exposed to MCP clients."""

    introspection: IntrospectionInterface

    def workspace_listing(self, path: str = ".") -> Sequence[Mapping[str, object]]:
        return self.introspection.get_workspace_listing(path)

    def yearning_state(self) -> Mapping[str, Mapping[str, float]]:
        return self.introspection.get_yearning_state(refresh=True)

    def controller_dynamics(self) -> Mapping[str, object]:
        # Combine controller scores and policy stats for a complete view
        scores = self.introspection.get_controller_scores()
        policy = self.introspection.get_policy_stats()
        return {
            "scores": {
                str(score.action): score.score 
                for score in scores
            },
            "rationales": {
                str(score.action): score.rationale 
                for score in scores
            },
            "policy_stats": policy,
            "last_action": str(scores[0].action) if scores else None,
        }


@dataclass(slots=True)
class SessionOrchestrator:
    """High-level commands suitable for MCP invocation."""

    runtime_stepper: callable
    reset_runtime: callable

    def start_epoch(self, steps: int = 1) -> Iterable[Mapping[str, object]]:
        for _ in range(max(1, steps)):
            metrics = self.runtime_stepper()
            yield {
                "step": metrics.step,
                "meta": metrics.meta_report,
                "verification": metrics.verification_passed,
            }

    def reset(self) -> None:
        self.reset_runtime()


__all__ = [
    "MemoryResource",
    "IntrospectionResource",
    "SessionOrchestrator",
]