"""
Microservices Architecture for Secure Ticketing Platform
Design Pattern: Event-Driven Microservices with API Gateway
"""

import json
import hashlib
import datetime
from typing import Dict, List, Optional, Any
from dataclasses import dataclass
from enum import Enum

class ServiceType(Enum):
    API_GATEWAY = "api_gateway"
    AUTH_SERVICE = "auth_service"
    TICKET_SERVICE = "ticket_service"
    PAYMENT_SERVICE = "payment_service"
    FRAUD_DETECTION = "fraud_detection"
    PRICING_ENGINE = "pricing_engine"
    NOTIFICATION_SERVICE = "notification_service"
    BLOCKCHAIN_VERIFIER = "blockchain_verifier"

@dataclass
class MicroService:
    name: str
    service_type: ServiceType
    port: int
    dependencies: List[str]
    health_endpoint: str
    scaling_config: Dict[str, Any]

class TicketingArchitecture:
    """Core architecture definition for scalable ticketing platform"""
    
    def __init__(self):
        self.services = self._initialize_services()
        self.message_broker = "redis_cluster"
        self.database_cluster = "postgresql_ha"
        self.cache_layer = "redis_cluster"
        
    def _initialize_services(self) -> List[MicroService]:
        """Define all microservices with their configurations"""
        return [
            MicroService(
                name="api-gateway",
                service_type=ServiceType.API_GATEWAY,
                port=3000,
                dependencies=["auth-service", "ticket-service"],
                health_endpoint="/health",
                scaling_config={"min_instances": 2, "max_instances": 10, "cpu_threshold": 70}
            ),
            MicroService(
                name="auth-service",
                service_type=ServiceType.AUTH_SERVICE,
                port=3001,
                dependencies=[],
                health_endpoint="/health",
                scaling_config={"min_instances": 2, "max_instances": 5, "cpu_threshold": 60}
            ),
            MicroService(
                name="ticket-service",
                service_type=ServiceType.TICKET_SERVICE,
                port=3002,
                dependencies=["auth-service", "pricing-engine", "fraud-detection"],
                health_endpoint="/health",
                scaling_config={"min_instances": 3, "max_instances": 15, "cpu_threshold": 75}
            ),
            MicroService(
                name="payment-service",
                service_type=ServiceType.PAYMENT_SERVICE,
                port=3003,
                dependencies=["auth-service", "fraud-detection"],
                health_endpoint="/health",
                scaling_config={"min_instances": 2, "max_instances": 8, "cpu_threshold": 65}
            ),
            MicroService(
                name="fraud-detection",
                service_type=ServiceType.FRAUD_DETECTION,
                port=3004,
                dependencies=[],
                health_endpoint="/health",
                scaling_config={"min_instances": 2, "max_instances": 6, "cpu_threshold": 80}
            ),
            MicroService(
                name="pricing-engine",
                service_type=ServiceType.PRICING_ENGINE,
                port=3005,
                dependencies=[],
                health_endpoint="/health",
                scaling_config={"min_instances": 1, "max_instances": 4, "cpu_threshold": 70}
            ),
            MicroService(
                name="notification-service",
                service_type=ServiceType.NOTIFICATION_SERVICE,
                port=3006,
                dependencies=["ticket-service"],
                health_endpoint="/health",
                scaling_config={"min_instances": 1, "max_instances": 3, "cpu_threshold": 50}
            ),
            MicroService(
                name="blockchain-verifier",
                service_type=ServiceType.BLOCKCHAIN_VERIFIER,
                port=3007,
                dependencies=["ticket-service"],
                health_endpoint="/health",
                scaling_config={"min_instances": 2, "max_instances": 5, "cpu_threshold": 60}
            )
        ]
    
    def generate_service_mesh(self) -> Dict[str, Any]:
        """Generate service mesh configuration"""
        mesh_config = {
            "mesh_type": "Istio",
            "services": [],
            "traffic_routing": {},
            "security_policies": {
                "mtls": "strict",
                "auth_policy": "jwt_validation"
            }
        }
        
        for service in self.services:
            mesh_config["services"].append({
                "name": service.name,
                "port": service.port,
                "dependencies": service.dependencies
            })
            
        return mesh_config
    
    def get_deployment_manifest(self) -> Dict[str, Any]:
        """Generate Kubernetes deployment manifests"""
        return {
            "api_version": "v1",
            "kind": "ServiceList",
            "services": [
                {
                    "name": service.name,
                    "image": f"ticketing/{service.name}:latest",
                    "port": service.port,
                    "replicas": service.scaling_config["min_instances"],
                    "resources": {
                        "requests": {"cpu": "100m", "memory": "128Mi"},
                        "limits": {"cpu": "500m", "memory": "512Mi"}
                    },
                    "health_check": service.health_endpoint
                }
                for service in self.services
            ]
        }

# Architecture validation
def validate_architecture():
    """Validate the microservices architecture"""
    arch = TicketingArchitecture()
    
    # Check service dependencies
    dependency_graph = {}
    for service in arch.services:
        dependency_graph[service.name] = service.dependencies
    
    # Check for circular dependencies
    def has_cycle(graph, node, visited, rec_stack):
        visited[node] = True
        rec_stack[node] = True
        
        for neighbor in graph.get(node, []):
            if not visited.get(neighbor, False):
                if has_cycle(graph, neighbor, visited, rec_stack):
                    return True
            elif rec_stack.get(neighbor, False):
                return True
        
        rec_stack[node] = False
        return False
    
    visited = {}
    rec_stack = {}
    for service_name in dependency_graph:
        if not visited.get(service_name, False):
            if has_cycle(dependency_graph, service_name, visited, rec_stack):
                raise ValueError(f"Circular dependency detected involving {service_name}")
    
    return {
        "validation": "passed",
        "services_count": len(arch.services),
        "architecture_type": "event_driven_microservices"
    }

if __name__ == "__main__":
    # Generate architecture
    architecture = TicketingArchitecture()
    
    # Output configuration
    print("=== Ticketing Platform Architecture ===")
    print(f"Total Services: {len(architecture.services)}")
    print(f"Message Broker: {architecture.message_broker}")
    print(f"Database Cluster: {architecture.database_cluster}")
    
    # Validate architecture
    validation_result = validate_architecture()
    print(f"\nValidation Result: {validation_result['validation']}")
    
    # Generate deployment config
    deployment = architecture.get_deployment_manifest()
    print(f"\nDeployment Configuration Generated: {len(deployment['services'])} services")