"""
Secure Ticketing Platform - Core API Gateway
Microservices Architecture Implementation
"""

import json
import hashlib
import datetime
import base64
import math
import re
from typing import Dict, List, Optional, Any, Union
from dataclasses import dataclass, asdict
from collections import defaultdict

@dataclass
class APIResponse:
    success: bool
    data: Optional[Dict[str, Any]]
    error: Optional[str]
    timestamp: str
    request_id: str

class TicketingAPIGateway:
    """Main API Gateway for ticketing platform microservices"""
    
    def __init__(self):
        self.services = {
            'ticket_service': TicketService(),
            'payment_service': PaymentService(),
            'fraud_detection': FraudDetectionService(),
            'pricing_engine': DynamicPricingEngine(),
            'blockchain_verifier': BlockchainVerifier()
        }
        self.request_counter = 0
        
    def generate_request_id(self) -> str:
        """Generate unique request ID"""
        self.request_counter += 1
        timestamp = datetime.datetime.now().isoformat()
        return f"REQ_{timestamp}_{self.request_counter}"
    
    def route_request(self, service: str, endpoint: str, data: Dict[str, Any]) -> APIResponse:
        """Route requests to appropriate microservice"""
        request_id = self.generate_request_id()
        
        try:
            if service not in self.services:
                return APIResponse(
                    success=False,
                    data=None,
                    error=f"Service {service} not found",
                    timestamp=datetime.datetime.now().isoformat(),
                    request_id=request_id
                )
            
            service_instance = self.services[service]
            result = getattr(service_instance, endpoint)(data)
            
            return APIResponse(
                success=True,
                data=result,
                error=None,
                timestamp=datetime.datetime.now().isoformat(),
                request_id=request_id
            )
            
        except Exception as e:
            return APIResponse(
                success=False,
                data=None,
                error=str(e),
                timestamp=datetime.datetime.now().isoformat(),
                request_id=request_id
            )

class TicketService:
    """Ticket management microservice"""
    
    def __init__(self):
        self.tickets = {}
        self.events = {}
        
    def create_ticket(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Create new ticket"""
        ticket_id = self._generate_ticket_id(data)
        ticket = {
            'id': ticket_id,
            'event_id': data['event_id'],
            'user_id': data['user_id'],
            'price': data['price'],
            'status': 'active',
            'created_at': datetime.datetime.now().isoformat(),
            'blockchain_hash': None
        }
        
        self.tickets[ticket_id] = ticket
        return {'ticket_id': ticket_id, 'status': 'created'}
    
    def verify_ticket(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Verify ticket validity"""
        ticket_id = data['ticket_id']
        
        if ticket_id not in self.tickets:
            return {'valid': False, 'reason': 'Ticket not found'}
            
        ticket = self.tickets[ticket_id]
        
        return {
            'valid': ticket['status'] == 'active',
            'ticket_details': {
                'event_id': ticket['event_id'],
                'user_id': ticket['user_id'],
                'price': ticket['price']
            }
        }
    
    def _generate_ticket_id(self, data: Dict[str, Any]) -> str:
        """Generate unique ticket ID"""
        raw_string = f"{data['event_id']}_{data['user_id']}_{datetime.datetime.now().isoformat()}"
        return hashlib.sha256(raw_string.encode()).hexdigest()[:16]

class PaymentService:
    """Payment processing microservice"""
    
    def __init__(self):
        self.transactions = {}
        
    def process_payment(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Process payment transaction"""
        transaction_id = self._generate_transaction_id()
        
        transaction = {
            'id': transaction_id,
            'ticket_id': data['ticket_id'],
            'amount': data['amount'],
            'currency': data.get('currency', 'USD'),
            'payment_method': data['payment_method'],
            'status': 'processing',
            'created_at': datetime.datetime.now().isoformat()
        }
        
        self.transactions[transaction_id] = transaction
        
        # Simulate payment processing
        if self._validate_payment(data):
            transaction['status'] = 'completed'
            return {'transaction_id': transaction_id, 'status': 'completed'}
        else:
            transaction['status'] = 'failed'
            return {'transaction_id': transaction_id, 'status': 'failed', 'error': 'Payment validation failed'}
    
    def _validate_payment(self, data: Dict[str, Any]) -> bool:
        """Validate payment details"""
        required_fields = ['ticket_id', 'amount', 'payment_method']
        return all(field in data for field in required_fields)
    
    def _generate_transaction_id(self) -> str:
        """Generate unique transaction ID"""
        timestamp = datetime.datetime.now().isoformat()
        raw_string = f"PAY_{timestamp}_{len(timestamp)}"
        return hashlib.sha256(raw_string.encode()).hexdigest()[:16]

class FraudDetectionService:
    """Real-time fraud detection microservice"""
    
    def __init__(self):
        self.risk_scores = defaultdict(float)
        self.suspicious_patterns = []
        
    def analyze_transaction(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Analyze transaction for fraud risk"""
        risk_score = self._calculate_risk_score(data)
        
        result = {
            'risk_score': risk_score,
            'risk_level': self._determine_risk_level(risk_score),
            'flags': self._identify_flags(data),
            'recommendation': self._get_recommendation(risk_score)
        }
        
        return result
    
    def _calculate_risk_score(self, data: Dict[str, Any]) -> float:
        """Calculate fraud risk score (0-100)"""
        score = 0.0
        
        # High-value transaction risk
        if data.get('amount', 0) > 1000:
            score += 20
            
        # Multiple tickets risk
        if data.get('quantity', 1) > 4:
            score += 15
            
        # New user risk
        if data.get('user_age_days', 365) < 7:
            score += 25
            
        # Unusual payment method
        if data.get('payment_method') == 'crypto':
            score += 10
            
        return min(score, 100.0)
    
    def _determine_risk_level(self, score: float) -> str:
        """Determine risk level based on score"""
        if score < 20:
            return 'low'
        elif score < 50:
            return 'medium'
        elif score < 80:
            return 'high'
        else:
            return 'critical'
    
    def _identify_flags(self, data: Dict[str, Any]) -> List[str]:
        """Identify specific fraud flags"""
        flags = []
        
        if data.get('amount', 0) > 5000:
            flags.append('high_value_transaction')
            
        if data.get('quantity', 1) > 10:
            flags.append('bulk_purchase')
            
        if data.get('ip_risk_score', 0) > 0.7:
            flags.append('suspicious_ip')
            
        return flags
    
    def _get_recommendation(self, score: float) -> str:
        """Get fraud prevention recommendation"""
        if score < 20:
            return 'approve'
        elif score < 50:
            return 'review'
        elif score < 80:
            return 'manual_review'
        else:
            return 'block'

class DynamicPricingEngine:
    """Dynamic pricing algorithm microservice"""
    
    def __init__(self):
        self.demand_history = defaultdict(list)
        self.pricing_rules = {}
        
    def calculate_price(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Calculate dynamic price based on demand"""
        event_id = data['event_id']
        base_price = data['base_price']
        
        demand_factor = self._calculate_demand_factor(event_id)
        time_factor = self._calculate_time_factor(data.get('event_date'))
        inventory_factor = self._calculate_inventory_factor(data.get('remaining_tickets', 100))
        
        dynamic_price = base_price * demand_factor * time_factor * inventory_factor
        
        return {
            'original_price': base_price,
            'dynamic_price': round(dynamic_price, 2),
            'demand_factor': demand_factor,
            'time_factor': time_factor,
            'inventory_factor': inventory_factor,
            'price_change_percent': round(((dynamic_price - base_price) / base_price) * 100, 2)
        }
    
    def _calculate_demand_factor(self, event_id: str) -> float:
        """Calculate demand-based pricing factor"""
        # Simulate demand calculation
        current_demand = len(self.demand_history[event_id])
        
        if current_demand < 10:
            return 1.0
        elif current_demand < 50:
            return 1.1
        elif current_demand < 100:
            return 1.25
        else:
            return 1.5
    
    def _calculate_time_factor(self, event_date: Optional[str]) -> float:
        """Calculate time-based pricing factor"""
        if not event_date:
            return 1.0
            
        try:
            event_dt = datetime.datetime.fromisoformat(event_date.replace('Z', '+00:00'))
            days_until = (event_dt - datetime.datetime.now()).days
            
            if days_until > 30:
                return 1.0
            elif days_until > 14:
                return 1.05
            elif days_until > 7:
                return 1.15
            elif days_until > 3:
                return 1.3
            else:
                return 1.5
        except:
            return 1.0
    
    def _calculate_inventory_factor(self, remaining_tickets: int) -> float:
        """Calculate inventory-based pricing factor"""
        if remaining_tickets > 100:
            return 1.0
        elif remaining_tickets > 50:
            return 1.1
        elif remaining_tickets > 20:
            return 1.25
        elif remaining_tickets > 10:
            return 1.5
        else:
            return 2.0

class BlockchainVerifier:
    """Blockchain-based ticket verification microservice"""
    
    def __init__(self):
        self.blockchain = []
        self.ticket_hashes = {}
        
    def create_ticket_hash(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Create blockchain hash for ticket"""
        ticket_data = {
            'ticket_id': data['ticket_id'],
            'event_id': data['event_id'],
            'user_id': data['user_id'],
            'price': data['price'],
            'timestamp': datetime.datetime.now().isoformat()
        }
        
        # Create hash
        ticket_string = json.dumps(ticket_data, sort_keys=True)
        ticket_hash = hashlib.sha256(ticket_string.encode()).hexdigest()
        
        # Add to blockchain
        block = {
            'hash': ticket_hash,
            'data': ticket_data,
            'previous_hash': self._get_last_hash(),
            'timestamp': datetime.datetime.now().isoformat()
        }
        
        self.blockchain.append(block)
        self.ticket_hashes[data['ticket_id']] = ticket_hash
        
        return {
            'ticket_hash': ticket_hash,
            'block_index': len(self.blockchain) - 1,
            'verified': True
        }
    
    def verify_ticket_blockchain(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """Verify ticket on blockchain"""
        ticket_id = data['ticket_id']
        
        if ticket_id not in self.ticket_hashes:
            return {'verified': False, 'reason': 'Ticket not found on blockchain'}
        
        stored_hash = self.ticket_hashes[ticket_id]
        
        # Verify blockchain integrity
        for block in self.blockchain:
            if block['hash'] == stored_hash:
                return {
                    'verified': True,
                    'block_index': self.blockchain.index(block),
                    'timestamp': block['timestamp']
                }
        
        return {'verified': False, 'reason': 'Blockchain verification failed'}
    
    def _get_last_hash(self) -> str:
        """Get hash of last block"""
        if not self.blockchain:
            return '0' * 64
        return self.blockchain[-1]['hash']

# API Gateway instance
api_gateway = TicketingAPIGateway()

def test_api_gateway():
    """Test API Gateway functionality"""
    print("Testing Ticketing Platform API Gateway...")
    
    # Test ticket creation
    ticket_data = {
        'event_id': 'EVENT_001',
        'user_id': 'USER_001',
        'price': 100.00
    }
    
    response = api_gateway.route_request('ticket_service', 'create_ticket', ticket_data)
    print(f"Ticket Creation: {response.success}")
    
    if response.success and response.data:
        ticket_id = response.data['ticket_id']
        
        # Test fraud detection
        fraud_data = {
            'ticket_id': ticket_id,
            'amount': 100.00,
            'quantity': 2,
            'user_age_days': 30,
            'payment_method': 'credit_card'
        }
        
        fraud_response = api_gateway.route_request('fraud_detection', 'analyze_transaction', fraud_data)
        print(f"Fraud Detection: {fraud_response.success}")
        
        # Test dynamic pricing
        pricing_data = {
            'event_id': 'EVENT_001',
            'base_price': 100.00,
            'event_date': '2026-02-15T19:00:00Z',
            'remaining_tickets': 50
        }
        
        pricing_response = api_gateway.route_request('pricing_engine', 'calculate_price', pricing_data)
        print(f"Dynamic Pricing: {pricing_response.success}")
        
        # Test blockchain verification
        blockchain_data = {
            'ticket_id': ticket_id,
            'event_id': 'EVENT_001',
            'user_id': 'USER_001',
            'price': 100.00
        }
        
        blockchain_response = api_gateway.route_request('blockchain_verifier', 'create_ticket_hash', blockchain_data)
        print(f"Blockchain Hash: {blockchain_response.success}")
    
    return True

if __name__ == "__main__":
    test_api_gateway()