from __future__ import annotations

import argparse
import glob
import json
import os
import shutil
from pathlib import Path
from typing import Any

import numpy as np

from kawk50m.cli import configure_utf8_stdio


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description=(
            "Build an exact-size long-context CPT mix with hard links for full "
            "uint16 shards and a bounded copy only for the final partial shard."
        )
    )
    parser.add_argument("--base-input", nargs="+", required=True)
    parser.add_argument("--structured-input", nargs="+", required=True)
    parser.add_argument("--validation-bin", required=True)
    parser.add_argument("--output-dir", required=True)
    parser.add_argument("--base-target-tokens", type=int, default=2_800_000_000)
    parser.add_argument(
        "--structured-target-tokens", type=int, default=200_000_000
    )
    return parser.parse_args()


def discover(values: list[str]) -> list[Path]:
    paths: set[Path] = set()
    for value in values:
        matches = [Path(item) for item in glob.glob(value)]
        if matches:
            paths.update(path.resolve() for path in matches if path.is_file())
        else:
            candidate = Path(value)
            if candidate.is_file():
                paths.add(candidate.resolve())
    return sorted(paths)


def token_count(path: Path) -> int:
    size = path.stat().st_size
    if size % np.dtype(np.uint16).itemsize:
        raise ValueError(f"Not a uint16 binary: {path}")
    return size // np.dtype(np.uint16).itemsize


def copy_prefix(source: Path, destination: Path, tokens: int) -> None:
    remaining = tokens * np.dtype(np.uint16).itemsize
    with source.open("rb") as input_handle, destination.open("xb") as output_handle:
        while remaining:
            block = input_handle.read(min(remaining, 16 * 1024 * 1024))
            if not block:
                raise EOFError(f"{source} ended before {tokens:,} tokens")
            output_handle.write(block)
            remaining -= len(block)


def select_shards(
    *,
    sources: list[Path],
    destination_dir: Path,
    target_tokens: int,
) -> dict[str, Any]:
    if target_tokens <= 0:
        raise ValueError("Target token count must be positive")
    destination_dir.mkdir()
    selected: list[dict[str, Any]] = []
    written = 0
    for index, source in enumerate(sources):
        available = token_count(source)
        remaining = target_tokens - written
        if remaining <= 0:
            break
        take = min(available, remaining)
        destination = destination_dir / f"{index:05d}-{source.name}"
        if take == available:
            os.link(source, destination)
            mode = "hardlink"
        else:
            destination = destination.with_name(destination.stem + "-partial.bin")
            copy_prefix(source, destination, take)
            mode = "prefix-copy"
        selected.append(
            {
                "source": str(source),
                "output": str(destination),
                "source_tokens": available,
                "tokens": take,
                "mode": mode,
            }
        )
        written += take
    if written != target_tokens:
        raise RuntimeError(
            f"Only {written:,} tokens were available for target {target_tokens:,}"
        )
    return {"tokens": written, "files": selected}


def main() -> None:
    configure_utf8_stdio()
    args = parse_args()
    output_dir = Path(args.output_dir)
    if output_dir.exists():
        raise FileExistsError(f"Refusing to overwrite {output_dir}")
    base_sources = discover(args.base_input)
    structured_sources = discover(args.structured_input)
    validation_source = Path(args.validation_bin).resolve()
    if not base_sources:
        raise FileNotFoundError("No base token shards were found")
    if not structured_sources:
        raise FileNotFoundError("No structured token shards were found")
    if not validation_source.is_file():
        raise FileNotFoundError(validation_source)

    output_dir.mkdir(parents=True)
    try:
        base = select_shards(
            sources=base_sources,
            destination_dir=output_dir / "base",
            target_tokens=args.base_target_tokens,
        )
        structured = select_shards(
            sources=structured_sources,
            destination_dir=output_dir / "structured",
            target_tokens=args.structured_target_tokens,
        )
        validation_destination = output_dir / "validation.bin"
        os.link(validation_source, validation_destination)
        manifest = {
            "dtype": "uint16",
            "base": base,
            "structured": structured,
            "validation": {
                "source": str(validation_source),
                "output": str(validation_destination),
                "tokens": token_count(validation_destination),
                "mode": "hardlink",
            },
            "total_train_tokens": base["tokens"] + structured["tokens"],
        }
        (output_dir / "manifest.json").write_text(
            json.dumps(manifest, ensure_ascii=False, indent=2) + "\n",
            encoding="utf-8",
        )
        print(json.dumps(manifest, ensure_ascii=False, indent=2))
    except BaseException:
        shutil.rmtree(output_dir)
        raise


if __name__ == "__main__":
    main()