from datetime import datetime
from app.models.session import PersistentSession
from app.services.opencode_client import opencode_client
from app.services.storage import storage
from app.core.logging import logger

PERSISTENT_KEY = "persistent_sessions"


class PersistentSessionManager:
    def __init__(self):
        self._sessions: dict[str, PersistentSession] = {}

    def load(self):
        data = storage.load(PERSISTENT_KEY, {})
        if isinstance(data, dict):
            for k, v in data.items():
                self._sessions[k] = PersistentSession(**v)
        logger.info(f"Loaded {len(self._sessions)} persistent sessions")

    def save(self):
        data = {k: v.model_dump() for k, v in self._sessions.items()}
        storage.save(PERSISTENT_KEY, data)

    async def create_session(self, name: str | None = None) -> PersistentSession:
        session = await opencode_client.create_session(
            title=name or "Persistent Session"
        )
        ps = PersistentSession(
            id=session["id"],
            session_id=session["id"],
            name=name or f"Session {session['id'][:8]}",
            created_at=datetime.now(),
            last_used_at=datetime.now(),
        )
        self._sessions[ps.id] = ps
        self.save()
        logger.info(f"Created persistent session: {ps.id}")
        return ps

    async def delete_session(self, session_id: str) -> bool:
        ps = self._sessions.get(session_id)
        if not ps:
            return False
        await opencode_client.delete_session(ps.session_id)
        del self._sessions[session_id]
        self.save()
        logger.info(f"Deleted persistent session: {session_id}")
        return True

    async def send_message(self, session_id: str, text: str) -> dict:
        ps = self._sessions.get(session_id)
        if not ps:
            raise ValueError(f"Persistent session {session_id} not found")
        ps.last_used_at = datetime.now()
        self.save()
        return await opencode_client.send_message(ps.session_id, text)

    async def send_message_async(self, session_id: str, text: str):
        ps = self._sessions.get(session_id)
        if not ps:
            raise ValueError(f"Persistent session {session_id} not found")
        ps.last_used_at = datetime.now()
        self.save()
        await opencode_client.send_message_async(ps.session_id, text)

    def get_session(self, session_id: str) -> PersistentSession | None:
        return self._sessions.get(session_id)

    def list_sessions(self) -> list[PersistentSession]:
        return list(self._sessions.values())


persistent_session_manager = PersistentSessionManager()