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):
        """すべての製品に対する1回の完全なモニタリングサイクルを実行します。"""
        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"遭遇したCAPTCHA: {self.daily_stats['captchas']}, 解決: {self.daily_stats['solved']}")
            return results