#!/usr/bin/env python3
"""
Parse execprog timing log and compute per-syscall execution times.
"""
import re
from pathlib import Path
from collections import defaultdict


def parse_log_line(line: str) -> tuple[str, float] | None:
    """
    Parse a log line like:
    2025/12/20 18:51:09 program 1 [/tmp/corpus/00036251...] completed in 43.79081ms

    Returns: (filepath, time_in_seconds) or None if parsing fails
    """
    # Match pattern: program N [filepath] completed in TIME
    pattern = r'program \d+ \[([^\]]+)\] completed in ([\d.]+)(ms|µs|s)'
    match = re.search(pattern, line)
    if not match:
        return None

    filepath = match.group(1)
    time_value = float(match.group(2))
    time_unit = match.group(3)

    # Convert to seconds
    if time_unit == 'ms':
        time_seconds = time_value / 1000.0
    elif time_unit == 'µs':
        time_seconds = time_value / 1000000.0
    else:  # 's'
        time_seconds = time_value

    return filepath, time_seconds


def parse_syscalls(path: Path) -> list[str]:
    """Extract syscall names from a syzkaller program file."""
    syscalls = []
    try:
        with open(path, 'r') as f:
            for line in f:
                line = line.strip()
                # Skip comments and empty lines
                if not line or line.startswith('#'):
                    continue

                # Syscalls can appear in two forms:
                # 1. With assignment: r0 = syz_init_net_socket$802154_raw(0x24, ...)
                # 2. Direct call: openat(0xffffffffffffff9c, ...)
                #                 read$dsp(r0, ...)

                # Try to match assignment form first
                match = re.match(r'^r\d+\s*=\s*([\w$]+)\s*\(', line)
                if match:
                    syscalls.append(match.group(1))
                else:
                    # Try direct call form
                    match = re.match(r'^([\w$]+)\s*\(', line)
                    if match:
                        syscalls.append(match.group(1))
    except Exception as e:
        print(f"[WARN] Failed to parse {path}: {e}")

    return syscalls


def main():
    import sys

    if len(sys.argv) < 2:
        print("Usage: ./analyze_timing.py <log_file>")
        sys.exit(1)

    log_file = Path(sys.argv[1])
    if not log_file.exists():
        print(f"Error: Log file {log_file} not found")
        sys.exit(1)

    # Parse log file
    prog_times = {}  # filepath -> time in seconds
    print(f"Parsing log file: {log_file}")

    with open(log_file, 'r') as f:
        for line in f:
            result = parse_log_line(line)
            if result:
                filepath, time_sec = result
                prog_times[filepath] = time_sec

    print(f"Found {len(prog_times)} program execution times\n")

    # Compute per-syscall times
    syscall_times = defaultdict(float)   # syscall -> total time
    syscall_counts = defaultdict(int)    # syscall -> count
    prog_results = []  # (time, filename) for ranking

    for filepath, time_sec in prog_times.items():
        path = Path(filepath)
        prog_results.append((time_sec, path.name))

        # Parse syscalls from the program file
        syscalls = parse_syscalls(path)

        if not syscalls:
            print(f"[WARN] No syscalls found in {path.name}")
            continue

        # Distribute time equally among syscalls in the program
        time_per_syscall = time_sec / len(syscalls)

        for syscall in syscalls:
            syscall_times[syscall] += time_per_syscall
            syscall_counts[syscall] += 1

    # Rank programs by execution time
    prog_results.sort()

    print("=" * 80)
    print("=== Programs ranked by execution time (fastest first) ===")
    print("=" * 80)
    for time_sec, name in prog_results[:20]:  # Show top 20
        print(f"{time_sec:10.6f} s  {name}")

    if len(prog_results) > 20:
        print(f"... and {len(prog_results) - 20} more")

    # Compute average time per syscall
    syscall_avg_times = {}
    for syscall, total_time in syscall_times.items():
        count = syscall_counts[syscall]
        syscall_avg_times[syscall] = total_time / count if count > 0 else 0

    # Rank syscalls by average time
    syscall_ranking = sorted(syscall_avg_times.items(), key=lambda x: x[1], reverse=True)

    print("\n" + "=" * 80)
    print("=== Syscalls ranked by average time (slowest first) ===")
    print("=" * 80)
    print(f"{'Syscall':<40} {'Avg Time (s)':>15} {'Count':>10} {'Total Time (s)':>15}")
    print("-" * 80)

    for syscall, avg_time in syscall_ranking:
        count = syscall_counts[syscall]
        total_time = syscall_times[syscall]
        print(f"{syscall:<40} {avg_time:>15.6f} {count:>10} {total_time:>15.6f}")

    # Summary statistics
    print("\n" + "=" * 80)
    print("=== Summary ===")
    print("=" * 80)
    print(f"Total programs analyzed: {len(prog_times)}")
    print(f"Total unique syscalls: {len(syscall_times)}")
    print(f"Total execution time: {sum(prog_times.values()):.3f} s")
    print(f"Average time per program: {sum(prog_times.values())/len(prog_times):.6f} s")


if __name__ == "__main__":
    main()