"""Performance optimization suggestions."""

from __future__ import annotations

from typing import Any, Dict, List, Optional


class PerformanceOptimizer:
    """Provides performance optimization recommendations."""

    def analyze_performance(self, framework: str, platform: str, analysis: Dict[str, Any]) -> Dict[str, Any]:
        """Analyze and suggest performance optimizations."""
        optimizations = []
        score = 100
        
        # Framework-specific optimizations
        if framework.lower() == "next.js":
            optimizations.extend([
                {
                    "category": "build",
                    "priority": "high",
                    "suggestion": "Enable static generation for pages where possible",
                    "impact": "Reduces server load and improves response time"
                },
                {
                    "category": "images",
                    "priority": "medium",
                    "suggestion": "Use next/image for automatic image optimization",
                    "impact": "Reduces image size by 30-50%"
                },
                {
                    "category": "caching",
                    "priority": "high",
                    "suggestion": "Implement ISR (Incremental Static Regeneration)",
                    "impact": "Improves page load time significantly"
                }
            ])
            score -= 10 if not analysis.get("has_docker") else 0
        
        elif framework.lower() in ["django", "flask", "fastapi"]:
            optimizations.extend([
                {
                    "category": "database",
                    "priority": "high",
                    "suggestion": "Enable database connection pooling",
                    "impact": "Reduces database connection overhead"
                },
                {
                    "category": "caching",
                    "priority": "high",
                    "suggestion": "Implement Redis caching layer",
                    "impact": "Improves response time by 40-60%"
                },
                {
                    "category": "async",
                    "priority": "medium",
                    "suggestion": "Use async/await for I/O operations",
                    "impact": "Improves concurrency and throughput"
                }
            ])
        
        # Platform-specific optimizations
        if platform.lower() == "vercel":
            optimizations.append({
                "category": "edge",
                "priority": "high",
                "suggestion": "Use Edge Functions for low-latency responses",
                "impact": "Reduces latency by 50-70%"
            })
        
        if platform.lower() in ["aws", "gcp", "azure"]:
            optimizations.append({
                "category": "cdn",
                "priority": "high",
                "suggestion": "Enable CDN for static assets",
                "impact": "Improves global load times"
            })
        
        # General optimizations
        if not analysis.get("has_docker"):
            optimizations.append({
                "category": "containerization",
                "priority": "medium",
                "suggestion": "Containerize application for consistent deployments",
                "impact": "Improves deployment reliability"
            })
        
        if analysis.get("dependencies", []):
            dep_count = len(analysis.get("dependencies", []))
            if dep_count > 50:
                optimizations.append({
                    "category": "dependencies",
                    "priority": "medium",
                    "suggestion": f"Review {dep_count} dependencies - consider removing unused ones",
                    "impact": "Reduces bundle size and build time"
                })
        
        return {
            "performance_score": max(0, score),
            "optimizations": optimizations,
            "priority_count": {
                "high": len([o for o in optimizations if o["priority"] == "high"]),
                "medium": len([o for o in optimizations if o["priority"] == "medium"]),
                "low": len([o for o in optimizations if o["priority"] == "low"])
            },
            "estimated_improvement": self._estimate_improvement(optimizations)
        }

    def _estimate_improvement(self, optimizations: List[Dict]) -> str:
        """Estimate performance improvement."""
        high_priority = len([o for o in optimizations if o["priority"] == "high"])
        
        if high_priority >= 3:
            return "30-50% performance improvement possible"
        elif high_priority >= 2:
            return "20-30% performance improvement possible"
        elif high_priority >= 1:
            return "10-20% performance improvement possible"
        else:
            return "Minor optimizations available"