"""P1 协议基线：串行、幂等、带现实预算的模拟器客户端。

协议硬规则 [题面] 与实现对应：
- 每个新动作使用新的 request_id；仅在网络失败后重试"完全相同的动作"时，
  复用原 request_id 与原请求体 —— 本类通过一次性序列化出 bytes 并原样重发保证；
- 必须同时检查 HTTP 状态与 accepted；accepted=false 不更新状态，
  其 virtual_time_s=0 不当作当前虚拟时刻；
- 逐次等待响应、不得并发；本类完全同步，一个动作未决不发起下一个；
- 现实截止用 /enter 响应的 remaining_real_duration_s 建立本地单调时钟，
  预留退出余量；/exit 不做预算拦截。
"""

from __future__ import annotations

import json
import uuid
from dataclasses import dataclass
from time import monotonic, sleep

from ..config import ProblemConfig, Vec2
from .log import SessionLog
from .rules import (CLEAR_RESULTS, DIRECTION, EXIT_USER, MEASURE_RESULTS,
                    POSITION_FIELDS, STATUS_OK, STATUS_RETRYABLE)
from .state import RobotState
from .timing import CostBreakdown
from .transport import RequestsTransport, Transport, TransportError


class ProtocolError(RuntimeError):
    """协议层失败，含 HTTP 状态与响应体；默认不重试（确定性错误）。"""

    def __init__(self, message: str, status: int | None = None, body=None):
        super().__init__(message)
        self.status = status
        self.body = body


class ActionRejected(ProtocolError):
    """HTTP 200 但 accepted=false：动作未生效，状态不得更新。"""

    def __init__(self, message: str, body=None):
        super().__init__(message, status=STATUS_OK, body=body)


class ProtocolViolation(ProtocolError):
    """响应与协议约定不符（字段缺失、值非法、虚拟时刻回退等）。"""


class DeadlineExceeded(RuntimeError):
    """现实预算不足：预留退出余量后剩余时间不够执行新动作。"""


@dataclass(frozen=True)
class MeasureOutcome:
    result: str
    svd_deg: float | None
    virtual_time_s: float
    predicted: CostBreakdown
    raw: dict


@dataclass(frozen=True)
class ClearOutcome:
    result: str
    virtual_time_s: float
    predicted: CostBreakdown
    raw: dict


@dataclass(frozen=True)
class ExitInfo:
    reason: str
    virtual_time_s: float
    raw: dict


def _validate_identifier(name: str, value: str, max_bytes: int) -> None:
    if not isinstance(value, str) or not value:
        raise ValueError(f"{name} 必须是非空字符串")
    encoded = value.encode("utf-8")
    if not 1 <= len(encoded) <= max_bytes:
        raise ValueError(f"{name} 的 UTF-8 长度须在 1..{max_bytes} 字节")
    if any(code < 0x20 or code == 0x7F for code in encoded):
        raise ValueError(f"{name} 不能包含控制字符")


def _validate_position(position: dict, limit: float) -> None:
    if set(position) != set(POSITION_FIELDS):
        raise ValueError("position 字段必须是且只能是 x、y")
    for key in ("x", "y"):
        value = position[key]
        if isinstance(value, bool) or not isinstance(value, (int, float)):
            raise ValueError(f"position.{key} 必须是数值")
        if value != value or value in (float("inf"), float("-inf")):
            raise ValueError(f"position.{key} 必须是有限数值")
        if abs(value) > limit:
            raise ValueError(f"position.{key} 绝对值不得超过 {limit} 米")


def _validate_channel(channel) -> int:
    # 写成 JSON number 1.0 且恰为整数也接受 [题面]；1.5 拒绝。
    if isinstance(channel, bool) or not isinstance(channel, (int, float)):
        raise ValueError("channel 必须是数值")
    if isinstance(channel, float) and not channel.is_integer():
        raise ValueError("channel 必须是整数")
    channel = int(channel)
    if not 1 <= channel <= 20:
        raise ValueError("channel 必须在 1..20 范围内")
    return channel


class SimulatorClient:
    """四条指令的同步客户端。状态只在 accepted=true 后推进。"""

    def __init__(self, robot_id: str, *,
                 config: ProblemConfig = ProblemConfig(),
                 transport: Transport | None = None,
                 log: SessionLog | None = None,
                 clock=monotonic):
        _validate_identifier("robot_id", robot_id, config.session.robot_id_max_bytes)
        self.robot_id = robot_id
        self.config = config
        self.session = config.session
        self.transport = transport if transport is not None else RequestsTransport()
        self.log = log if log is not None else SessionLog()
        self.clock = clock
        self.state = RobotState()
        self._prefix = uuid.uuid4().hex[:12]
        self._seq = 0
        self._deadline: float | None = None          # 本地单调时钟截止
        self._server_deadline_ms: float | None = None  # 服务器时间戳交叉核对
        self._enter_monotonic: float | None = None   # 实机计时起点（/enter 成功）

    # ------------------------------------------------------------ 公共动作 API
    def enter(self) -> dict:
        started = self.clock()
        payload = self._payload("/enter")
        response = self._call("/enter", payload)
        self.state.apply_enter(response)
        remaining = response["remaining_real_duration_s"]
        if not isinstance(remaining, (int, float)) or remaining <= 0:
            raise ProtocolViolation("remaining_real_duration_s 缺失或非法", body=response)
        self._deadline = self.clock() + remaining
        self._server_deadline_ms = (response["real_timestamp_ms"]
                                    + remaining * 1000.0)
        self._enter_monotonic = self.clock()
        self._log_step("/enter", payload, response, started,
                       predicted=CostBreakdown(0.0, 0.0, 0.0))
        return response

    def measure(self, position: Vec2, channel: int) -> MeasureOutcome:
        started = self.clock()
        payload = self._payload("/measure", position=position, channel=channel)
        response = self._call("/measure", payload)
        predicted = self.state.apply_measure(payload, response,
                                             cost=self.config.cost)
        result = response.get("measure_result")
        if result not in MEASURE_RESULTS:
            raise ProtocolViolation(f"measure_result 非法: {result!r}", body=response)
        svd = response.get("svd_deg")
        if result == DIRECTION:
            if not isinstance(svd, (int, float)) or isinstance(svd, bool):
                raise ProtocolViolation("direction 响应缺少数值 svd_deg", body=response)
        self._log_step("/measure", payload, response, started, result=result,
                       predicted=predicted, channel=payload["channel"])
        return MeasureOutcome(result, float(svd) if svd is not None else None,
                              response["virtual_time_s"], predicted, response)

    def clear(self, position: Vec2, channel: int) -> ClearOutcome:
        started = self.clock()
        payload = self._payload("/clear", position=position, channel=channel)
        response = self._call("/clear", payload)
        predicted = self.state.apply_clear(payload, response,
                                           cost=self.config.cost)
        result = response.get("clear_result")
        if result not in CLEAR_RESULTS:
            raise ProtocolViolation(f"clear_result 非法: {result!r}", body=response)
        self._log_step("/clear", payload, response, started, result=result,
                       predicted=predicted, channel=payload["channel"])
        return ClearOutcome(result, response["virtual_time_s"], predicted, response)

    def exit(self) -> ExitInfo:
        started = self.clock()
        payload = self._payload("/exit")
        response = self._call("/exit", payload)
        self.state.apply_exit(response)
        reason = response.get("exit_reason")
        if reason != EXIT_USER:
            raise ProtocolViolation(f"exit_reason 非法: {reason!r}", body=response)
        self._log_step("/exit", payload, response, started,
                       predicted=CostBreakdown(0.0, 0.0, 0.0))
        return ExitInfo(reason, response["virtual_time_s"], response)

    # ---------------------------------------------------------------- 预算控制
    @property
    def real_remaining_s(self) -> float | None:
        """按本地单调时钟估计的剩余现实秒数（未 enter 时为 None）。"""
        return None if self._deadline is None else self._deadline - self.clock()

    def _log_step(self, path: str, payload: dict, response: dict,
                  started: float, *, result: str | None = None,
                  predicted: CostBreakdown, channel: int | None = None) -> None:
        """每步计时留档 [用户决策 2026-09-11]：实机墙钟耗时 + 比赛虚拟耗时分项
        （移动=直线距离/5、切频道 1s、检测 5s、清除成功 5s/未发现 3s）。

        step 事件不含 response 字段，不会混入 action_events / 虚拟时刻复算。
        """
        now = self.clock()
        entry: dict = {"event": "step", "path": path,
                       "request_id": payload["request_id"],
                       "real_elapsed_s": round(now - started, 6),
                       "virtual_time_s": response["virtual_time_s"],
                       "virtual_cost": {"move_s": round(predicted.move_s, 6),
                                        "switch_s": round(predicted.switch_s, 6),
                                        "action_s": round(predicted.action_s, 6),
                                        "total_s": round(predicted.total_s, 6)}}
        if self._enter_monotonic is not None:
            entry["real_since_enter_s"] = round(now - self._enter_monotonic, 6)
        if "position" in payload:
            entry["position"] = {"x": payload["position"]["x"],
                                 "y": payload["position"]["y"]}
        if channel is not None:
            entry["channel"] = channel
        if result is not None:
            entry["result"] = result
        self.log.append(entry)

    def _check_budget(self, path: str) -> None:
        if path == "/exit" or self._deadline is None:
            return
        margin = self.session.reserve_exit_s
        if self.real_remaining_s <= margin:
            raise DeadlineExceeded(
                f"剩余现实时间 {self.real_remaining_s:.1f}s 不足以预留 {margin:.1f}s 退出余量")

    # ---------------------------------------------------------------- 内部机制
    def _payload(self, path: str, *, position: Vec2 | None = None,
                 channel: int | None = None) -> dict:
        payload = {"arena_id": self.session.arena_id,
                   "robot_id": self.robot_id,
                   "request_id": self._next_request_id()}
        if position is not None:
            x, y = float(position[0]), float(position[1])
            _validate_position({"x": x, "y": y}, self.config.field.coord_abs_limit_m)
            payload["position"] = {"x": x, "y": y}
        if channel is not None:
            payload["channel"] = _validate_channel(channel)
        return payload

    def _next_request_id(self) -> str:
        self._seq += 1
        request_id = f"{self._prefix}-{self._seq:04d}"
        _validate_identifier("request_id", request_id,
                             self.session.request_id_max_bytes)
        return request_id

    def _call(self, path: str, payload: dict) -> dict:
        """串行执行一个动作；网络失败原样重发，HTTP 确定性错误立即抛出。"""
        self._check_budget(path)
        body = json.dumps(payload, ensure_ascii=False, allow_nan=False).encode("utf-8")
        if len(body) > self.session.request_body_max_bytes:
            raise ValueError("请求体超过 65536 字节")
        headers = {"Content-Type": "application/json"}
        url = self.session.base_url + path
        attempts, last_error = 0, None
        while attempts < self.session.max_attempts:
            attempts += 1
            started = self.clock()
            self.log.append({"event": "attempt", "path": path,
                             "request_id": payload["request_id"],
                             "attempt": attempts, "request": payload})
            try:
                result = self.transport.post(
                    url, body, headers,
                    timeout=(self.session.connect_timeout_s,
                             self.session.read_timeout_s))
            except TransportError as exc:
                last_error = exc
                self.log.append({"event": "transport_error", "path": path,
                                 "request_id": payload["request_id"],
                                 "attempt": attempts, "error": str(exc),
                                 "elapsed_s": self.clock() - started})
                if attempts < self.session.max_attempts:
                    sleep(self.session.retry_backoff_s * (2 ** (attempts - 1)))
                continue
            if result.status in STATUS_RETRYABLE:
                self.log.append({"event": "retryable_status", "path": path,
                                 "request_id": payload["request_id"],
                                 "attempt": attempts, "status": result.status})
                if attempts < self.session.max_attempts:
                    sleep(self.session.retry_backoff_s * (2 ** (attempts - 1)))
                continue
            if result.status != STATUS_OK:
                raise ProtocolError(
                    f"{path} 返回 HTTP {result.status}", status=result.status,
                    body=self._safe_json(result.body))
            response = self._safe_json(result.body)
            if response is None or response.get("accepted") is not True:
                raise ActionRejected(
                    f"{path} 未被接受: {response}", body=response)
            self._verify_clock(response)
            self.log.append({"event": "accepted", "path": path,
                             "request_id": payload["request_id"],
                             "request": payload, "response": response,
                             "attempts": attempts,
                             "elapsed_s": self.clock() - started})
            return response
        raise TransportError(
            f"{path} 重试 {attempts} 次仍失败: {last_error}") from last_error

    def _verify_clock(self, response: dict) -> None:
        """accepted=true 的虚拟时刻必须单调不减；现实时间戳用于漂移核对。"""
        virtual = response.get("virtual_time_s")
        if not isinstance(virtual, (int, float)) or isinstance(virtual, bool):
            raise ProtocolViolation("accepted 响应缺少 virtual_time_s", body=response)
        if virtual < self.state.virtual_time_s - 1e-9:
            raise ProtocolViolation(
                f"虚拟时刻回退: {self.state.virtual_time_s} -> {virtual}",
                body=response)
        if self._server_deadline_ms is not None:
            drift = (self._server_deadline_ms - response["real_timestamp_ms"]) / 1000.0
            if drift < self.session.reserve_exit_s / 2:
                # 服务器视角余量告急（本地时钟漂移或请求排队）；仅记录，交由上层决策。
                self.log.append({"event": "server_time_warning",
                                 "server_remaining_s": drift})

    @staticmethod
    def _safe_json(body: bytes):
        try:
            return json.loads(body.decode("utf-8"))
        except (UnicodeDecodeError, json.JSONDecodeError):
            return None