"""Quant Desk environment.

A multi-domain analyst desk: each reset serves one deterministic task drawn
from tasks.jsonl (log forensics, sensor math, invoice reconciliation, graph
counting, CIDR checks, media metadata, and more). The agent answers with a
single `{"answer": "..."}` action and gets up to three attempts per episode;
the episode reward is the best attempt score in [0, 1].
"""

import json
import logging
import threading
from pathlib import Path
from typing import Any, Dict, List, Optional
from uuid import uuid4

from openenv.core.env_server.interfaces import Environment
from openenv.core.env_server.types import Action, Observation

try:
    from ..models import QuantDeskAction, QuantDeskObservation, QuantDeskState
    from .graders import grade
except ImportError:
    from models import QuantDeskAction, QuantDeskObservation, QuantDeskState
    from server.graders import grade

logger = logging.getLogger(__name__)

_TASKS_PATH = Path(__file__).resolve().parent.parent / "tasks.jsonl"
MAX_ATTEMPTS = 3

_tasks_lock = threading.Lock()
_TASKS: Optional[List[Dict[str, Any]]] = None


def _load_tasks() -> List[Dict[str, Any]]:
    global _TASKS
    if _TASKS is None:
        with _tasks_lock:
            if _TASKS is None:
                with open(_TASKS_PATH, encoding="utf-8") as f:
                    _TASKS = [json.loads(line) for line in f if line.strip()]
    return _TASKS


class QuantDeskEnvironment(Environment):
    """Single-answer multi-domain QA environment for OpenEnv Arena."""

    SUPPORTS_CONCURRENT_SESSIONS = True

    def __init__(self):
        super().__init__()
        self._tasks = _load_tasks()
        self._state = QuantDeskState(episode_id=str(uuid4()))
        self._task: Optional[Dict[str, Any]] = None
        self._done = False

    def _pick_task(self, task_id=None, seed=None, split=None):
        pool = [t for t in self._tasks if split is None or t.get("split") == split]
        if not pool:
            pool = self._tasks
        if task_id is not None:
            for t in pool:
                if t["task_id"] == task_id:
                    return t
            raise ValueError(
                f"unknown task_id {task_id!r}; known ids: "
                + ", ".join(sorted(t["task_id"] for t in pool))
            )
        idx = (seed or 0) % len(pool)
        return pool[idx]

    def reset(
        self,
        seed: Optional[int] = None,
        episode_id: Optional[str] = None,
        task_id: Optional[str] = None,
        split: Optional[str] = None,
        **kwargs: Any,
    ) -> QuantDeskObservation:
        """Start an episode on the requested task."""
        self._task = self._pick_task(task_id=task_id, seed=seed, split=split)
        self._state = QuantDeskState(
            episode_id=episode_id or str(uuid4()),
            step_count=0,
            task_id=self._task["task_id"],
            attempts=0,
            best_score=0.0,
        )
        self._done = False
        logger.info("reset %s on task %s", self._state.episode_id, self._task["task_id"])
        return QuantDeskObservation(
            done=False,
            reward=0.0,
            prompt=self._task["prompt"],
            feedback="",
            attempts_remaining=MAX_ATTEMPTS,
            task_id=self._task["task_id"],
        )

    def step(
        self,
        action: Action,
        timeout_s: Optional[float] = None,
        **kwargs: Any,
    ) -> QuantDeskObservation:
        """Grade one answer attempt."""
        if self._task is None:
            self.reset()
        self._state.step_count += 1

        if self._done:
            return QuantDeskObservation(
                done=True,
                reward=self._state.best_score,
                feedback="Episode already finished.",
                attempts_remaining=0,
                task_id=self._state.task_id,
            )

        answer = getattr(action, "answer", "")
        if not isinstance(answer, str):
            answer = json.dumps(answer)
        self._state.attempts += 1
        score, hint = grade(answer.strip(), self._task)
        self._state.best_score = max(self._state.best_score, score)

        last = self._state.attempts >= MAX_ATTEMPTS
        self._done = score >= 0.999 or last
        remaining = 0 if self._done else MAX_ATTEMPTS - self._state.attempts

        if score >= 0.999:
            feedback = f"Correct on attempt {self._state.attempts}."
        else:
            feedback = (
                f"Attempt {self._state.attempts} of {MAX_ATTEMPTS} "
                f"scored {score:.2f}."
            )
            if hint:
                feedback += f" Hint: {hint}."
            if not self._done:
                feedback += " Try again."
            else:
                feedback += " No attempts left."

        reward = self._state.best_score if self._done else score
        return QuantDeskObservation(
            done=self._done,
            reward=reward,
            feedback=feedback,
            attempts_remaining=remaining,
            task_id=self._state.task_id,
        )

    @property
    def state(self) -> QuantDeskState:
        """Current environment state."""
        return self._state