import json
from typing import Optional, Any

from core.logger import get_logger


logger = get_logger("core.http")


class SessionManager:
    def __init__(self) -> None:
        self._session: Optional[object] = None

    async def get_session(self) -> Optional[object]:
        if self._session:
            return self._session
        try:
            import aiohttp
        except ImportError:
            logger.warning("aiohttp not installed")
            return None
        self._session = aiohttp.ClientSession()
        return self._session

    async def close(self) -> None:
        if self._session:
            await self._session.close()
            self._session = None

    async def get_json(self, url: str) -> Optional[Any]:
        session = await self.get_session()
        if session:
            async with session.get(url) as response:
                return await response.json()
        try:
            from urllib import request
        except Exception:
            return None
        loop = __import__("asyncio").get_event_loop()
        return await loop.run_in_executor(None, self._sync_get_json, url)

    def _sync_get_json(self, url: str) -> Optional[Any]:
        from urllib import request

        with request.urlopen(url) as response:
            payload = response.read().decode("utf-8")
        try:
            return json.loads(payload)
        except json.JSONDecodeError:
            return None


class RestrictedSession:
    def __init__(self, manager: SessionManager, allow_network: bool) -> None:
        self.manager = manager
        self.allow_network = allow_network

    async def get_session(self) -> Optional[object]:
        if not self.allow_network:
            return None
        return await self.manager.get_session()

    async def get_json(self, url: str) -> Optional[Any]:
        if not self.allow_network:
            raise RuntimeError("Network access disabled for plugins")
        return await self.manager.get_json(url)