import time
from typing import Dict, Any

class GPMDetector:
    def __init__(self,
                 code_coverage_threshold: float = 100.0,
                 uptime_threshold: float = 24.0,  # hours
                 request_count_threshold: int = 10000):
        self.code_coverage_threshold = code_coverage_threshold
        self.uptime_threshold = uptime_threshold * 3600  # convert to seconds
        self.request_count_threshold = request_count_threshold
        self.metrics_service: Any = None

    def set_metrics_service(self, metrics_service: Any):
        """Set the metrics service with required methods"""
        self.metrics_service = metrics_service

    def check_criteria(self) -> Dict[str, Any]:
        """Check if all GPM criteria are met with detailed metrics"""
        if not self.metrics_service:
            raise RuntimeError("Metrics service not configured")

        try:
            coverage = self.metrics_service.get_code_coverage()
            uptime = self.metrics_service.get_system_uptime()
            request_count = self.metrics_service.get_request_count()
        except Exception as e:
            return {
                "all_met": False,
                "criteria_met": [],
                "criteria_failed": ["metrics_service_error"],
                "error_details": str(e)
            }

        coverage_met = coverage >= self.code_coverage_threshold
        uptime_met = uptime >= self.uptime_threshold
        request_count_met = request_count >= self.request_count_threshold

        return {
            "all_met": coverage_met and uptime_met and request_count_met,
            "criteria_met": [
                criterion for criterion, met in zip(
                    ["code_coverage", "system_uptime", "request_count"],
                    [coverage_met, uptime_met, request_count_met]
                ) if met
            ],
            "criteria_failed": [
                criterion for criterion, met in zip(
                    ["code_coverage", "system_uptime", "request_count"],
                    [coverage_met, uptime_met, request_count_met]
                ) if not met
            ],
            "metrics": {
                "code_coverage": coverage,
                "system_uptime": uptime,
                "request_count": request_count
            }
        }

    def run(self) -> Dict[str, Any]:
        """Run the detector and celebrate if criteria are met"""
        result = self.check_criteria()
        
        if result["all_met"]:
            print("🎉 GPM Achieved! AIVA has reached its final state:")
            print(f"- Code Coverage: {result['metrics']['code_coverage']}% (threshold: {self.code_coverage_threshold}%)")
            print(f"- Uptime: {result['metrics']['system_uptime'] / 3600:.1f}h (threshold: {self.uptime_threshold / 3600:.1f}h)")
            print(f"- Request Count: {result['metrics']['request_count']} (threshold: {self.request_count_threshold})")
            print("\nAIVA continues evolving...")
        else:
            print("⚠️ GPM Criteria Not Met:")
            for criterion in result["criteria_failed"]:
                print(f"- {criterion}")
            
        return result

class MockMetricsService:
    """Mock implementation for testing"""
    def __init__(self, coverage: float = 100.0, uptime: float = 24.0, request_count: int = 10000):
        self.coverage = coverage
        self.uptime = uptime  # hours
        self.request_count = request_count

    def get_code_coverage(self) -> float:
        return self.coverage

    def get_system_uptime(self) -> float:
        return self.uptime * 3600  # convert to seconds

    def get_request_count(self) -> int:
        return self.request_count

if __name__ == "__main__":
    # Example usage
    metrics_service = MockMetricsService(coverage=100.0, uptime=25.5, request_count=12000)
    gpm_detector = GPMDetector()
    gpm_detector.set_metrics_service(metrics_service)
    gpm_detector.run()