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


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

    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.semaphore = asyncio.Semaphore(max_concurrency)
        self.http_sources = [
            "http://httpbin.org/ip",
            "http://api.ipify.org",
        ]
        self.https_sources = [
            "https://httpbin.org/ip",
            "https://api.ipify.org",
        ]

    def _get_test_url(self, protocol: str) -> str:
        protocol = protocol.lower()
        if protocol == "https":
            return random.choice(self.https_sources)
        return random.choice(self.http_sources)

    async def validate(self, ip: str, port: int, protocol: str = "http") -> Tuple[bool, float]:
        """验证单个代理，返回 (是否有效, 延迟毫秒)"""
        protocol = protocol.lower()
        test_url = self._get_test_url(protocol)

        async with self.semaphore:
            start = time.time()
            try:
                if protocol in ("socks4", "socks5"):
                    return await self._validate_socks(ip, port, protocol, test_url, start)
                else:
                    return await self._validate_http(ip, port, protocol, test_url, 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, test_url: str, start: float
    ) -> Tuple[bool, float]:
        proxy_url = f"http://{ip}:{port}"
        connector = aiohttp.TCPConnector(ssl=False, limit=0, force_close=True)
        timeout = aiohttp.ClientTimeout(total=self.timeout, connect=self.connect_timeout)

        try:
            async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
                async with 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
        finally:
            await connector.close()

    async def _validate_socks(
        self, ip: str, port: int, protocol: str, test_url: str, start: float
    ) -> Tuple[bool, float]:
        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)

        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()