from __future__ import annotations

import argparse
from collections import defaultdict
from concurrent.futures import ThreadPoolExecutor
import hashlib
import json
from pathlib import Path
import sys
import time

import torch


ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "src"))

from anima_style_probe.factor_interventions import apply_intervention  # noqa: E402
from anima_style_probe.feature_parts import completed_part_records, write_feature_part  # noqa: E402
from anima_style_probe.image_preprocess import image_tensor  # noqa: E402
from anima_style_probe.style_dataset import (  # noqa: E402
    assigned_shards,
    iter_prefetched_batches,
    iter_style_samples,
)
from extract_style_backbone_features import (  # noqa: E402
    compact_feature_map,
    forward_intermediates,
    load_model,
)


def read_jsonl(path: Path) -> list[dict]:
    with path.open(encoding="utf-8") as handle:
        return [json.loads(line) for line in handle if line.strip()]


def save_image_atomic(image, path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if path.is_file():
        return
    temporary = path.with_suffix(path.suffix + ".tmp")
    image.save(temporary, format="WEBP", quality=90, method=4)
    temporary.replace(path)


def flush_part(
    output_dir: Path,
    worker_index: int,
    part_index: int,
    full: list[torch.Tensor],
    face: list[torch.Tensor],
    face_mask: list[torch.Tensor],
    records: list[dict],
    *,
    manifest_sha256: str,
    layer_indices: list[int],
) -> None:
    write_feature_part(
        output_dir,
        "intervention",
        worker_index,
        part_index,
        {
            "full": torch.cat(full).to(torch.bfloat16),
            "face": torch.cat(face).to(torch.bfloat16),
            "face_mask": torch.cat(face_mask).to(torch.bool),
        },
        {
            "kind": "factor_intervention_full_face",
            "backbone": "siglip2_so400m",
            "layer_indices": layer_indices,
            "manifest_sha256": manifest_sha256,
            "records": records,
        },
    )


def main() -> int:
    parser = argparse.ArgumentParser(description="Extract resumable factor-intervention features.")
    parser.add_argument("--dataset-root", type=Path, required=True)
    parser.add_argument("--manifest", type=Path, required=True)
    parser.add_argument("--output-dir", type=Path, required=True)
    parser.add_argument("--worker-index", type=int, required=True)
    parser.add_argument("--num-workers", type=int, default=4)
    parser.add_argument("--batch-size", type=int, default=16)
    parser.add_argument("--source-batch-size", type=int, default=16)
    parser.add_argument("--decode-workers", type=int, default=16)
    parser.add_argument("--part-size", type=int, default=4096)
    parser.add_argument("--image-size", type=int, default=512)
    parser.add_argument("--mode", choices=("panel", "full"), default="full")
    parser.add_argument("--panel-dir", type=Path)
    parser.add_argument("--anima-pilot-dir", type=Path)
    args = parser.parse_args()
    if min(args.batch_size, args.source_batch_size, args.decode_workers, args.part_size) < 1:
        raise ValueError("batch and worker sizes must be positive")
    if not torch.cuda.is_available():
        raise RuntimeError("CUDA is required")

    manifest_sha256 = hashlib.sha256(args.manifest.read_bytes()).hexdigest()
    rows = read_jsonl(args.manifest)
    if args.mode == "panel":
        rows = [row for row in rows if row.get("panel")]
    worker_shards = {
        path.name
        for path in assigned_shards(args.dataset_root, args.worker_index, args.num_workers)
    }
    rows = [row for row in rows if row["shard"] in worker_shards]
    by_source: dict[str, list[dict]] = defaultdict(list)
    for row in rows:
        by_source[row["source_record_id"]].append(row)

    completed, part_index = completed_part_records(
        args.output_dir, "intervention", args.worker_index
    )
    for path in args.output_dir.glob(f"intervention-w{args.worker_index}-p*.json"):
        metadata = json.loads(path.read_text(encoding="utf-8"))
        if metadata.get("manifest_sha256") != manifest_sha256:
            raise RuntimeError(f"manifest mismatch with completed part: {path}")
    pending_by_source = {
        source_id: [row for row in variants if row["record_id"] not in completed]
        for source_id, variants in by_source.items()
    }
    pending_by_source = {key: value for key, value in pending_by_source.items() if value}

    device = torch.device("cuda")
    dtype = torch.bfloat16
    model, depth = load_model("siglip2_so400m", device, dtype)
    layer_indices = [round(0.25 * (depth - 1)), round(0.55 * (depth - 1)), depth - 1]
    decode_pool = ThreadPoolExecutor(
        max_workers=args.decode_workers, thread_name_prefix="intervention"
    )
    started = time.perf_counter()
    processed = 0
    full_parts: list[torch.Tensor] = []
    face_parts: list[torch.Tensor] = []
    mask_parts: list[torch.Tensor] = []
    part_records: list[dict] = []
    feature_buffer: list[tuple[torch.Tensor, torch.Tensor, bool, dict]] = []

    def decode_source(sample):
        decoded = []
        for spec in pending_by_source[sample.metadata["record_id"]]:
            full_image, face_image = apply_intervention(
                sample.full_bytes,
                sample.face_bytes,
                sample.metadata,
                spec,
                size=args.image_size,
            )
            if args.panel_dir is not None and spec.get("panel"):
                save_image_atomic(
                    full_image,
                    args.panel_dir / spec["source"] / spec["factor"] / f"{spec['record_id']}.webp",
                )
            if args.anima_pilot_dir is not None and spec.get("anima_pilot"):
                save_image_atomic(full_image, args.anima_pilot_dir / f"{spec['record_id']}.webp")
            full_tensor = image_tensor(full_image)
            face_tensor = torch.zeros_like(full_tensor) if face_image is None else image_tensor(face_image)
            record = {
                **spec,
                "source_shard": sample.shard,
                "content_id": sample.metadata.get("content_id") or sample.metadata.get("cell_id"),
                "seed": sample.metadata.get("seed"),
                "face_present": face_image is not None,
            }
            decoded.append((full_tensor, face_tensor, face_image is not None, record))
        return decoded

    def process_features(batch) -> None:
        nonlocal processed, part_index, full_parts, face_parts, mask_parts, part_records
        full_pixels, face_pixels, masks, records = map(list, zip(*batch, strict=True))
        pixels = torch.cat((torch.stack(full_pixels), torch.stack(face_pixels))).to(
            device=device, dtype=dtype
        )
        with torch.inference_mode(), torch.autocast("cuda", dtype=dtype):
            maps = forward_intermediates(model, "siglip2_so400m", pixels, layer_indices)
            compact = torch.cat(
                [
                    compact_feature_map(value, pool)
                    for value, pool in zip(maps, (2, 4, 2), strict=True)
                ],
                dim=1,
            ).to(device="cpu", dtype=torch.bfloat16)
        size = len(batch)
        full_parts.append(compact[:size])
        face_parts.append(compact[size:])
        mask_parts.append(torch.tensor(masks, dtype=torch.bool))
        part_records.extend(records)
        processed += size
        if len(part_records) >= args.part_size:
            flush_part(
                args.output_dir,
                args.worker_index,
                part_index,
                full_parts,
                face_parts,
                mask_parts,
                part_records,
                manifest_sha256=manifest_sha256,
                layer_indices=layer_indices,
            )
            part_index += 1
            full_parts, face_parts, mask_parts, part_records = [], [], [], []
        print(
            json.dumps(
                {
                    "worker": args.worker_index,
                    "new_records": processed,
                    "expected": len(rows),
                    "already_complete": len(completed),
                    "elapsed_seconds": round(time.perf_counter() - started, 1),
                }
            ),
            flush=True,
        )

    try:
        samples = iter_style_samples(
            args.dataset_root,
            worker_index=args.worker_index,
            num_workers=args.num_workers,
            include_record_ids=set(pending_by_source),
        )
        for source_batch in iter_prefetched_batches(samples, args.source_batch_size):
            for group in decode_pool.map(decode_source, source_batch):
                feature_buffer.extend(group)
                while len(feature_buffer) >= args.batch_size:
                    process_features(feature_buffer[: args.batch_size])
                    del feature_buffer[: args.batch_size]
        if feature_buffer:
            process_features(feature_buffer)
    finally:
        decode_pool.shutdown()

    if part_records:
        flush_part(
            args.output_dir,
            args.worker_index,
            part_index,
            full_parts,
            face_parts,
            mask_parts,
            part_records,
            manifest_sha256=manifest_sha256,
            layer_indices=layer_indices,
        )
    if processed + len(completed) != len(rows):
        raise RuntimeError(
            f"worker coverage mismatch: {processed} + {len(completed)} != {len(rows)}"
        )
    summary = {
        "status": "complete",
        "mode": args.mode,
        "worker_index": args.worker_index,
        "manifest_sha256": manifest_sha256,
        "records": len(rows),
        "already_complete": len(completed),
        "new_records": processed,
        "elapsed_seconds": time.perf_counter() - started,
        "peak_vram_bytes": torch.cuda.max_memory_allocated(),
    }
    path = args.output_dir / f"intervention-worker-{args.worker_index}.json"
    path.write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
    print(json.dumps(summary, indent=2))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())