#!/usr/bin/env python3
"""Slice RGC session log into 253 overlapping windows (match N4 data slices)."""
from __future__ import annotations
import argparse, os, sys
from pathlib import Path
from typing import List, Tuple

def human(n: float) -> str:
    for unit in ("B", "KB", "MB", "GB", "TB"):
        if abs(n) < 1024.0:
            return f"{n:6.1f} {unit}"
        n /= 1024.0
    return f"{n:.1f} PB"

def find_line_aligned_offset(fh, target_byte: int, search_window: int = 512 * 1024) -> int:
    file_size = fh.seek(0, os.SEEK_END)
    if target_byte <= 0:
        return 0
    if target_byte >= file_size:
        return file_size
    start = max(0, target_byte - search_window // 4)
    fh.seek(start)
    buf = fh.read(min(search_window, file_size - start))
    if not buf:
        return file_size
    if start > 0:
        nl = buf.find(b"\n")
        if nl < 0:
            return min(file_size, start + len(buf))
        buf = buf[nl + 1 :]
        start += nl + 1
    pos = start
    for line in buf.splitlines(keepends=True):
        pos += len(line)
        if pos >= target_byte:
            return min(pos, file_size)
    return min(pos, file_size)

def compute_slice_plan(file_size: int, n_slices: int, overlap_bytes: int, fh) -> List[Tuple[int, int, int, int]]:
    if file_size <= 0:
        raise ValueError("Empty log file.")
    nominal = file_size / n_slices
    pure_bounds = [0]
    for i in range(1, n_slices):
        pure_bounds.append(find_line_aligned_offset(fh, int(i * nominal)))
    pure_bounds.append(file_size)
    plan = []
    for i in range(n_slices):
        pure_start, pure_end = pure_bounds[i], pure_bounds[i + 1]
        if i == 0:
            start = pure_start
        else:
            start = min(find_line_aligned_offset(fh, max(0, pure_start - overlap_bytes)), pure_start)
        if i == n_slices - 1:
            end = pure_end
        else:
            end = find_line_aligned_offset(fh, min(file_size, pure_end + overlap_bytes))
        plan.append((i, start, end, pure_end))
    return plan

def slice_log(src: Path, outdir: Path, n_slices: int = 253, overlap_mb: float = 1.5, bufsize: int = 8 * 1024 * 1024) -> None:
    if not src.is_file():
        sys.exit(f"ERROR: source file not found: {src}")
    outdir.mkdir(parents=True, exist_ok=True)
    overlap_bytes = int(overlap_mb * 1024 * 1024)
    file_size = src.stat().st_size
    print(f"Source      : {src}")
    print(f"Size        : {human(file_size)}")
    print(f"Slices      : {n_slices}")
    print(f"Overlap     : {overlap_mb} MB  ({human(overlap_bytes)})")
    print(f"Output dir  : {outdir}\n")
    with open(src, "rb") as fh:
        plan = compute_slice_plan(file_size, n_slices, overlap_bytes, fh)
        manifest = []
        for idx, start, end, pure_end in plan:
            out_path = outdir / f"n4_log_{idx:03d}.log"
            length = end - start
            pure_start_i = 0 if idx == 0 else plan[idx - 1][3]
            lead_ov = max(0, pure_start_i - start) if idx > 0 else 0
            trail_ov = max(0, end - pure_end) if idx < n_slices - 1 else 0
            with open(out_path, "wb") as out:
                fh.seek(start)
                remaining = length
                while remaining > 0:
                    chunk = fh.read(min(bufsize, remaining))
                    if not chunk:
                        break
                    out.write(chunk)
                    remaining -= len(chunk)
            final_size = out_path.stat().st_size
            manifest.append({"idx": idx, "file": out_path.name, "start": start, "end": end, "bytes": final_size, "lead_ov": lead_ov, "trail_ov": trail_ov})
            print(f"  [{idx:03d}] {out_path.name}  {human(final_size)}  bytes {start:,}–{end:,}  lead_ov={human(lead_ov)}  trail_ov={human(trail_ov)}")
    man_path = outdir / "log_slice_manifest.csv"
    with open(man_path, "w", encoding="utf-8") as m:
        m.write("slice_idx,filename,start_byte,end_byte,file_bytes,lead_overlap_bytes,trail_overlap_bytes\n")
        for row in manifest:
            m.write(f"{row['idx']},{row['file']},{row['start']},{row['end']},{row['bytes']},{row['lead_ov']},{row['trail_ov']}\n")
    print(f"\nManifest written to {man_path}")
    print(f"Done — {n_slices} log slices.")

def main() -> None:
    p = argparse.ArgumentParser(description="Slice RGC session log into overlapping windows.")
    p.add_argument("source", type=Path)
    p.add_argument("--outdir", type=Path, default=Path("./n4_log_slices"))
    p.add_argument("--n-slices", type=int, default=253)
    p.add_argument("--overlap-mb", type=float, default=1.5)
    args = p.parse_args()
    if args.n_slices < 1 or args.overlap_mb < 0:
        sys.exit("Invalid n-slices or overlap-mb")
    slice_log(args.source, args.outdir, args.n_slices, args.overlap_mb)

if __name__ == "__main__":
    main()