"""Local capacity telemetry: one NVML GPU and owned Linux process trees.

CPU percentages use one logical CPU as 100%. RSS sums count shared pages once
per process and are not unique physical memory. Host MemAvailable is separate.
"""
import ctypes
import os
from pathlib import Path
import time

from eval_common import MemoryInfo

GIB = 1024 ** 3


class Utilization(ctypes.Structure):
    _fields_ = [('gpu', ctypes.c_uint), ('memory', ctypes.c_uint)]


def read_process(pid, proc_root=Path('/proc')):
    """PID plus start ticks is the identity; comm can contain spaces/parens."""
    try:
        text = (Path(proc_root) / str(pid) / 'stat').read_text()
        suffix = text[text.rfind(')') + 2:].split()
        return {'pid': int(pid), 'start_ticks': int(suffix[19]),
                'ppid': int(suffix[1]), 'pgrp': int(suffix[2]), 'session': int(suffix[3]),
                'state': suffix[0], 'cpu_ticks': int(suffix[11]) + int(suffix[12]),
                'rss_bytes': max(0, int(suffix[21])) * os.sysconf('SC_PAGE_SIZE')}
    except (OSError, ValueError, IndexError):
        return None


def process_snapshot(proc_root=Path('/proc')):
    records = {}
    for path in Path(proc_root).iterdir():
        if path.name.isdigit():
            row = read_process(int(path.name), proc_root)
            if row is not None:
                records[row['pid']] = row
    return records


def identity(row):
    return row['pid'], row['start_ticks']


def owned_processes(snapshot, roots, remembered=()):
    """Follow parent links only from matching identities; retain observed orphans."""
    known = set(roots) | set(remembered)
    selected = {pid for pid, row in snapshot.items() if identity(row) in known}
    while True:
        extra = {pid for pid, row in snapshot.items() if row['ppid'] in selected}
        if extra <= selected:
            break
        selected |= extra
    return [snapshot[pid] for pid in sorted(selected)]


class NvmlGpu:
    def __init__(self, uuid):
        if not uuid or not uuid.startswith('GPU-') or any(x.isspace() for x in uuid) or ',' in uuid:
            raise ValueError('Select one physical GPU UUID explicitly')
        self.uuid = uuid
        self.lib = ctypes.CDLL('libnvidia-ml.so.1')
        self.check(self.lib.nvmlInit_v2())
        self.handle = ctypes.c_void_p()
        self.check(self.lib.nvmlDeviceGetHandleByUUID(uuid.encode(), ctypes.byref(self.handle)))
        actual = ctypes.create_string_buffer(96)
        self.check(self.lib.nvmlDeviceGetUUID(self.handle, actual, len(actual)))
        if actual.value.decode() != uuid:
            raise RuntimeError('NVML GPU UUID mismatch')

    @staticmethod
    def check(code):
        if code:
            raise RuntimeError('NVML error ' + str(code))

    def sample(self):
        memory, utilization, power = MemoryInfo(), Utilization(), ctypes.c_uint()
        self.check(self.lib.nvmlDeviceGetMemoryInfo(self.handle, ctypes.byref(memory)))
        utilization_code = self.lib.nvmlDeviceGetUtilizationRates(self.handle, ctypes.byref(utilization))
        power_code = self.lib.nvmlDeviceGetPowerUsage(self.handle, ctypes.byref(power))
        return {'gpu_uuid': self.uuid, 'memory_used_bytes': memory.used,
                'memory_total_bytes': memory.total,
                'utilization_percent': utilization.gpu if utilization_code == 0 else None,
                'power_watts': power.value / 1000 if power_code == 0 else None,
                'optional_metric_errors': {'utilization': utilization_code, 'power': power_code}}

    def close(self):
        self.lib.nvmlShutdown()


class CapacityTelemetry:
    def __init__(self, gpu_uuid, gpu_reader=None, proc_root=Path('/proc')):
        self.gpu = gpu_reader if gpu_reader is not None else NvmlGpu(gpu_uuid)
        self.proc_root = Path(proc_root)
        self.previous = {}
        self.previous_time = None
        self.remembered = set()
        self.ticks_per_second = os.sysconf('SC_CLK_TCK')

    def sample(self, roots):
        now = time.monotonic()
        snapshot = process_snapshot(self.proc_root)
        rows = owned_processes(snapshot, roots, self.remembered)
        self.remembered = {identity(row) for row in rows}
        elapsed = None if self.previous_time is None else now - self.previous_time
        for row in rows:
            previous = self.previous.get(identity(row))
            row['cpu_percent'] = (100 * (row['cpu_ticks'] - previous) / self.ticks_per_second / elapsed
                                  if previous is not None and elapsed and elapsed > 0 else None)
        self.previous = {identity(row): row['cpu_ticks'] for row in rows}
        self.previous_time = now
        meminfo = {}
        for line in (self.proc_root / 'meminfo').read_text().splitlines():
            key, value = line.split(':', 1)
            if key in ('MemTotal', 'MemAvailable', 'SwapTotal', 'SwapFree'):
                meminfo[key + '_bytes'] = int(value.split()[0]) * 1024
        if 'MemAvailable_bytes' not in meminfo:
            raise RuntimeError('Host MemAvailable is unavailable')
        return {'monotonic': now, 'timestamp': time.time(), 'gpu': self.gpu.sample(),
                'host': meminfo, 'processes': rows,
                'process_tree_rss_bytes': sum(row['rss_bytes'] for row in rows),
                'process_tree_cpu_percent': sum(row['cpu_percent'] or 0 for row in rows),
                'cpu_sample_has_baseline': elapsed is not None,
                'rss_scope': 'Sum of RSS; shared pages can be counted repeatedly across processes.',
                'gpu_scope': 'Whole selected physical GPU, including unrelated existing workloads.'}

    def close(self):
        self.gpu.close()


def summarize_samples(rows, start, end, interval=1.0):
    scoped = [row for row in rows if start <= row['monotonic'] <= end]
    valid = [row for row in scoped if row.get('status') == 'ok']
    covered = integral = 0.0
    metrics = {'gpu_utilization_percent': ('gpu', 'utilization_percent'),
               'gpu_power_watts': ('gpu', 'power_watts'),
               'process_tree_cpu_percent': (None, 'process_tree_cpu_percent')}
    totals = {name: [0.0, 0.0] for name in metrics}
    def value(row, name):
        parent, key = metrics[name]
        if parent is None:
            return row.get(key) if row.get('cpu_sample_has_baseline') else None
        return row[parent].get(key)
    for left, right in zip(scoped, scoped[1:]):
        delta = right['monotonic'] - left['monotonic']
        if left.get('status') == right.get('status') == 'ok' and 0 < delta <= 2.5 * interval:
            integral += delta * (left['gpu']['memory_used_bytes'] + right['gpu']['memory_used_bytes']) / 2
            covered += delta
            for name in metrics:
                a, b = value(left, name), value(right, name)
                # CPU percentage is itself a rate over the preceding interval.
                if name == 'process_tree_cpu_percent' and b is not None:
                    totals[name][0] += delta * b
                    totals[name][1] += delta
                elif a is not None and b is not None:
                    totals[name][0] += delta * (a + b) / 2
                    totals[name][1] += delta
    span = end - start
    summary = {'samples': len(valid), 'failed_samples': len(scoped) - len(valid),
            'gpu_mean_memory_bytes': integral / covered if covered else None,
            'gpu_peak_memory_bytes': max((r['gpu']['memory_used_bytes'] for r in valid), default=None),
            'process_tree_peak_rss_bytes': max((r['process_tree_rss_bytes'] for r in valid), default=None),
            'host_min_available_bytes': min((r['host']['MemAvailable_bytes'] for r in valid), default=None),
            'covered_seconds': covered, 'coverage': covered / span if span > 0 else 0,
            'scope': 'One-second samples over the whole condition, not sums of overlapping episode GPU-hours.',
            'rss_note': 'Shared RSS can be counted in multiple processes; host available memory is independent.',
            'cpu_note': 'One logical CPU is 100%; first samples without a baseline are excluded. Process creation/exit between samples can omit CPU work; this is not exact cumulative CPU time.',
            'peak_note': 'Sampled peak only; gaps over 2.5 sample intervals are excluded from the mean.'}
    for name, (total, duration) in totals.items():
        observed = [value(row, name) for row in valid if value(row, name) is not None]
        summary['mean_' + name] = total / duration if duration else None
        summary['peak_' + name] = max(observed, default=None)
        summary[name + '_covered_seconds'] = duration
    return summary