"""Result Formatting Utilities"""
import json
from typing import Dict, Any, List

def format_analysis_result(result: Dict[str, Any]) -> str:
    """
    Format analysis result for display.
    
    Args:
        result: Analysis result dictionary
        
    Returns:
        str: Formatted result string
    """
    if "error" in result:
        return f"❌ Error: {result['error']}"
    
    issues = result.get("issues", [])
    if not issues:
        return "✅ No issues found! Code looks good."
    
    output = [f"Found {len(issues)} issue(s):\n"]
    
    for i, issue in enumerate(issues, 1):
        severity = issue.get("severity", "info").upper()
        message = issue.get("message", "Unknown issue")
        location = issue.get("location", {})
        row = location.get("row", "?")
        col = location.get("column", "?")
        
        emoji = {
            "ERROR": "🔴",
            "WARNING": "🟡",
            "INFO": "🔵"
        }.get(severity, "⚪")
        
        output.append(f"{emoji} Issue {i}: Line {row}:{col}")
        output.append(f"   {severity}: {message}")
        
        if "suggestion" in issue:
            output.append(f"   💡 Suggestion: {issue['suggestion']}")
        
        output.append("")
    
    return "\n".join(output)

def format_security_result(result: Dict[str, Any]) -> str:
    """
    Format security scan result.
    
    Args:
        result: Security result dictionary
        
    Returns:
        str: Formatted result string
    """
    if "error" in result:
        return f"❌ Error: {result['error']}"
    
    vulnerabilities = result.get("vulnerabilities", [])
    if not vulnerabilities:
        return "✅ No security vulnerabilities found!"
    
    output = [f"🛡️ Found {len(vulnerabilities)} security issue(s):\n"]
    
    # Group by severity
    by_severity = {}
    for vuln in vulnerabilities:
        severity = vuln.get("severity", "MEDIUM")
        by_severity.setdefault(severity, []).append(vuln)
    
    for severity in ["CRITICAL", "HIGH", "MEDIUM", "LOW"]:
        if severity not in by_severity:
            continue
        
        vulns = by_severity[severity]
        emoji = {
            "CRITICAL": "🔴",
            "HIGH": "🟠",
            "MEDIUM": "🟡",
            "LOW": "🟢"
        }.get(severity, "⚪")
        
        output.append(f"{emoji} {severity} ({len(vulns)} issue(s)):")
        for vuln in vulns:
            line = vuln.get("line", "?")
            message = vuln.get("message", "Unknown vulnerability")
            output.append(f"   Line {line}: {message}")
        output.append("")
    
    return "\n".join(output)

def format_complexity_result(result: Dict[str, Any]) -> str:
    """
    Format complexity metrics result.
    
    Args:
        result: Complexity result dictionary
        
    Returns:
        str: Formatted result string
    """
    if "error" in result:
        return f"❌ Error: {result['error']}"
    
    metrics = result.get("metrics", {})
    if not metrics:
        return "⚠️ No complexity metrics available"
    
    output = ["📊 Complexity Metrics:\n"]
    
    # Average complexity
    avg = metrics.get("average_complexity", 0)
    output.append(f"Average Complexity: {avg:.2f}")
    
    # Max complexity
    max_val = metrics.get("max_complexity", 0)
    output.append(f"Maximum Complexity: {max_val}")
    
    # Maintainability index
    mi = metrics.get("maintainability_index", 0)
    mi_emoji = "🟢" if mi >= 70 else "🟡" if mi >= 50 else "🔴"
    output.append(f"{mi_emoji} Maintainability Index: {mi:.1f}/100")
    
    # Functions by complexity
    functions = metrics.get("functions", [])
    if functions:
        output.append(f"\nTop Complex Functions:")
        sorted_funcs = sorted(functions, key=lambda x: x.get("complexity", 0), reverse=True)
        for func in sorted_funcs[:5]:
            name = func.get("name", "unknown")
            complexity = func.get("complexity", 0)
            rank = func.get("rank", "?")
            output.append(f"  - {name}: {complexity} ({rank} complexity)")
    
    return "\n".join(output)