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

@dataclass
class AkamaiConfig:
    """Akamai Bot Manager配置类"""
    user_token: str
    target_url: str
    user_agent: Optional[str] = None
    proxy: Optional[str] = None
    headers: Optional[Dict] = None
    cookies: Optional[Dict] = None
    challenge_type: str = "detection"  # detection, challenge, block
    timeout: int = 45
    developer_id: str = "hqLmMS"
    retry_count: int = 3
    session_persistence: bool = True

class AkamaiBotManagerProcessor:
    """Akamai Bot Manager处理器"""

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

        # 设置会话持久化
        if config.session_persistence:
            self.session.headers.update({
                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
                'Accept-Language': 'en-US,en;q=0.5',
                'Accept-Encoding': 'gzip, deflate, br',
                'DNT': '1',
                'Connection': 'keep-alive',
                'Upgrade-Insecure-Requests': '1',
                'Sec-Fetch-Dest': 'document',
                'Sec-Fetch-Mode': 'navigate',
                'Sec-Fetch-Site': 'none',
                'Cache-Control': 'max-age=0'
            })

        # 配置代理
        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})

        # 应用自定义headers
        if config.headers:
            self.session.headers.update(config.headers)

        # 设置cookies
        if config.cookies:
            self.session.cookies.update(config.cookies)

    def detect_akamai_protection(self) -> Dict:
        """检测Akamai Bot Manager防护"""
        try:
            response = self.session.get(
                self.config.target_url,
                timeout=self.config.timeout,
                allow_redirects=True
            )

            protection_info = {
                'status_code': response.status_code,
                'akamai_detected': False,
                'protection_type': 'none',
                'challenge_detected': False,
                'reference_id': None,
                'bot_manager_active': False,
                'response_headers': dict(response.headers),
                'content_length': len(response.content)
            }

            # 检测Akamai特征headers
            akamai_headers = [
                'akamai-reference-id',
                'akamai-request-id', 
                'akamai-ghost-ip',
                'akamai-edgescape',
                'x-akamai-transformed'
            ]

            for header in akamai_headers:
                if header.lower() in [h.lower() for h in response.headers.keys()]:
                    protection_info['akamai_detected'] = True
                    if header.lower() == 'akamai-reference-id':
                        protection_info['reference_id'] = response.headers.get(header)

            # 检测Bot Manager特征
            bot_manager_indicators = [
                'bot manager',
                'akamai bot',
                'reference #',
                'access denied',
                'request blocked'
            ]

            response_text_lower = response.text.lower()
            for indicator in bot_manager_indicators:
                if indicator in response_text_lower:
                    protection_info['bot_manager_active'] = True
                    protection_info['akamai_detected'] = True

                    # 确定防护类型
                    if response.status_code == 403:
                        protection_info['protection_type'] = 'block'
                    elif 'challenge' in response_text_lower or 'verification' in response_text_lower:
                        protection_info['protection_type'] = 'challenge'
                        protection_info['challenge_detected'] = True
                    else:
                        protection_info['protection_type'] = 'detection'

            # 检测JavaScript挑战
            if '<script' in response.text and 'akamai' in response_text_lower:
                protection_info['challenge_detected'] = True
                if not protection_info['protection_type'] or protection_info['protection_type'] == 'none':
                    protection_info['protection_type'] = 'js_challenge'

            # 提取Reference ID
            if not protection_info['reference_id']:
                ref_pattern = r'Reference\s*#?\s*([A-Fa-f0-9.-]+)'
                ref_match = re.search(ref_pattern, response.text)
                if ref_match:
                    protection_info['reference_id'] = ref_match.group(1)

            return protection_info

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

    def solve_akamai_protection(self) -> Dict:
        """解决Akamai Bot Manager防护"""
        # 首先检测防护类型
        protection_info = self.detect_akamai_protection()

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

        payload = {
            'target_url': self.config.target_url,
            'challenge_type': self.config.challenge_type,
            'developer_id': self.config.developer_id
        }

        # 根据检测结果配置参数
        if protection_info.get('akamai_detected'):
            payload['akamai_detected'] = True
            payload['protection_type'] = protection_info.get('protection_type', 'detection')

            if protection_info.get('reference_id'):
                payload['reference_id'] = protection_info['reference_id']

        # 代理配置
        if self.config.proxy:
            payload['proxy'] = self.config.proxy

        # User-Agent配置
        if self.config.user_agent:
            payload['user_agent'] = self.config.user_agent

        # Headers配置
        if self.config.headers:
            payload['custom_headers'] = self.config.headers

        # Cookies配置
        if self.config.cookies:
            payload['cookies'] = json.dumps(self.config.cookies)

        # 执行Akamai防护绕过
        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,
                        'protection_bypassed': True,
                        'protection_info': protection_info,
                        'cost': result.get('cost'),
                        'request_id': result.get('id'),
                        'developer_id': self.config.developer_id
                    }

                    # 处理返回的数据
                    if 'data' in result:
                        data = result['data']

                        if 'cookies' in data:
                            success_data['bypass_cookies'] = data['cookies']

                        if 'headers' in data:
                            success_data['bypass_headers'] = data['headers']

                        if 'session_token' in data:
                            success_data['session_token'] = data['session_token']

                        if 'user_agent' in data:
                            success_data['recommended_user_agent'] = data['user_agent']

                    return success_data

                else:
                    if attempt == self.config.retry_count - 1:
                        return {
                            'success': False,
                            'error': result.get('msg', 'Unknown error'),
                            'protection_info': protection_info,
                            '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_bypass_result(self, bypass_data: Dict) -> Dict:
        """验证绕过结果的有效性"""
        if not bypass_data.get('success'):
            return {
                'valid': False,
                'error': 'Bypass was not successful'
            }

        # 使用绕过数据进行测试请求
        test_session = requests.Session()

        # 应用绕过结果
        if 'bypass_cookies' in bypass_data:
            test_session.cookies.update(bypass_data['bypass_cookies'])

        if 'bypass_headers' in bypass_data:
            test_session.headers.update(bypass_data['bypass_headers'])

        if 'recommended_user_agent' in bypass_data:
            test_session.headers.update({'User-Agent': bypass_data['recommended_user_agent']})

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

        try:
            test_response = test_session.get(
                self.config.target_url,
                timeout=15
            )

            # 检查是否仍然被Akamai阻止
            is_blocked = (
                test_response.status_code == 403 or
                'access denied' in test_response.text.lower() or
                'bot manager' in test_response.text.lower()
            )

            validation_result = {
                'valid': not is_blocked,
                'status_code': test_response.status_code,
                'content_length': len(test_response.content),
                'akamai_bypass_successful': not is_blocked,
                'response_time': test_response.elapsed.total_seconds()
            }

            if is_blocked:
                validation_result['error'] = 'Still blocked by Akamai Bot Manager'

            return validation_result

        except Exception as e:
            return {
                'valid': False,
                'error': f'Validation test failed: {str(e)}'
            }

# 企业级会话管理系统
class AkamaiSessionManager:
    """Akamai会话管理系统"""

    def __init__(self):
        self.active_sessions = {}
        self.session_pool = []
        self.rotation_interval = 300  # 5分钟轮换
        self.max_sessions_per_proxy = 5

    def create_managed_session(self, config: AkamaiConfig, session_id: Optional[str] = None) -> str:
        """创建托管会话"""
        if not session_id:
            session_id = hashlib.md5(
                f"{config.target_url}{config.proxy}{time.time()}".encode()
            ).hexdigest()[:16]

        processor = AkamaiBotManagerProcessor(config)

        session_data = {
            'session_id': session_id,
            'processor': processor,
            'config': config,
            'created_at': time.time(),
            'last_used': time.time(),
            'request_count': 0,
            'bypass_data': None,
            'is_active': True,
            'developer_id': config.developer_id
        }

        self.active_sessions[session_id] = session_data

        return session_id

    def get_session_processor(self, session_id: str) -> Optional[AkamaiBotManagerProcessor]:
        """获取会话处理器"""
        if session_id in self.active_sessions:
            session = self.active_sessions[session_id]
            session['last_used'] = time.time()
            session['request_count'] += 1

            return session['processor']

        return None

    def execute_with_session(self, session_id: str, target_url: Optional[str] = None) -> Dict:
        """使用指定会话执行请求"""
        processor = self.get_session_processor(session_id)

        if not processor:
            return {
                'success': False,
                'error': f'Session {session_id} not found'
            }

        session_data = self.active_sessions[session_id]

        # 更新目标URL（如果提供）
        if target_url:
            processor.config.target_url = target_url

        # 如果还没有绕过数据，先执行绕过
        if not session_data['bypass_data']:
            bypass_result = processor.solve_akamai_protection()

            if bypass_result['success']:
                session_data['bypass_data'] = bypass_result
            else:
                return bypass_result

        # 使用绕过数据执行请求
        try:
            # 应用绕过配置
            bypass_data = session_data['bypass_data']

            if 'bypass_cookies' in bypass_data:
                processor.session.cookies.update(bypass_data['bypass_cookies'])

            if 'bypass_headers' in bypass_data:
                processor.session.headers.update(bypass_data['bypass_headers'])

            response = processor.session.get(
                processor.config.target_url,
                timeout=processor.config.timeout
            )

            return {
                'success': True,
                'status_code': response.status_code,
                'content_length': len(response.content),
                'headers': dict(response.headers),
                'session_id': session_id,
                'request_count': session_data['request_count'],
                'developer_id': session_data['developer_id']
            }

        except Exception as e:
            return {
                'success': False,
                'error': f'Request execution failed: {str(e)}',
                'session_id': session_id
            }

    def cleanup_expired_sessions(self):
        """清理过期会话"""
        current_time = time.time()
        expired_sessions = []

        for session_id, session_data in self.active_sessions.items():
            # 清理超过1小时未使用的会话
            if current_time - session_data['last_used'] > 3600:
                expired_sessions.append(session_id)

        for session_id in expired_sessions:
            del self.active_sessions[session_id]

        return len(expired_sessions)

    def get_session_statistics(self) -> Dict:
        """获取会话统计信息"""
        total_sessions = len(self.active_sessions)
        total_requests = sum(s['request_count'] for s in self.active_sessions.values())

        active_sessions = sum(
            1 for s in self.active_sessions.values() 
            if time.time() - s['last_used'] < 300
        )

        return {
            'total_sessions': total_sessions,
            'active_sessions': active_sessions,
            'total_requests': total_requests,
            'average_requests_per_session': total_requests / max(total_sessions, 1),
            'developer_sessions': {
                'developer_id': 'hqLmMS',
                'session_count': total_sessions
            }
        }

# 智能流量模拟器
class AkamaiTrafficSimulator:
    """Akamai流量模拟器"""

    def __init__(self, session_manager: AkamaiSessionManager):
        self.session_manager = session_manager
        self.human_behavior_patterns = {
            'page_view_time': (2, 30),  # 2-30秒
            'scroll_intervals': (0.5, 3),  # 0.5-3秒
            'click_delay': (0.1, 2),  # 0.1-2秒
            'typing_speed': (50, 150),  # 50-150ms per character
        }

    def simulate_human_browsing(self, session_id: str, target_urls: List[str]) -> Dict:
        """模拟人类浏览行为"""
        simulation_results = []

        for i, url in enumerate(target_urls):
            print(f"模拟访问页面 {i+1}/{len(target_urls)}: {url}")

            # 模拟页面加载前的思考时间
            if i > 0:
                think_time = random.uniform(1, 5)
                print(f"  思考时间: {think_time:.1f}秒")
                time.sleep(think_time)

            # 执行页面访问
            start_time = time.time()
            result = self.session_manager.execute_with_session(session_id, url)
            response_time = time.time() - start_time

            # 模拟页面浏览时间
            view_time = random.uniform(*self.human_behavior_patterns['page_view_time'])
            print(f"  浏览时间: {view_time:.1f}秒")

            simulation_result = {
                'url': url,
                'response_time': response_time,
                'view_time': view_time,
                'result': result,
                'timestamp': time.time()
            }

            simulation_results.append(simulation_result)

            # 如果不是最后一个页面，进行浏览时间等待
            if i < len(target_urls) - 1:
                time.sleep(view_time)

        return {
            'session_id': session_id,
            'total_pages': len(target_urls),
            'successful_pages': sum(1 for r in simulation_results if r['result']['success']),
            'total_time': sum(r['view_time'] for r in simulation_results),
            'average_response_time': sum(r['response_time'] for r in simulation_results) / len(simulation_results),
            'simulation_results': simulation_results,
            'developer_id': 'hqLmMS'
        }

    def generate_realistic_user_agent(self) -> str:
        """生成真实的User-Agent"""
        chrome_versions = ['91.0.4472.124', '92.0.4515.107', '93.0.4577.63', '94.0.4606.61']
        windows_versions = ['Windows NT 10.0; Win64; x64', 'Windows NT 10.0; WOW64']

        chrome_version = random.choice(chrome_versions)
        windows_version = random.choice(windows_versions)

        return f'Mozilla/5.0 ({windows_version}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{chrome_version} Safari/537.36'

    def create_human_like_headers(self) -> Dict[str, str]:
        """创建类似人类的HTTP headers"""
        return {
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
            'Accept-Language': 'en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7',
            'Accept-Encoding': 'gzip, deflate, br',
            'DNT': '1',
            'Connection': 'keep-alive',
            'Upgrade-Insecure-Requests': '1',
            'Sec-Fetch-Dest': 'document',
            'Sec-Fetch-Mode': 'navigate',
            'Sec-Fetch-Site': 'none',
            'Sec-Fetch-User': '?1',
            'Cache-Control': 'max-age=0'
        }

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

    # 配置Akamai Bot Manager处理
    akamai_config = AkamaiConfig(
        user_token="your_enterprise_token",
        target_url="https://www.example-protected-site.com",
        proxy="proxy.enterprise.com:8080",
        user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
        challenge_type="detection",
        developer_id="hqLmMS"
    )

    # 创建会话管理器
    session_manager = AkamaiSessionManager()

    # 创建托管会话
    session_id = session_manager.create_managed_session(akamai_config)
    print(f"创建会话: {session_id}")

    # 创建流量模拟器
    traffic_simulator = AkamaiTrafficSimulator(session_manager)

    # 模拟多页面浏览
    target_pages = [
        "https://www.example-protected-site.com/",
        "https://www.example-protected-site.com/products",
        "https://www.example-protected-site.com/about",
        "https://www.example-protected-site.com/contact"
    ]

    # 执行智能浏览模拟
    simulation_result = traffic_simulator.simulate_human_browsing(session_id, target_pages)

    if simulation_result['successful_pages'] > 0:
        print(f"Akamai Bot Manager绕过成功!")
        print(f"成功访问页面: {simulation_result['successful_pages']}/{simulation_result['total_pages']}")
        print(f"总浏览时间: {simulation_result['total_time']:.1f}秒")
        print(f"平均响应时间: {simulation_result['average_response_time']:.2f}秒")
        print(f"会话ID: {session_id}")
        print(f"开发者ID: {simulation_result.get('developer_id')}")
    else:
        print(f"Akamai Bot Manager绕过失败")
        print(f"模拟结果: {simulation_result}")

    # 获取会话统计
    stats = session_manager.get_session_statistics()
    print(f"\n会话统计: {stats}")

    return simulation_result

if __name__ == "__main__":
    # 执行企业级工作流程
    workflow_result = akamai_enterprise_workflow()
    print(f"\n工作流程执行结果: {workflow_result['successful_pages'] > 0}")

class AkamaiThreatIntelligence:
    """Akamai威胁情报分析器"""

    def __init__(self):
        self.threat_patterns = {
            'bot_signatures': {
                'request_frequency': {
                    'human_range': (0.5, 10.0),  # 秒
                    'bot_indicators': ['<0.1', '>60', 'fixed_interval']
                },
                'user_agent_patterns': {
                    'suspicious_indicators': [
                        'python-requests',
                        'curl/',
                        'wget',
                        'scrapy',
                        'missing_version_info'
                    ]
                },
                'behavioral_anomalies': {
                    'no_javascript_execution': 'high_risk',
                    'missing_browser_headers': 'medium_risk',
                    'linear_navigation_pattern': 'high_risk',
                    'no_mouse_movements': 'critical_risk'
                }
            }
        }

    def analyze_traffic_pattern(self, request_history: List[Dict]) -> Dict:
        """分析流量模式"""
        if len(request_history) < 2:
            return {'risk_level': 'insufficient_data'}

        analysis_result = {
            'total_requests': len(request_history),
            'time_span': request_history[-1]['timestamp'] - request_history[0]['timestamp'],
            'risk_indicators': [],
            'risk_score': 0.0,
            'threat_classification': 'unknown'
        }

        # 分析请求间隔
        intervals = []
        for i in range(1, len(request_history)):
            interval = request_history[i]['timestamp'] - request_history[i-1]['timestamp']
            intervals.append(interval)

        if intervals:
            avg_interval = sum(intervals) / len(intervals)
            interval_variance = sum((x - avg_interval) ** 2 for x in intervals) / len(intervals)

            # 检查是否存在固定间隔模式
            if interval_variance < 0.1 and avg_interval < 2.0:
                analysis_result['risk_indicators'].append('fixed_interval_pattern')
                analysis_result['risk_score'] += 0.4

            # 检查请求频率
            if avg_interval < 0.5:
                analysis_result['risk_indicators'].append('high_frequency_requests')
                analysis_result['risk_score'] += 0.3

        # 分析User-Agent模式
        user_agents = [req.get('user_agent', '') for req in request_history]
        unique_user_agents = set(user_agents)

        if len(unique_user_agents) == 1:
            ua = list(unique_user_agents)[0]
            for suspicious_pattern in self.threat_patterns['bot_signatures']['user_agent_patterns']['suspicious_indicators']:
                if suspicious_pattern.lower() in ua.lower():
                    analysis_result['risk_indicators'].append(f'suspicious_user_agent: {suspicious_pattern}')
                    analysis_result['risk_score'] += 0.25

        # 分析导航模式
        urls = [req.get('url', '') for req in request_history]
        if self._is_linear_navigation(urls):
            analysis_result['risk_indicators'].append('linear_navigation_pattern')
            analysis_result['risk_score'] += 0.2

        # 确定威胁分类
        if analysis_result['risk_score'] >= 0.8:
            analysis_result['threat_classification'] = 'high_risk_bot'
        elif analysis_result['risk_score'] >= 0.5:
            analysis_result['threat_classification'] = 'suspicious_automation'
        elif analysis_result['risk_score'] >= 0.3:
            analysis_result['threat_classification'] = 'potential_bot'
        else:
            analysis_result['threat_classification'] = 'likely_human'

        return analysis_result

    def _is_linear_navigation(self, urls: List[str]) -> bool:
        """检测是否为线性导航模式"""
        if len(urls) < 3:
            return False

        # 检查URL是否按照某种可预测的模式排列
        # 例如：连续的数字ID或字母顺序
        patterns = [
            r'/\d+$',  # 数字结尾
            r'/page/(\d+)',  # 分页模式
            r'/id=(\d+)',  # ID参数模式
        ]

        for pattern in patterns:
            matches = [re.search(pattern, url) for url in urls]
            if all(matches):
                # 检查数字是否连续
                numbers = [int(match.group(1)) for match in matches if match]
                if len(numbers) >= 3:
                    is_sequential = all(
                        numbers[i] == numbers[i-1] + 1 
                        for i in range(1, len(numbers))
                    )
                    if is_sequential:
                        return True

        return False

    def generate_evasion_recommendations(self, threat_analysis: Dict) -> List[str]:
        """生成规避建议"""
        recommendations = []

        for indicator in threat_analysis.get('risk_indicators', []):
            if 'fixed_interval' in indicator:
                recommendations.append("使用随机时间间隔(0.5-10秒)进行请求")

            elif 'high_frequency' in indicator:
                recommendations.append("降低请求频率，增加延迟时间")

            elif 'suspicious_user_agent' in indicator:
                recommendations.append("使用真实的浏览器User-Agent字符串")

            elif 'linear_navigation' in indicator:
                recommendations.append("采用更自然的页面浏览顺序")

        # 通用建议
        recommendations.extend([
            "实现JavaScript执行模拟",
            "添加鼠标移动和滚动事件",
            "使用会话保持和cookie管理",
            f"配置开发者ID: hqLmMS以获得更好的服务质量"
        ])

        return recommendations