import logging

import httpx

from yuxi.channel.protocols import ChannelAccountSnapshot

logger = logging.getLogger(__name__)

PROBE_URL = "https://api.weixin.qq.com/cgi-bin/getcallbackip"


class MiniProgramStatus:
    default_runtime = ChannelAccountSnapshot(account_id="default")

    def __init__(self, gateway=None):
        self._gateway = gateway

    async def probe(self, account: dict | None = None) -> bool:
        gateway = self._gateway
        if gateway is None:
            return False

        token = gateway.access_token
        if not token:
            return False

        url = f"{PROBE_URL}?access_token={token}"
        try:
            async with httpx.AsyncClient(timeout=10.0) as client:
                resp = await client.get(url)
                data = resp.json()

            if "errcode" in data and data["errcode"] != 0:
                logger.warning("MiniProgram probe failed: errcode=%s", data.get("errcode"))
                return False

            return True
        except Exception:
            logger.exception("MiniProgram probe failed")
            return False

    def build_summary(self, snapshot: object) -> dict:
        if not isinstance(snapshot, ChannelAccountSnapshot):
            return {}
        return {
            "account_id": snapshot.account_id,
            "running": snapshot.running,
            "connected": snapshot.connected,
            "health_state": snapshot.health_state,
        }

    def build_account_snapshot(
        self,
        account: dict,
        config: dict,
        runtime: ChannelAccountSnapshot | None = None,
        probe_result: object | None = None,
        audit: object | None = None,
    ) -> ChannelAccountSnapshot:
        gateway = self._gateway
        token = gateway.access_token if gateway else None
        return ChannelAccountSnapshot(
            account_id=account.get("account_id", "default"),
            name=account.get("name", ""),
            enabled=account.get("enabled", True),
            configured=bool(account.get("app_id") and account.get("app_secret")),
            status_state="linked" if token else "not-linked",
            running=getattr(runtime, "running", False) if runtime else False,
            connected=bool(token),
            last_message_at=getattr(runtime, "last_message_at", None) if runtime else None,
            health_state="ok" if probe_result else "unknown",
            dm_policy=account.get("dm_policy", "open"),
        )

    def collect_status_issues(self, accounts: list[ChannelAccountSnapshot]) -> list:
        issues = []
        for acc in accounts:
            if not acc.configured:
                issues.append({
                    "channel": "wechat-miniprogram",
                    "account_id": acc.account_id,
                    "kind": "not-configured",
                    "message": "MiniProgram credentials not configured",
                    "fix": "Set WECHAT_MINIPROGRAM_APP_ID, WECHAT_MINIPROGRAM_APP_SECRET, WECHAT_MINIPROGRAM_TOKEN, WECHAT_MINIPROGRAM_ENCODING_AES_KEY",
                })
            elif not acc.connected:
                issues.append({
                    "channel": "wechat-miniprogram",
                    "account_id": acc.account_id,
                    "kind": "not-connected",
                    "message": "MiniProgram gateway not running",
                    "fix": "Check environment variables and gateway status",
                })
        return issues