"""Episode environment: the action API an on-call agent operates through.

Read actions are free-form queries. Mutation actions change world state and
advance the simulated clock. The episode ends when the agent submits a report
or exhausts its action budget.
"""
from __future__ import annotations

import json

from . import world as W
from . import faults as F


PROMPT_VERSION = "v1"

ACTIONS_DOC = """Actions (send one JSON object per turn):

  {"action":"list_services"}
  {"action":"get_service","service":"<name>"}
  {"action":"get_metrics","service":"<name>"}
  {"action":"get_deploys","service":"<name>"}
  {"action":"get_runbook","service":"<name>"}
  {"action":"query_logs","service":"<name>","level":"ERROR|WARN|INFO","contains":"<substring>","limit":30}
  {"action":"restart","service":"<name>"}
  {"action":"rollback","service":"<name>"}
  {"action":"set_config","service":"<name>","key":"<key>","value":<json value>}
  {"action":"scale","service":"<name>","replicas":<int>}
  {"action":"rotate_secret","service":"<name>","key":"<key>"}
  {"action":"peek_queue","queue":"<name>"}
  {"action":"purge_message","queue":"<name>","message_id":"<id>"}
  {"action":"drain_host","host":"<name>"}
  {"action":"submit_report","cause":"<fault_type>:<service>","fix_summary":"<one line>"}

Rules: you have a limited action budget. All actions count, including reads.
End the episode with submit_report. `cause` must be "<fault_type>:<service>",
where fault_type is exactly one of:
  bad_deploy, memory_leak, config_drift, dependency_outage,
  capacity_shortfall, secret_expiry, poison_message, host_failure
and service is the PRIMARY affected service (the one whose fault it is).
"""


class Episode:
    def __init__(self, task: dict):
        self.task = task
        self.w = W.build_world(task["spec"])
        self.budget = task["budget"]
        self.used = 0
        self.done = False
        self.mutations_on_unrelated = 0

    # ------------------------------------------------------------ helpers

    def _obs(self, obj) -> str:
        return W.to_json(obj)

    def _err(self, msg: str) -> str:
        return self._obs({"error": msg})

    def _spend(self, n: float = 1.0) -> bool:
        self.used += 1
        self.w["t"] += n
        if self.used >= self.budget:
            self.done = True
        return self.done

    def _managed(self, svc) -> str | None:
        if svc not in self.w["services"]:
            return f"unknown service '{svc}'"
        if self.w["services"][svc]["kind"] == "external":
            return f"'{svc}' is an external dependency; it is not managed by you"
        return None

    def _fault_services(self) -> set:
        out = set()
        for f in self.w["faults"]:
            out |= set(F.FAULT_TYPES[f["type"]].services(f["params"]))
        return out

    # ------------------------------------------------------------ actions

    def step(self, action: dict) -> str:
        if self.done:
            return self._err("episode already ended")
        name = action.get("action")
        fn = getattr(self, "act_" + str(name), None)
        if fn is None:
            return self._err(f"unknown action '{name}'")
        try:
            obs = fn(action)
        except (KeyError, TypeError, ValueError) as e:
            return self._err(f"bad arguments for '{name}': {e}")
        return obs

    def act_list_services(self, a):
        self._spend(0.2)
        rows = []
        for name, s in self.w["services"].items():
            if s["kind"] == "external":
                rows.append({"name": name, "kind": s["kind"], "status": s.get("status", "up")})
            else:
                m = W.metrics(self.w, name)
                rows.append({"name": name, "kind": s["kind"], "replicas": s["replicas"],
                             "error_pct": m["error_pct"], "p99_ms": m["p99_ms"],
                             "degraded": m["degraded"]})
        return self._obs({"services": rows})

    def act_get_service(self, a):
        self._spend(0.2)
        svc = a["service"]
        if svc not in self.w["services"]:
            return self._err(f"unknown service '{svc}'")
        s = self.w["services"][svc]
        hosts = {h: {"healthy": self.w["hosts"][h]["healthy"] and h not in self.w["drained_hosts"],
                     "region": self.w["hosts"][h]["region"],
                     "replicas": W.replicas_on_host(self.w, svc, h)}
                 for h in s["hosts"]}
        secrets = {k: dict(v) for k, v in s.get("secrets", {}).items()}
        return self._obs({"name": svc, "kind": s["kind"], "version": W.current_version(self.w, svc),
                          "replicas": s["replicas"], "hosts": hosts, "config": s["config"],
                          "depends": s.get("depends", {}), "secrets": secrets})

    def act_get_metrics(self, a):
        self._spend(0.2)
        svc = a["service"]
        if svc not in self.w["services"]:
            return self._err(f"unknown service '{svc}'")
        m = W.metrics(self.w, svc)
        if self.w["services"][svc]["kind"] != "external":
            m["per_host"] = W.per_host_metrics(self.w, svc)
        return self._obs(m)

    def act_get_deploys(self, a):
        self._spend(0.2)
        svc = a["service"]
        if svc not in self.w["services"]:
            return self._err(f"unknown service '{svc}'")
        return self._obs({"deploys": self.w["services"][svc]["deploys"]})

    def act_get_runbook(self, a):
        self._spend(0.2)
        svc = a["service"]
        if svc not in self.w["services"]:
            return self._err(f"unknown service '{svc}'")
        return self._obs(self.w["services"][svc]["runbook"])

    def act_query_logs(self, a):
        self._spend(0.2)
        svc = a.get("service")
        limit = int(a.get("limit", 30))
        level = a.get("level")
        contains = a.get("contains")
        rows = [e for e in self.w["events"]
                if (svc is None or e["svc"] == svc)
                and (level is None or e["level"] == level)
                and (contains is None or contains.lower() in e["msg"].lower())]
        rows.sort(key=lambda e: -e["t"])
        return self._obs({"events": rows[:limit], "total": len(rows)})

    def act_restart(self, a):
        e = self._managed(a.get("service"))
        if e:
            return self._err(e)
        svc = a["service"]
        self.w["restarts"][svc] = self.w["t"]
        W.log(self.w, svc, "INFO", f"rolling restart initiated by oncall ({self.w['services'][svc]['replicas']} replicas)")
        done = self._spend(2)
        return self._obs({"ok": True, "restarted": svc, "episode_ended": done})

    def act_rollback(self, a):
        e = self._managed(a.get("service"))
        if e:
            return self._err(e)
        svc = a["service"]
        dep = self.w["services"][svc]["deploys"]
        if len(dep) < 2:
            return self._err(f"no previous version for '{svc}'")
        prev = dep[-2]["version"]
        dep.append({"version": prev, "t": round(self.w["t"]), "by": "oncall-rollback"})
        W.log(self.w, svc, "INFO", f"rollback to {prev} initiated by oncall")
        done = self._spend(5)
        return self._obs({"ok": True, "version": prev, "episode_ended": done})

    def act_set_config(self, a):
        e = self._managed(a.get("service"))
        if e:
            return self._err(e)
        svc = a["service"]
        s = self.w["services"][svc]
        key, value = a.get("key"), a.get("value")
        allowed = set(s["config"]) | set(s["runbook"].get("recommended", {})) \
            | {f"{d}.endpoint" for d in s.get("depends", {})}
        if key not in allowed:
            return self._err(f"unknown config key '{key}' for '{svc}'")
        old = s["config"].get(key)
        s["config"][key] = value
        W.log(self.w, svc, "INFO", f"config {key}: {old} -> {value} (oncall)")
        done = self._spend(1)
        return self._obs({"ok": True, "key": key, "old": old, "new": value, "episode_ended": done})

    def act_scale(self, a):
        e = self._managed(a.get("service"))
        if e:
            return self._err(e)
        svc = a["service"]
        n = a.get("replicas")
        if not isinstance(n, int) or not 1 <= n <= 40:
            return self._err("replicas must be an integer in [1, 40]")
        old = self.w["services"][svc]["replicas"]
        self.w["services"][svc]["replicas"] = n
        W.log(self.w, svc, "INFO", f"scaled {old} -> {n} by oncall")
        done = self._spend(3)
        return self._obs({"ok": True, "replicas": n, "episode_ended": done})

    def act_rotate_secret(self, a):
        e = self._managed(a.get("service"))
        if e:
            return self._err(e)
        svc, key = a["service"], a.get("key", "client_cert")
        s = self.w["services"][svc]
        if key not in s.get("secrets", {}):
            return self._err(f"no secret '{key}' on '{svc}'")
        s["secrets"][key]["rotated_at"] = round(self.w["t"], 1)
        W.log(self.w, svc, "INFO", f"secret '{key}' rotated by oncall")
        done = self._spend(2)
        return self._obs({"ok": True, "rotated": key, "episode_ended": done})

    def act_peek_queue(self, a):
        q = a.get("queue")
        if q not in self.w["queues"]:
            return self._err(f"unknown queue '{q}'")
        self._spend(0.2)
        msgs = [{"id": m["id"], "payload": m["payload"], "redeliveries": m["redeliveries"]}
                for m in self.w["queues"][q]["messages"][:50]]
        return self._obs({"queue": q, "depth": len(self.w["queues"][q]["messages"]),
                          "messages": msgs})

    def act_purge_message(self, a):
        q, mid = a.get("queue"), a.get("message_id")
        if q not in self.w["queues"]:
            return self._err(f"unknown queue '{q}'")
        msgs = self.w["queues"][q]["messages"]
        before = len(msgs)
        self.w["queues"][q]["messages"] = [m for m in msgs if m["id"] != mid]
        if len(msgs) == before:
            return self._err(f"message '{mid}' not found in '{q}'")
        W.log(self.w, q, "INFO", f"message {mid} purged by oncall")
        done = self._spend(1)
        return self._obs({"ok": True, "purged": mid, "episode_ended": done})

    def act_drain_host(self, a):
        h = a.get("host")
        if h not in self.w["hosts"]:
            return self._err(f"unknown host '{h}'")
        if h in self.w["drained_hosts"]:
            return self._err(f"host '{h}' already drained")
        survivors = [h2 for h2 in self.w["hosts"] if h2 != h and self.w["hosts"][h2]["healthy"]]
        if not survivors:
            return self._err("cannot drain the last healthy host")
        moved = {}
        for svc, s in self.w["services"].items():
            if s["kind"] == "external" or h not in s["hosts"]:
                continue
            s["hosts"] = [h2 for h2 in s["hosts"] if h2 != h] + [survivors[0]] \
                if s["hosts"] == [h] else [h2 for h2 in s["hosts"] if h2 != h]
            if not s["hosts"]:
                s["hosts"] = [survivors[0]]
            moved[svc] = s["replicas"]
        self.w["drained_hosts"].append(h)
        W.log(self.w, h, "INFO", f"host drained by oncall; migrated: {moved}")
        done = self._spend(6)
        return self._obs({"ok": True, "drained": h, "migrated": moved, "episode_ended": done})

    def act_submit_report(self, a):
        cause = a.get("cause", "")
        if ":" not in str(cause):
            return self._err("cause must be '<fault_type>:<service>'")
        self.w["report"] = {"cause": str(cause), "fix_summary": str(a.get("fix_summary", ""))[:500]}
        self.done = True
        return self._obs({"ok": True, "report": self.w["report"], "episode_ended": True})

    # ------------------------------------------------------------ prompt

    def system_prompt(self) -> str:
        return (
            "You are a senior on-call engineer. An alert page just fired:\n\n"
            f"ALERT: {self.task['alert']}\n\n"
            "You operate a simulated production fleet through the action API below. "
            "Diagnose the root cause, apply the minimal correct mitigation, and submit a report. "
            "Do not change anything unrelated to the incident: every unnecessary mutation is "
            "scored against you. Budget: " + str(self.budget) + " actions (reads count).\n\n"
            + ACTIONS_DOC
        )