import ctypes
import os
import subprocess
from typing import Optional, Dict, Any

class JemallocProfiler:
    def __init__(self, pid: int):
        self.pid = pid
        self.libc = ctypes.CDLL("libc.so.6")
        
    def enable_profiling(self, prefix: str = "/tmp/jeprof") -> bool:
        """Enable profiling in running process via gdb injection"""
        gdb_script = f"""
        attach {self.pid}
        call (int)mallctl("prof.active", 0, 0, &(bool){{1}}, sizeof(bool))
        call (int)mallctl("prof.prefix", 0, 0, "{prefix}", strlen("{prefix}")+1)
        detach
        quit
        """
        
        try:
            result = subprocess.run(
                ["gdb", "-batch", "-ex", gdb_script],
                capture_output=True, text=True, timeout=30
            )
            return result.returncode == 0
        except subprocess.TimeoutExpired:
            return False
    
    def dump_profile(self) -> Optional[str]:
        """Trigger immediate profile dump"""
        gdb_script = f"""
        attach {self.pid}
        call (int)mallctl("prof.dump", 0, 0, 0, 0)
        detach
        quit
        """
        
        try:
            subprocess.run(
                ["gdb", "-batch", "-ex", gdb_script],
                capture_output=True, timeout=30
            )
            return self._find_latest_profile()
        except subprocess.TimeoutExpired:
            return None
    
    def _find_latest_profile(self) -> Optional[str]:
        """Find the most recent profile dump"""
        import glob
        profiles = glob.glob("/tmp/jeprof.*")
        if profiles:
            return max(profiles, key=os.path.getctime)
        return None
    
    def analyze_growth(self, base_profile: str, current_profile: str) -> Dict[str, Any]:
        """Analyze memory growth between two profiles"""
        cmd = ["jeprof", "--base", base_profile, "--text", current_profile]
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        return {
            "growth_output": result.stdout,
            "potential_leaks": self._parse_growth_output(result.stdout)
        }
    
    def _parse_growth_output(self, output: str) -> list:
        """Parse jeprof output for potential memory leaks"""
        leaks = []
        lines = output.split('\n')
        
        for line in lines:
            if line.strip() and not line.startswith('Total'):
                parts = line.split()
                if len(parts) >= 4:
                    try:
                        growth = float(parts[0])
                        if growth > 1024 * 1024:  # >1MB growth
                            leaks.append({
                                "growth_bytes": growth,
                                "function": " ".join(parts[3:])
                            })
                    except ValueError:
                        continue
        
        return sorted(leaks, key=lambda x: x["growth_bytes"], reverse=True)

import ctypes
import os
import signal
import subprocess
import time
from pathlib import Path
from typing import List, Dict, Optional

class JemallocMemoryProfiler:
    def __init__(self, target_pid: int, profile_dir: str = "/tmp/profiles"):
        self.target_pid = target_pid
        self.profile_dir = Path(profile_dir)
        self.profile_dir.mkdir(exist_ok=True)
        self.baseline_profile = None
        
    def enable_profiling(self) -> bool:
        """Enable jemalloc profiling in target process"""
        try:
            # Create gdb script for mallctl injection
            gdb_commands = [
                f"attach {self.target_pid}",
                "call (int)mallctl(\"prof.active\", 0, 0, &(bool){1}, sizeof(bool))",
                f"call (int)mallctl(\"prof.prefix\", 0, 0, \"{self.profile_dir}/app\", {len(str(self.profile_dir)) + 5})",
                "call (int)mallctl(\"prof.leak\", 0, 0, &(bool){1}, sizeof(bool))",
                "detach",
                "quit"
            ]
            
            gdb_script = "\n".join(gdb_commands)
            
            # Execute gdb injection
            process = subprocess.run(
                ["gdb", "-batch", "-ex", gdb_script],
                capture_output=True,
                text=True,
                timeout=30
            )
            
            return process.returncode == 0
            
        except subprocess.TimeoutExpired:
            return False
    
    def trigger_profile_dump(self) -> Optional[str]:
        """Trigger immediate profile dump via signal"""
        try:
            os.kill(self.target_pid, signal.SIGUSR1)
            time.sleep(2)  # Allow time for dump generation
            return self._get_latest_profile()
        except ProcessLookupError:
            return None
    
    def start_leak_detection(self, interval_minutes: int = 10) -> None:
        """Start continuous leak detection monitoring"""
        self.baseline_profile = self.trigger_profile_dump()
        
        while True:
            time.sleep(interval_minutes * 60)
            current_profile = self.trigger_profile_dump()
            
            if current_profile and self.baseline_profile:
                leaks = self.analyze_growth(self.baseline_profile, current_profile)
                if leaks:
                    self._alert_memory_leaks(leaks)
    
    def analyze_growth(self, base_profile: str, current_profile: str) -> List[Dict]:
        """Analyze memory growth between profiles"""
        try:
            cmd = [
                "jeprof", 
                "--base", base_profile,
                "--text", current_profile
            ]
            
            result = subprocess.run(cmd, capture_output=True, text=True)
            return self._parse_jeprof_output(result.stdout)
            
        except FileNotFoundError:
            # jeprof not available, try manual analysis
            return self._manual_profile_diff(base_profile, current_profile)
    
    def _parse_jeprof_output(self, output: str) -> List[Dict]:
        """Parse jeprof text output for memory leaks"""
        leaks = []
        lines = output.strip().split('\n')
        
        # Skip header lines
        data_started = False
        for line in lines:
            if line.startswith('Total:'):
                data_started = True
                continue
            
            if not data_started or not line.strip():
                continue
                
            parts = line.split()
            if len(parts) >= 6:
                try:
                    # Parse: growth_mb growth_pct alloc_mb alloc_pct function
                    growth_mb = float(parts[0])
                    growth_pct = float(parts[1].rstrip('%'))
                    function_name = ' '.join(parts[4:])
                    
                    if growth_mb > 1.0:  # >1MB growth threshold
                        leaks.append({
                            "growth_mb": growth_mb,
                            "growth_percentage": growth_pct,
                            "function": function_name,
                            "severity": self._calculate_leak_severity(growth_mb, growth_pct)
                        })
                except (ValueError, IndexError):
                    continue
        
        return sorted(leaks, key=lambda x: x["growth_mb"], reverse=True)
    
    def _calculate_leak_severity(self, growth_mb: float, growth_pct: float) -> str:
        """Calculate leak severity based on growth metrics"""
        if growth_mb > 100 or growth_pct > 50:
            return "critical"
        elif growth_mb > 10 or growth_pct > 20:
            return "high"
        elif growth_mb > 1 or growth_pct > 10:
            return "medium"
        else:
            return "low"
    
    def _get_latest_profile(self) -> Optional[str]:
        """Find the most recent profile file"""
        profiles = list(self.profile_dir.glob("app.*"))
        if profiles:
            return str(max(profiles, key=lambda p: p.stat().st_mtime))
        return None
    
    def _alert_memory_leaks(self, leaks: List[Dict]) -> None:
        """Send alerts for detected memory leaks"""
        critical_leaks = [l for l in leaks if l["severity"] == "critical"]
        
        if critical_leaks:
            message = f"CRITICAL: Memory leaks detected in PID {self.target_pid}:\n"
            for leak in critical_leaks[:5]:  # Top 5 leaks
                message += f"  - {leak['function']}: {leak['growth_mb']:.1f}MB growth\n"
            
            # Send alert (implement your alerting mechanism)
            print(message)

class ContinuousMemoryMonitor:
    def __init__(self, process_list: List[int], 
                 alert_threshold_mb: float = 50.0,
                 check_interval_minutes: int = 15):
        self.processes = process_list
        self.alert_threshold = alert_threshold_mb * 1024 * 1024  # Convert to bytes
        self.check_interval = check_interval_minutes
        self.baselines = {}
        
    def start_monitoring(self):
        """Start continuous memory leak monitoring"""
        # Establish baselines
        for pid in self.processes:
            profiler = JemallocProfiler(pid)
            profiler.enable_profiling()
            baseline = profiler.dump_profile()
            if baseline:
                self.baselines[pid] = baseline
        
        # Monitor for growth
        while True:
            time.sleep(self.check_interval * 60)
            self._check_for_leaks()
    
    def _check_for_leaks(self):
        """Check all processes for memory leaks"""
        for pid in self.processes:
            try:
                profiler = JemallocProfiler(pid)
                current_profile = profiler.dump_profile()
                
                if current_profile and pid in self.baselines:
                    growth_analysis = profiler.analyze_growth(
                        self.baselines[pid], 
                        current_profile
                    )
                    
                    # Check for significant growth
                    total_growth = sum(leak["growth_bytes"] 
                                     for leak in growth_analysis["potential_leaks"])
                    
                    if total_growth > self.alert_threshold:
                        self._send_leak_alert(pid, growth_analysis)
                        
                        # Update baseline if growth is persistent
                        self.baselines[pid] = current_profile
                        
            except Exception as e:
                print(f"Error monitoring PID {pid}: {e}")
    
    def _send_leak_alert(self, pid: int, analysis: Dict):
        """Send memory leak alert"""
        alert_data = {
            "timestamp": time.time(),
            "pid": pid,
            "leaks": analysis["potential_leaks"][:10],  # Top 10 leaks
            "total_growth_mb": sum(l["growth_bytes"] for l in analysis["potential_leaks"]) / (1024*1024)
        }
        
        # Implement your alerting mechanism here
        # Examples: PagerDuty, Slack, email, etc.
        print(f"ALERT: Memory leak detected in PID {pid}")
        print(f"Total growth: {alert_data['total_growth_mb']:.1f} MB")

def collect_jemalloc_metrics(pid: int) -> Dict[str, float]:
    """Collect jemalloc memory metrics via gdb injection"""
    metrics = {}
    
    gdb_script = f"""
    attach {pid}
    call (long)mallctl("stats.allocated", &{{long}}{{0}}, &{{size_t}}{{sizeof(long)}}, 0, 0)
    call (long)mallctl("stats.active", &{{long}}{{0}}, &{{size_t}}{{sizeof(long)}}, 0, 0)
    call (long)mallctl("stats.metadata", &{{long}}{{0}}, &{{size_t}}{{sizeof(long)}}, 0, 0)
    call (long)mallctl("stats.resident", &{{long}}{{0}}, &{{size_t}}{{sizeof(long)}}, 0, 0)
    call (long)mallctl("stats.mapped", &{{long}}{{0}}, &{{size_t}}{{sizeof(long)}}, 0, 0)
    detach
    quit
    """
    
    try:
        result = subprocess.run(
            ["gdb", "-batch", "-ex", gdb_script],
            capture_output=True, text=True, timeout=30
        )
        
        # Parse gdb output for metric values
        metrics = parse_gdb_mallctl_output(result.stdout)
        
    except subprocess.TimeoutExpired:
        pass
    
    return metrics

def parse_gdb_mallctl_output(output: str) -> Dict[str, float]:
    """Parse gdb mallctl output for metrics"""
    # Implementation would parse gdb output format
    # This is a simplified version
    return {
        "allocated_bytes": 0,
        "active_bytes": 0,
        "metadata_bytes": 0,
        "resident_bytes": 0,
        "mapped_bytes": 0
    }

from prometheus_client import Gauge, Counter, start_http_server

# Define Prometheus metrics
memory_allocated = Gauge('jemalloc_allocated_bytes', 'Currently allocated memory', ['pid'])
memory_growth = Gauge('jemalloc_growth_bytes', 'Memory growth since baseline', ['pid'])
leak_detections = Counter('jemalloc_leaks_detected_total', 'Number of leaks detected', ['pid', 'severity'])

def export_metrics_to_prometheus(pid: int, metrics: Dict[str, float]):
    """Export jemalloc metrics to Prometheus"""
    memory_allocated.labels(pid=str(pid)).set(metrics.get('allocated_bytes', 0))
    memory_growth.labels(pid=str(pid)).set(metrics.get('growth_bytes', 0))
    
    # Increment leak counter based on severity
    for severity in ['low', 'medium', 'high', 'critical']:
        if metrics.get(f'{severity}_leaks', 0) > 0:
            leak_detections.labels(pid=str(pid), severity=severity).inc(
                metrics[f'{severity}_leaks']
            )

# Start Prometheus metrics server
start_http_server(8000)

import time
import psutil

def measure_profiling_overhead(pid: int, duration_seconds: int = 60):
    """Measure performance impact of jemalloc profiling"""
    process = psutil.Process(pid)
    
    # Baseline measurement (profiling disabled)
    cpu_before = process.cpu_percent()
    memory_before = process.memory_info().rss
    
    # Enable profiling
    profiler = JemallocProfiler(pid)
    profiler.enable_profiling()
    
    # Measure with profiling enabled
    time.sleep(duration_seconds)
    cpu_after = process.cpu_percent()
    memory_after = process.memory_info().rss
    
    overhead = {
        "cpu_overhead_percent": cpu_after - cpu_before,
        "memory_overhead_bytes": memory_after - memory_before,
        "duration_seconds": duration_seconds
    }
    
    return overhead