"""代理验证服务 - 支持 HTTP/HTTPS/SOCKS4/SOCKS5"""
import asyncio
import random
import time
import aiohttp
import aiohttp_socks
from typing import Tuple
from app.core.log import logger


class ValidatorService:
    """代理验证器"""

    # 测试 URL
    TEST_URLS = {
        "http": ["http://httpbin.org/ip", "http://api.ipify.org"],
        "https": ["https://httpbin.org/ip", "https://api.ipify.org"],
    }

    def __init__(
        self,
        timeout: float = 5.0,
        connect_timeout: float = 3.0,
        max_concurrency: int = 50,
    ):
        self.timeout = timeout
        self.connect_timeout = connect_timeout
        self.max_concurrency = max_concurrency
        self.semaphore = asyncio.Semaphore(max_concurrency)

        # 共享 HTTP/HTTPS ClientSession
        self._http_connector = aiohttp.TCPConnector(
            ssl=False,
            limit=max_concurrency,
            limit_per_host=max_concurrency,
            force_close=False,
        )
        self._timeout = aiohttp.ClientTimeout(
            total=timeout, connect=connect_timeout
        )
        self._http_session = aiohttp.ClientSession(
            connector=self._http_connector,
            timeout=self._timeout,
        )

    def _get_test_url(self, protocol: str) -> str:
        """获取测试 URL"""
        urls = self.TEST_URLS.get(protocol.lower(), self.TEST_URLS["http"])
        return random.choice(urls)

    async def validate(self, ip: str, port: int, protocol: str = "http") -> Tuple[bool, float]:
        """验证单个代理，返回 (是否有效, 延迟毫秒)"""
        protocol = protocol.lower()
        
        async with self.semaphore:
            start = time.time()
            try:
                if protocol in ("socks4", "socks5"):
                    return await self._validate_socks(ip, port, protocol, start)
                else:
                    return await self._validate_http(ip, port, protocol, start)
            except asyncio.TimeoutError:
                logger.debug(f"Validation timeout: {ip}:{port} ({protocol})")
                return False, 0.0
            except Exception as e:
                logger.debug(f"Validation error {ip}:{port} ({protocol}): {e}")
                return False, 0.0

    async def _validate_http(self, ip: str, port: int, protocol: str, start: float) -> Tuple[bool, float]:
        """验证 HTTP/HTTPS 代理"""
        proxy_url = f"http://{ip}:{port}"
        test_url = self._get_test_url(protocol)

        async with self._http_session.get(test_url, proxy=proxy_url, allow_redirects=True) as response:
            if response.status in (200, 301, 302):
                latency = round((time.time() - start) * 1000, 2)
                logger.info(f"HTTP valid: {ip}:{port} ({protocol}) {latency}ms")
                return True, latency
            return False, 0.0

    async def _validate_socks(self, ip: str, port: int, protocol: str, start: float) -> Tuple[bool, float]:
        """验证 SOCKS4/SOCKS5 代理"""
        proxy_type = (
            aiohttp_socks.ProxyType.SOCKS4
            if protocol == "socks4"
            else aiohttp_socks.ProxyType.SOCKS5
        )
        connector = aiohttp_socks.ProxyConnector(
            proxy_type=proxy_type,
            host=ip,
            port=port,
            rdns=True,
            ssl=False,
        )
        timeout = aiohttp.ClientTimeout(total=self.timeout, connect=self.connect_timeout)
        test_url = self._get_test_url("http")

        try:
            async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
                async with session.get(test_url, allow_redirects=True) as response:
                    if response.status in (200, 301, 302):
                        latency = round((time.time() - start) * 1000, 2)
                        logger.info(f"SOCKS valid: {ip}:{port} ({protocol}) {latency}ms")
                        return True, latency
                    return False, 0.0
        finally:
            await connector.close()

    async def close(self):
        """关闭共享的 HTTP ClientSession"""
        await self._http_session.close()