# metrics/dora_collector.py
from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import Optional
import httpx

@dataclass
class DeploymentEvent:
    service: str
    deployed_at: datetime
    commit_sha: str
    pr_merged_at: Optional[datetime]
    is_hotfix: bool = False

@dataclass
class IncidentEvent:
    service: str
    started_at: datetime
    resolved_at: Optional[datetime]
    caused_by_deployment: Optional[str]  # commit_sha

class DORAMetricsCollector:
    def __init__(self, window_days: int = 30):
        self.window_days = window_days
        self.window_start = datetime.utcnow() - timedelta(days=window_days)
    
    def deployment_frequency(
        self, 
        deployments: list[DeploymentEvent]
    ) -> dict[str, float]:
        """Calculate deployments per day per service."""
        recent = [d for d in deployments if d.deployed_at >= self.window_start]
        
        by_service: dict[str, list[DeploymentEvent]] = {}
        for d in recent:
            by_service.setdefault(d.service, []).append(d)
        
        return {
            service: len(deploys) / self.window_days
            for service, deploys in by_service.items()
        }
    
    def lead_time_for_changes(
        self,
        deployments: list[DeploymentEvent]
    ) -> dict[str, timedelta]:
        """Median time from PR merge to production deployment."""
        with_pr = [
            d for d in deployments 
            if d.pr_merged_at and d.deployed_at >= self.window_start
        ]
        
        by_service: dict[str, list[timedelta]] = {}
        for d in with_pr:
            lead_time = d.deployed_at - d.pr_merged_at
            by_service.setdefault(d.service, []).append(lead_time)
        
        return {
            service: sorted(times)[len(times) // 2]  # Median
            for service, times in by_service.items()
        }
    
    def change_failure_rate(
        self,
        deployments: list[DeploymentEvent],
        incidents: list[IncidentEvent]
    ) -> float:
        """Percentage of deployments that caused incidents."""
        recent_deploys = [d for d in deployments if d.deployed_at >= self.window_start]
        failed = [
            i for i in incidents 
            if i.caused_by_deployment and i.started_at >= self.window_start
        ]
        
        if not recent_deploys:
            return 0.0
        
        return len(failed) / len(recent_deploys)
    
    def time_to_restore(
        self,
        incidents: list[IncidentEvent]
    ) -> timedelta:
        """Median time from incident start to resolution."""
        resolved = [
            i for i in incidents
            if i.resolved_at and i.started_at >= self.window_start
        ]
        
        if not resolved:
            return timedelta(0)
        
        times = sorted([i.resolved_at - i.started_at for i in resolved])
        return times[len(times) // 2]

# Time Saved = (Old Process Time - New Process Time) × Usage Count
# Example calculation

class TimeSavedCalculator:
    # Baseline times (measured from developer surveys or ticket data)
    BASELINES = {
        "provision_new_service": timedelta(days=3),      # Was: 3 days
        "setup_monitoring": timedelta(hours=8),           # Was: 8 hours
        "configure_ci_pipeline": timedelta(hours=4),      # Was: 4 hours
        "onboard_new_developer": timedelta(days=5),       # Was: 5 days
        "promote_to_staging": timedelta(hours=2),         # Was: 2 hours
    }
    
    PLATFORM_TIMES = {
        "provision_new_service": timedelta(minutes=10),   # Now: 10 min
        "setup_monitoring": timedelta(minutes=5),          # Now: 5 min (auto)
        "configure_ci_pipeline": timedelta(minutes=15),   # Now: 15 min
        "onboard_new_developer": timedelta(hours=4),      # Now: 4 hours
        "promote_to_staging": timedelta(minutes=2),       # Now: 2 min
    }
    
    def calculate_monthly_savings(
        self, 
        usage_counts: dict[str, int],
        hourly_rate: float = 150.0
    ) -> dict:
        total_hours_saved = 0.0
        breakdown = {}
        
        for action, count in usage_counts.items():
            baseline = self.BASELINES.get(action, timedelta(0))
            platform_time = self.PLATFORM_TIMES.get(action, timedelta(0))
            saved_per_use = baseline - platform_time
            total_saved = saved_per_use * count
            hours_saved = total_saved.total_seconds() / 3600
            
            breakdown[action] = {
                "count": count,
                "hours_saved_per_use": saved_per_use.total_seconds() / 3600,
                "total_hours_saved": hours_saved,
                "cost_saved": hours_saved * hourly_rate
            }
            total_hours_saved += hours_saved
        
        return {
            "breakdown": breakdown,
            "total_hours_saved": total_hours_saved,
            "total_cost_saved": total_hours_saved * hourly_rate
        }

# Classify deployments by methodology
def classify_deployment_method(deployment: dict) -> str:
    if deployment.get("via_platform_cli"):
        return "golden_path"
    elif deployment.get("via_custom_script"):
        return "off_road"
    elif deployment.get("via_manual_console"):
        return "manual"
    return "unknown"

def paved_path_ratio(deployments: list[dict]) -> float:
    total = len(deployments)
    golden = sum(1 for d in deployments if classify_deployment_method(d) == "golden_path")
    return golden / total if total > 0 else 0.0

DX_SURVEY_QUESTIONS = [
    {
        "id": "ease_of_deployment",
        "text": "How easy is it to deploy your service to production?",
        "scale": "1-7 Likert (Very Difficult → Very Easy)"
    },
    {
        "id": "confidence_in_system",
        "text": "How confident are you that your production deployments will succeed?",
        "scale": "1-7 Likert"
    },
    {
        "id": "feedback_speed",
        "text": "How quickly do you get feedback when something goes wrong in production?",
        "scale": "1-7 Likert (Very Slow → Very Fast)"
    },
    {
        "id": "platform_nps",
        "text": "How likely are you to recommend our internal developer platform to a new team?",
        "scale": "0-10 NPS"
    },
    {
        "id": "biggest_pain",
        "text": "What is the single biggest friction point in your development workflow?",
        "scale": "Open text"
    }
]

def calculate_dx_score(responses: list[dict]) -> dict:
    """
    Composite DX score: 0-100
    Weighted combination of quantitative questions
    """
    weights = {
        "ease_of_deployment": 0.30,
        "confidence_in_system": 0.25,
        "feedback_speed": 0.20,
        "platform_nps": 0.25
    }
    
    averages = {}
    for metric, weight in weights.items():
        values = [r[metric] for r in responses if metric in r]
        if values:
            if metric == "platform_nps":
                # NPS: normalize 0-10 to 0-100
                averages[metric] = sum(values) / len(values) * 10
            else:
                # Likert 1-7: normalize to 0-100
                averages[metric] = (sum(values) / len(values) - 1) / 6 * 100
    
    composite = sum(averages[m] * w for m, w in weights.items() if m in averages)
    
    return {
        "composite_score": round(composite, 1),
        "breakdown": averages,
        "respondents": len(responses)
    }

def developer_productivity_index(snapshot: dict) -> float:
    """
    Composite score 0-100 for executive dashboards.
    Weighted combination of key signals.
    """
    # Normalize each dimension to 0-1
    dora_score = normalize_dora(snapshot['dora'])           # 0-1
    adoption = snapshot['platform']['pavedPathRatio']        # 0-1
    dx = snapshot['dx']['compositeScore'] / 100             # 0-1
    sla = snapshot['sla']['uptimePercent'] / 100            # 0-1
    
    weights = {
        'dora': 0.40,       # Delivery performance matters most
        'adoption': 0.20,   # Platform actually being used
        'dx': 0.30,         # How engineers feel
        'sla': 0.10,        # Platform reliability
    }
    
    dpi = (
        dora_score * weights['dora'] +
        adoption * weights['adoption'] +
        dx * weights['dx'] +
        sla * weights['sla']
    ) * 100
    
    return round(dpi, 1)