"""
Recolector de resultados para el Agent CLI.

Buffer local de resultados cuando el WebSocket está temporalmente
desconectado. Los resultados se envían cuando la conexión se restablece.
"""
import json
from collections import deque
from pathlib import Path
from typing import Any

from jama_agent.config import ensure_jama_dir
from jama_agent.logger import log

BUFFER_PATH = Path.home() / ".jama" / "result_buffer.jsonl"
MAX_BUFFER_SIZE = 1000  # máximo de resultados en buffer


class ResultCollector:
    """Recolecta resultados de tareas y los envía al cloud.

    Si el WebSocket está desconectado, los resultados se almacenan
    en un buffer local (memoria + disco) y se reenvían cuando la
    conexión se restablece.
    """

    def __init__(self) -> None:
        self._buffer: deque[dict[str, Any]] = deque(maxlen=MAX_BUFFER_SIZE)
        self._load_persisted()

    def _load_persisted(self) -> None:
        """Carga resultados pendientes del buffer en disco."""
        if not BUFFER_PATH.exists():
            return
        try:
            with open(BUFFER_PATH) as f:
                for line in f:
                    line = line.strip()
                    if line:
                        self._buffer.append(json.loads(line))
            log.info(f"Buffer cargado: {len(self._buffer)} resultados pendientes")
        except Exception as exc:
            log.warning(f"Error cargando buffer: {exc}")

    def _persist(self) -> None:
        """Guarda el buffer actual en disco."""
        ensure_jama_dir()
        try:
            with open(BUFFER_PATH, "w") as f:
                for item in self._buffer:
                    f.write(json.dumps(item) + "\n")
        except Exception as exc:
            log.warning(f"Error persistiendo buffer: {exc}")

    def add(self, result: dict[str, Any]) -> None:
        """Agrega un resultado al buffer.

        Args:
            result: Diccionario con el resultado de una tarea
        """
        self._buffer.append(result)
        self._persist()

    def get_pending(self) -> list[dict[str, Any]]:
        """Retorna todos los resultados pendientes de envío."""
        return list(self._buffer)

    def clear(self) -> None:
        """Limpia el buffer después de envío exitoso."""
        self._buffer.clear()
        if BUFFER_PATH.exists():
            BUFFER_PATH.unlink()

    def remove(self, task_id: str) -> None:
        """Elimina un resultado específico del buffer."""
        self._buffer = deque(
            (r for r in self._buffer if r.get("task_id") != task_id),
            maxlen=MAX_BUFFER_SIZE,
        )
        self._persist()

    @property
    def count(self) -> int:
        """Cantidad de resultados pendientes."""
        return len(self._buffer)
