import subprocess
import json
from collections import defaultdict

class TestSelector:
    def __init__(self, test_history_file="test_history.json"):
        self.test_history = self._load_history(test_history_file)
        self.test_dependencies = self._build_dependency_graph()

    def _load_history(self, filepath):
        try:
            with open(filepath) as f:
                return json.load(f)
        except FileNotFoundError:
            return {}

    def _build_dependency_graph(self):
        """Map tests to files they depend on."""
        dependencies = defaultdict(set)
        result = subprocess.run(
            ["pytest", "--collect-only", "-q"],
            capture_output=True, text=True
        )
        # Parse test collection output
        return dependencies

    def select_tests(self, changed_files):
        """Select tests most likely to fail based on changed files."""
        scored_tests = []

        for test, history in self.test_history.items():
            impact_score = 0
            for changed_file in changed_files:
                if self._affects_test(changed_file, test):
                    # Weight by recent failure rate
                    recent_failures = history.get("failures", [])[-10:]
                    fail_rate = sum(recent_failures) / len(recent_failures) if recent_failures else 0
                    impact_score += fail_rate

            scored_tests.append((test, impact_score))

        # Return top 50% by score
        scored_tests.sort(key=lambda x: x[1], reverse=True)
        cutoff = len(scored_tests) // 2
        return [t[0] for t in scored_tests[:cutoff]]

    def _affects_test(self, file_path, test_name):
        # Simplified: check if test file imports the changed module
        return file_path.split("/")[-1].replace(".py", "") in test_name

# pipeline_optimizer.py
import statistics
import json
from datetime import datetime, timedelta

class PipelineOptimizer:
    def __init__(self, metrics_file="pipeline_metrics.json"):
        self.metrics = self._load_metrics(metrics_file)
        self.baseline = self._calculate_baseline()

    def _load_metrics(self, filepath):
        try:
            with open(filepath) as f:
                return json.load(f)
        except FileNotFoundError:
            return {"runs": []}

    def _calculate_baseline(self, days=30):
        cutoff = datetime.now() - timedelta(days=days)
        recent_runs = [
            r for r in self.metrics["runs"]
            if datetime.fromisoformat(r["timestamp"]) > cutoff
        ]

        if not recent_runs:
            return None

        return {
            "avg_duration": statistics.mean(r["duration"] for r in recent_runs),
            "avg_test_time": statistics.mean(r["test_duration"] for r in recent_runs),
            "avg_build_time": statistics.mean(r["build_duration"] for r in recent_runs),
            "p95_duration": sorted(r["duration"] for r in recent_runs)[int(len(recent_runs) * 0.95)]
        }

    def analyze_slowdown(self, current_run):
        if not self.baseline:
            return {"status": "no_baseline"}

        duration_ratio = current_run["duration"] / self.baseline["avg_duration"]

        analysis = {
            "status": "normal" if duration_ratio < 1.2 else "slow",
            "duration_ratio": round(duration_ratio, 2),
            "recommendations": []
        }

        if current_run["test_duration"] / self.baseline["avg_test_time"] > 1.3:
            analysis["recommendations"].append({
                "area": "tests",
                "suggestion": "Consider test parallelization or test selection"
            })

        if current_run["build_duration"] / self.baseline["avg_build_time"] > 1.3:
            analysis["recommendations"].append({
                "area": "build",
                "suggestion": "Review dependency caching and build configuration"
            })

        return analysis

    def suggest_optimizations(self):
        if not self.baseline:
            return []

        optimizations = []

        # Analyze test execution patterns
        test_times = [r["test_duration"] for r in self.metrics["runs"]]
        if statistics.stdev(test_times) / statistics.mean(test_times) > 0.3:
            optimizations.append({
                "type": "test_instability",
                "description": "High test time variance detected",
                "action": "Review flaky tests and implement retry logic"
            })

        # Check for caching opportunities
        recent_runs = self.metrics["runs"][-10:]
        dependency_fetch_times = [r.get("dependency_time", 0) for r in recent_runs]
        avg_dep_time = statistics.mean(dependency_fetch_times)
        if avg_dep_time > 60:
            optimizations.append({
                "type": "caching",
                "description": f"Average dependency fetch: {avg_dep_time:.0f}s",
                "action": "Implement dependency caching with hash-based keys"
            })

        return optimizations

# record_run.py
import json
from datetime import datetime

def record_pipeline_run(metrics_file: str, run_data: dict):
    try:
        with open(metrics_file) as f:
            history = json.load(f)
    except FileNotFoundError:
        history = {"runs": []}

    history["runs"].append({
        "timestamp": datetime.now().isoformat(),
        "branch": run_data.get("branch"),
        "changed_files": run_data.get("changed_files", []),
        "duration": run_data.get("duration"),
        "build_duration": run_data.get("build_duration"),
        "test_duration": run_data.get("test_duration"),
        "dependency_time": run_data.get("dependency_time", 0),
        "passed": run_data.get("passed", 0),
        "failed": run_data.get("failed", 0),
    })

    # Keep the last 500 runs to bound file size
    history["runs"] = history["runs"][-500:]
    with open(metrics_file, "w") as f:
        json.dump(history, f, indent=2)