import requests
from bs4 import BeautifulSoup
import time

CAPSOLVER_KEY = "your-api-key"

class EcommerceCaptchaHandler:
    def __init__(self):
        self.solve_count = 0
        self.session_solves = {}
    
    def detect_captcha(self, response):
        """检测响应是否包含CAPTCHA挑战。"""
        # 检查常见的CAPTCHA指示器
        if response.status_code == 403:
            return True
        if response.status_code == 503 and "challenge" in response.text.lower():
            return True
        
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # reCAPTCHA检测
        if soup.find('div', class_='g-recaptcha'):
            return True
        if 'recaptcha' in response.text.lower():
            return True
        
        # Cloudflare检测
        if soup.find('div', id='cf-challenge-running'):
            return True
        if 'cf-turnstile' in response.text:
            return True
        
        return False
    
    def extract_captcha_params(self, response, url):
        """从页面中提取站点密钥和CAPTCHA类型。"""
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # 尝试reCAPTCHA
        recaptcha_div = soup.find('div', class_='g-recaptcha')
        if recaptcha_div:
            site_key = recaptcha_div.get('data-sitekey', '')
            return {
                "type": "ReCaptchaV2TaskProxyLess",
                "websiteKey": site_key,
                "websiteURL": url
            }
        
        # 尝试Cloudflare Turnstile
        turnstile_div = soup.find('div', class_='cf-turnstile')
        if turnstile_div:
            site_key = turnstile_div.get('data-sitekey', '')
            return {
                "type": "AntiCloudflareTask",
                "websiteKey": site_key,
                "websiteURL": url
            }
        
        return None
    
    def solve(self, captcha_params):
        """将CAPTCHA发送到CapSolver并获取令牌。"""
        payload = {
            "clientKey": CAPSOLVER_KEY,
            "task": captcha_params
        }
        
        resp = requests.post("https://api.capsolver.com/createTask", json=payload)
        task_id = resp.json().get("taskId")
        
        if not task_id:
            raise Exception(f"无法创建任务: {resp.json()}")
        
        for _ in range(40):
            result = requests.post("https://api.capsolver.com/getTaskResult", json={
                "clientKey": CAPSOLVER_KEY,
                "taskId": task_id
            }).json()
            
            if result.get("status") == "ready":
                self.solve_count += 1
                return result["solution"]
            time.sleep(3)
        
        raise TimeoutError("CAPTCHA求解超时")

import asyncio
from typing import Optional, Dict

class PriceMonitor:
    def __init__(self, captcha_handler: EcommerceCaptchaHandler):
        self.handler = captcha_handler
        self.session = requests.Session()
        self.prices = {}
    
    def fetch_price(self, product_url: str, retry_count: int = 3) -> Optional[Dict]:
        """获取产品价格并自动处理CAPTCHA。"""
        for attempt in range(retry_count):
            response = self.session.get(product_url, headers={
                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
            })
            
            if self.handler.detect_captcha(response):
                # 检测到CAPTCHA - 解决它
                params = self.handler.extract_captcha_params(response, product_url)
                if params:
                    solution = self.handler.solve(params)
                    # 注入令牌并重试
                    token = solution.get("gRecaptchaResponse") or solution.get("token")
                    # 使用解决的令牌重新请求
                    response = self.submit_with_token(product_url, token)
            
            if response.status_code == 200 and not self.handler.detect_captcha(response):
                return self.extract_price(response)
            
            time.sleep(2 ** attempt)
        
        return None
    
    def extract_price(self, response) -> Dict:
        """从产品页面中提取价格数据。"""
        soup = BeautifulSoup(response.text, 'html.parser')
        # 实现因零售商而异
        price_elem = soup.find('span', class_='price')
        return {
            "price": price_elem.text if price_elem else None,
            "timestamp": time.time(),
            "available": True
        }

import asyncio
import aiohttp
from asyncio import Semaphore

class ScalablePriceMonitor:
    def __init__(self, max_concurrent_solves=15, max_concurrent_requests=50):
        self.solve_semaphore = Semaphore(max_concurrent_solves)
        self.request_semaphore = Semaphore(max_concurrent_requests)
        self.daily_stats = {"requests": 0, "captchas": 0, "solved": 0, "failed": 0}
    
    async def monitor_product(self, product_url, session):
        """以速率限制监控单个产品。"""
        async with self.request_semaphore:
            response = await session.get(product_url)
            
            if self.is_captcha(await response.text()):
                self.daily_stats["captchas"] += 1
                async with self.solve_semaphore:
                    token = await self.async_solve_captcha(product_url, await response.text())
                    if token:
                        self.daily_stats["solved"] += 1
                        return await self.retry_with_token(product_url, token, session)
                    else:
                        self.daily_stats["failed"] += 1
                        return None
            
            self.daily_stats["requests"] += 1
            return await self.parse_price(await response.text())
    
    async def run_monitoring_cycle(self, product_urls):
        """运行所有产品的完整监控周期。"""
        async with aiohttp.ClientSession() as session:
            tasks = [self.monitor_product(url, session) for url in product_urls]
            results = await asyncio.gather(*tasks, return_exceptions=True)
            
            success_count = sum(1 for r in results if r and not isinstance(r, Exception))
            print(f"周期完成: {success_count}/{len(product_urls)} 个价格已收集")
            print(f"遇到的CAPTCHAs: {self.daily_stats['captchas']}, "
                  f"已解决: {self.daily_stats['solved']}")
            return results