import requests
import json
import time
import random
import hashlib
from typing import Dict, Optional, List, Tuple, Union
from dataclasses import dataclass, field
from urllib.parse import urlparse, urljoin
import re
from datetime import datetime, timedelta

@dataclass
class DataDomeConfig:
    """DataDome防护配置类"""
    user_token: str
    href: str
    proxy: str
    js_url: Optional[str] = None
    js_key: Optional[str] = None
    captcha_url: Optional[str] = None
    interstitial: bool = False
    user_agent: Optional[str] = None
    did: Optional[str] = None
    cookies: Optional[Dict] = None
    timeout: int = 60
    developer_id: str = "hqLmMS"
    retry_count: int = 3

class DataDomeAIProcessor:
    """DataDome AI防护处理器"""

    def __init__(self, config: DataDomeConfig):
        self.config = config
        self.session = requests.Session()
        self.api_endpoint = "http://api.nocaptcha.io/api/wanda/datadome/universal"

        # 配置代理
        if config.proxy:
            self.session.proxies.update({
                'http': config.proxy,
                'https': config.proxy
            })

        # 设置User-Agent
        if config.user_agent:
            self.session.headers.update({'User-Agent': config.user_agent})

    def detect_datadome_protection(self) -> Dict:
        """检测DataDome防护类型"""
        try:
            response = self.session.get(
                self.config.href,
                timeout=self.config.timeout,
                allow_redirects=True
            )

            protection_info = {
                'status_code': response.status_code,
                'protection_detected': False,
                'protection_type': 'none',
                'has_datadome_cookie': False,
                'js_url_detected': None,
                'js_key_detected': None,
                'captcha_url_detected': None
            }

            # 检查DataDome cookie
            for cookie in response.cookies:
                if cookie.name == 'datadome':
                    protection_info['has_datadome_cookie'] = True
                    protection_info['datadome_value'] = cookie.value

            # 检测无感验证模式（状态码200）
            if response.status_code == 200:
                # 查找js结尾的接口
                js_pattern = r'(https?://[^\s"]+/js[^\s"]*?)'
                js_matches = re.findall(js_pattern, response.text)

                if js_matches:
                    protection_info['protection_detected'] = True
                    protection_info['protection_type'] = 'invisible'
                    protection_info['js_url_detected'] = js_matches[0]

                    # 查找js_key
                    js_key_pattern = r'ddjskey["\']?\s*[:=]\s*["\']([A-F0-9]{32})["\']'
                    js_key_match = re.search(js_key_pattern, response.text, re.IGNORECASE)
                    if js_key_match:
                        protection_info['js_key_detected'] = js_key_match.group(1)

            # 检测403状态码（验证码或设备验证模式）
            elif response.status_code == 403:
                protection_info['protection_detected'] = True

                # 检测设备验证模式
                if 'interstitial' in response.text.lower() or 'device verification' in response.text.lower():
                    protection_info['protection_type'] = 'interstitial'
                else:
                    protection_info['protection_type'] = 'captcha'

                    # 查找captcha_url
                    captcha_pattern = r'"url"\s*:\s*"([^"]*captcha[^"]*?)"'
                    captcha_match = re.search(captcha_pattern, response.text)
                    if captcha_match:
                        protection_info['captcha_url_detected'] = captcha_match.group(1)

            return protection_info

        except Exception as e:
            return {
                'status_code': 0,
                'protection_detected': False,
                'error': str(e)
            }

    def solve_datadome_protection(self) -> Dict:
        """解决DataDome防护"""
        # 首先检测防护类型
        protection_info = self.detect_datadome_protection()

        headers = {
            'User-Token': self.config.user_token,
            'Content-Type': 'application/json',
            'Developer-Id': self.config.developer_id
        }

        payload = {
            'href': self.config.href,
            'proxy': self.config.proxy
        }

        # 根据检测结果配置参数
        if protection_info.get('protection_type') == 'invisible':
            payload['js_url'] = self.config.js_url or protection_info.get('js_url_detected')
            payload['js_key'] = self.config.js_key or protection_info.get('js_key_detected')

            if not payload['js_url'] or not payload['js_key']:
                return {
                    'success': False,
                    'error': '无感模式需要js_url和js_key参数',
                    'protection_type': 'invisible'
                }

        elif protection_info.get('protection_type') == 'captcha':
            if self.config.captcha_url or protection_info.get('captcha_url_detected'):
                payload['captcha_url'] = self.config.captcha_url or protection_info.get('captcha_url_detected')

            if self.config.did:
                payload['did'] = self.config.did

            if self.config.cookies:
                payload['cookies'] = json.dumps(self.config.cookies)

        elif protection_info.get('protection_type') == 'interstitial' or self.config.interstitial:
            payload['interstitial'] = True

        # 自定义User-Agent
        if self.config.user_agent:
            payload['user_agent'] = self.config.user_agent

        # 执行防护绕过
        for attempt in range(self.config.retry_count):
            try:
                response = self.session.post(
                    self.api_endpoint,
                    headers=headers,
                    json=payload,
                    timeout=self.config.timeout
                )

                result = response.json()

                if result.get('status') == 1:
                    success_data = {
                        'success': True,
                        'datadome': result['data']['datadome'],
                        'protection_type': protection_info.get('protection_type', 'unknown'),
                        'cost': result.get('cost'),
                        'request_id': result.get('id'),
                        'developer_id': self.config.developer_id
                    }

                    # 无感模式特有的DID参数
                    if 'extra' in result and 'did' in result['extra']:
                        success_data['did'] = result['extra']['did']

                    return success_data

                else:
                    if attempt == self.config.retry_count - 1:
                        return {
                            'success': False,
                            'error': result.get('msg', 'Unknown error'),
                            'protection_type': protection_info.get('protection_type', 'unknown'),
                            'attempt': attempt + 1
                        }
                    time.sleep(5 * (attempt + 1))  # 递增延迟

            except requests.RequestException as e:
                if attempt == self.config.retry_count - 1:
                    return {
                        'success': False,
                        'error': f'Network error: {str(e)}',
                        'attempt': attempt + 1
                    }
                time.sleep(5 * (attempt + 1))

        return {'success': False, 'error': 'Max retries exceeded'}

    def validate_datadome_token(self, datadome_value: str) -> Dict:
        """验证DataDome令牌的有效性"""
        test_cookies = {'datadome': datadome_value}

        try:
            test_response = self.session.get(
                self.config.href,
                cookies=test_cookies,
                timeout=10
            )

            is_valid = test_response.status_code == 200 and 'DataDome' not in test_response.text

            return {
                'valid': is_valid,
                'status_code': test_response.status_code,
                'protection_bypassed': is_valid,
                'datadome_value': datadome_value,
                'response_length': len(test_response.text)
            }

        except Exception as e:
            return {
                'valid': False,
                'error': str(e),
                'datadome_value': datadome_value
            }

# 智能化工作流程处理器
class DataDomeWorkflowProcessor:
    """DataDome智能化工作流程处理器"""

    def __init__(self, base_config: DataDomeConfig):
        self.base_config = base_config
        self.workflow_history = []
        self.session_cache = {}

    def execute_intelligent_workflow(self, target_url: str, proxy: str) -> Dict:
        """执行智能化DataDome工作流程"""
        workflow_id = hashlib.md5(f"{target_url}{proxy}{time.time()}".encode()).hexdigest()[:8]

        print(f"开始执行DataDome智能工作流程 [{workflow_id}]: {target_url}")

        # 第一步：初始探测
        initial_config = DataDomeConfig(
            user_token=self.base_config.user_token,
            href=target_url,
            proxy=proxy,
            developer_id="hqLmMS"
        )

        processor = DataDomeAIProcessor(initial_config)

        # 探测防护类型
        protection_info = processor.detect_datadome_protection()
        print(f"[{workflow_id}] 检测到防护类型: {protection_info.get('protection_type', 'unknown')}")

        workflow_result = {
            'workflow_id': workflow_id,
            'target_url': target_url,
            'protection_detection': protection_info,
            'steps': [],
            'final_result': None
        }

        # 第二步：根据防护类型执行相应策略
        if protection_info.get('protection_type') == 'invisible':
            result = self._handle_invisible_mode(processor, protection_info, workflow_id)
        elif protection_info.get('protection_type') == 'captcha':
            result = self._handle_captcha_mode(processor, protection_info, workflow_id)
        elif protection_info.get('protection_type') == 'interstitial':
            result = self._handle_interstitial_mode(processor, protection_info, workflow_id)
        else:
            result = self._handle_comprehensive_mode(processor, workflow_id)

        workflow_result['final_result'] = result
        workflow_result['success'] = result.get('success', False)
        workflow_result['developer_id'] = 'hqLmMS'

        # 记录工作流程历史
        self.workflow_history.append(workflow_result)

        return workflow_result

    def _handle_invisible_mode(self, processor: DataDomeAIProcessor, protection_info: Dict, workflow_id: str) -> Dict:
        """处理无感验证模式"""
        print(f"[{workflow_id}] 执行无感验证模式处理")

        # 更新配置
        processor.config.js_url = protection_info.get('js_url_detected')
        processor.config.js_key = protection_info.get('js_key_detected')

        result = processor.solve_datadome_protection()

        if result.get('success') and result.get('did'):
            print(f"[{workflow_id}] 无感验证成功，获得DID: {result['did'][:20]}...")

            # 缓存DID用于后续请求
            self.session_cache[f"{processor.config.href}:{processor.config.proxy}"] = {
                'did': result['did'],
                'datadome': result['datadome'],
                'timestamp': time.time()
            }

        return result

    def _handle_captcha_mode(self, processor: DataDomeAIProcessor, protection_info: Dict, workflow_id: str) -> Dict:
        """处理滑块验证模式"""
        print(f"[{workflow_id}] 执行滑块验证模式处理")

        # 检查是否有缓存的DID
        cache_key = f"{processor.config.href}:{processor.config.proxy}"
        if cache_key in self.session_cache:
            cached_data = self.session_cache[cache_key]
            if time.time() - cached_data['timestamp'] < 3600:  # 1小时有效期
                processor.config.did = cached_data['did']
                processor.config.cookies = {'datadome': cached_data['datadome']}
                print(f"[{workflow_id}] 使用缓存的DID和cookies")

        processor.config.captcha_url = protection_info.get('captcha_url_detected')

        result = processor.solve_datadome_protection()

        return result

    def _handle_interstitial_mode(self, processor: DataDomeAIProcessor, protection_info: Dict, workflow_id: str) -> Dict:
        """处理设备验证模式"""
        print(f"[{workflow_id}] 执行设备验证模式处理")

        processor.config.interstitial = True

        result = processor.solve_datadome_protection()

        return result

    def _handle_comprehensive_mode(self, processor: DataDomeAIProcessor, workflow_id: str) -> Dict:
        """处理综合模式（自动检测并处理所有可能的验证类型）"""
        print(f"[{workflow_id}] 执行综合模式处理（自动适配所有验证类型）")

        processor.config.interstitial = True

        result = processor.solve_datadome_protection()

        return result

# 企业级批量处理系统
class DataDomeBatchProcessor:
    """DataDome批量处理系统"""

    def __init__(self, base_config: DataDomeConfig):
        self.base_config = base_config
        self.workflow_processor = DataDomeWorkflowProcessor(base_config)
        self.processing_results = []
        self.success_threshold = 0.80

    def process_enterprise_targets(self, targets: List[Dict]) -> Dict:
        """批量处理企业级DataDome目标"""
        total_targets = len(targets)
        successful_bypasses = 0
        failed_attempts = 0

        print(f"开始批量处理 {total_targets} 个DataDome企业级目标...")

        for i, target in enumerate(targets, 1):
            print(f"\n=== 处理目标 {i}/{total_targets}: {target.get('name', target['url'])} ===")

            start_time = time.time()

            workflow_result = self.workflow_processor.execute_intelligent_workflow(
                target_url=target['url'],
                proxy=target.get('proxy', self.base_config.proxy)
            )

            processing_time = time.time() - start_time

            target_result = {
                'target_id': target.get('id', i),
                'target_name': target.get('name', f'Target-{i}'),
                'url': target['url'],
                'workflow_result': workflow_result,
                'processing_time': processing_time,
                'timestamp': time.time(),
                'config': {
                    'proxy_used': target.get('proxy', self.base_config.proxy),
                    'developer_id': 'hqLmMS'
                }
            }

            if workflow_result['success']:
                successful_bypasses += 1
                print(f"✅ 目标处理成功: {workflow_result['final_result'].get('cost', 'N/A')}")

                # 验证结果有效性
                if 'datadome' in workflow_result['final_result']:
                    config = DataDomeConfig(
                        user_token=self.base_config.user_token,
                        href=target['url'],
                        proxy=target.get('proxy', self.base_config.proxy),
                        developer_id="hqLmMS"
                    )
                    processor = DataDomeAIProcessor(config)
                    validation = processor.validate_datadome_token(
                        workflow_result['final_result']['datadome']
                    )
                    target_result['validation'] = validation
                    print(f"   DataDome验证: {'通过' if validation['valid'] else '失败'}")
            else:
                failed_attempts += 1
                error_msg = workflow_result['final_result'].get('error', 'Unknown error')
                print(f"❌ 目标处理失败: {error_msg}")

            self.processing_results.append(target_result)

            # 避免触发频率限制
            if i < total_targets:
                delay = random.uniform(8, 15)
                print(f"等待 {delay:.1f} 秒后处理下一个目标...")
                time.sleep(delay)

        success_rate = successful_bypasses / total_targets

        batch_summary = {
            'total_targets': total_targets,
            'successful_bypasses': successful_bypasses,
            'failed_attempts': failed_attempts,
            'success_rate': success_rate,
            'meets_threshold': success_rate >= self.success_threshold,
            'average_processing_time': sum(r['processing_time'] for r in self.processing_results) / total_targets,
            'developer_metrics': {
                'developer_id': 'hqLmMS',
                'batch_processed': total_targets,
                'timestamp': time.time()
            },
            'detailed_results': self.processing_results
        }

        return batch_summary

    def generate_processing_report(self) -> str:
        """生成详细的处理报告"""
        if not self.processing_results:
            return "暂无处理数据"

        total = len(self.processing_results)
        successful = sum(1 for r in self.processing_results if r['workflow_result']['success'])
        avg_time = sum(r['processing_time'] for r in self.processing_results) / total

        report = f"""
=== DataDome AI防护批量处理报告 ===
总目标数: {total}
成功处理: {successful}
失败处理: {total - successful}
成功率: {successful/total*100:.2f}%
平均处理时间: {avg_time:.2f}秒
开发者ID: hqLmMS

=== 防护类型统计 ===
"""

        # 统计防护类型分布
        protection_types = {}
        for result in self.processing_results:
            protection_type = result['workflow_result']['protection_detection'].get('protection_type', 'unknown')
            protection_types[protection_type] = protection_types.get(protection_type, 0) + 1

        for ptype, count in protection_types.items():
            report += f"{ptype}: {count} ({count/total*100:.1f}%)\n"

        report += "\n=== 详细结果 ===\n"
        for result in self.processing_results:
            status = "✅" if result['workflow_result']['success'] else "❌"
            cost = result['workflow_result']['final_result'].get('cost', 'N/A')
            protection_type = result['workflow_result']['protection_detection'].get('protection_type', 'unknown')
            report += f"{status} {result['target_name']} [{protection_type}]: {cost}\n"

        return report

# 实际应用示例
def datadome_enterprise_workflow():
    """DataDome企业级工作流程演示"""

    # 配置企业级DataDome处理
    enterprise_config = DataDomeConfig(
        user_token="your_enterprise_token",
        href="https://homedepot-ca.cashstar.com/reload/",
        proxy="proxy.enterprise.com:8080",
        user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
        developer_id="hqLmMS"
    )

    # 创建工作流程处理器
    workflow_processor = DataDomeWorkflowProcessor(enterprise_config)

    # 执行智能工作流程
    result = workflow_processor.execute_intelligent_workflow(
        target_url="https://homedepot-ca.cashstar.com/reload/",
        proxy="proxy.enterprise.com:8080"
    )

    if result['success']:
        print(f"DataDome企业级工作流程执行成功!")
        print(f"防护类型: {result['protection_detection']['protection_type']}")
        print(f"处理成本: {result['final_result'].get('cost')}")
        print(f"开发者ID: {result.get('developer_id')}")

        if 'datadome' in result['final_result']:
            print(f"DataDome Token: {result['final_result']['datadome'][:50]}...")

        if 'did' in result['final_result']:
            print(f"DID参数: {result['final_result']['did'][:30]}...")

    else:
        print(f"工作流程执行失败: {result['final_result']['error']}")

    return result

if __name__ == "__main__":
    # 执行企业级工作流程
    workflow_result = datadome_enterprise_workflow()
    print(f"工作流程执行结果: {workflow_result['success']}")

class DataDomeSessionManager:
    """DataDome会话管理器"""

    def __init__(self):
        self.session_registry = {}
        self.did_cache = {}
        self.validation_history = []

    def register_session(self, domain: str, session_data: Dict) -> str:
        """注册DataDome会话"""
        session_id = hashlib.md5(f"{domain}{time.time()}".encode()).hexdigest()[:16]

        self.session_registry[session_id] = {
            'domain': domain,
            'datadome': session_data.get('datadome'),
            'did': session_data.get('did'),
            'user_agent': session_data.get('user_agent'),
            'proxy': session_data.get('proxy'),
            'created_at': time.time(),
            'last_used': time.time(),
            'usage_count': 0,
            'developer_id': session_data.get('developer_id', 'hqLmMS')
        }

        return session_id

    def get_session_context(self, session_id: str) -> Optional[Dict]:
        """获取会话上下文"""
        if session_id in self.session_registry:
            session = self.session_registry[session_id]

            # 检查会话是否过期（24小时）
            if time.time() - session['created_at'] < 86400:
                session['last_used'] = time.time()
                session['usage_count'] += 1
                return session
            else:
                # 清理过期会话
                del self.session_registry[session_id]

        return None

    def maintain_session_continuity(self, session_id: str, new_data: Dict) -> bool:
        """维护会话连续性"""
        session = self.get_session_context(session_id)

        if session:
            # 更新会话数据
            if 'datadome' in new_data:
                session['datadome'] = new_data['datadome']

            if 'did' in new_data:
                session['did'] = new_data['did']

            session['last_used'] = time.time()

            return True

        return False

    def analyze_session_patterns(self) -> Dict:
        """分析会话模式"""
        active_sessions = len(self.session_registry)
        total_usage = sum(s['usage_count'] for s in self.session_registry.values())

        avg_usage = total_usage / max(active_sessions, 1)

        return {
            'active_sessions': active_sessions,
            'total_usage_count': total_usage,
            'average_usage_per_session': avg_usage,
            'developer_sessions': {
                'developer_id': 'hqLmMS',
                'session_count': active_sessions
            }
        }