from __future__ import annotations

import argparse
import hashlib
import json
import os
import re
import sys
from collections import Counter
from pathlib import Path
from typing import Any

import numpy as np
from datasets import load_dataset
from tqdm import tqdm
from transformers import AutoTokenizer

from kawk50m.chat import ROLE_HEADERS, build_assistant_examples, parse_chatml
from kawk50m.cli import configure_utf8_stdio
from kawk50m.text import FilterConfig, measure_text, normalize_text, rejection_reason


CODE_FENCE_RE = re.compile(r"```|~~~")
LATEX_RE = re.compile(
    r"\$\$|\\(?:begin|end|frac|dfrac|tfrac|sum|prod|sqrt|text|boxed)\b"
)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description=(
            "Stream a pinned Korean ChatML source and create packed SFT records "
            "whose loss mask supervises assistant responses only."
        )
    )
    parser.add_argument("--dataset", required=True)
    parser.add_argument("--data-file", action="append", default=[])
    parser.add_argument("--split", default="train")
    parser.add_argument("--revision", required=True)
    parser.add_argument("--tokenizer-dir", required=True)
    parser.add_argument("--output-dir", required=True)
    parser.add_argument("--train-tokens", type=int, required=True)
    parser.add_argument("--validation-tokens", type=int, required=True)
    parser.add_argument("--sequence-length", type=int, default=5120)
    parser.add_argument("--validation-permyriad", type=int, default=128)
    parser.add_argument("--shuffle-buffer", type=int, default=10_000)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--batch-size", type=int, default=128)
    parser.add_argument("--allowed-license", action="append", default=[])
    parser.add_argument("--exclude-source-regex")
    parser.add_argument("--resume", action="store_true")
    return parser.parse_args()


def sft_filter_config() -> FilterConfig:
    return FilterConfig(
        min_chars=30,
        max_chars=100_000,
        min_hangul_chars=10,
        min_hangul_letter_ratio=0.70,
        min_hangul_visible_ratio=0.45,
        max_digit_ratio=0.15,
        max_symbol_ratio=0.20,
        max_url_per_word=0.01,
        min_unique_line_ratio=0.50,
        min_unique_word_ratio=0.10,
        max_short_line_ratio=1.0,
        max_list_line_ratio=0.70,
        max_table_line_ratio=0.20,
        max_boilerplate_hits_per_1k=3.0,
        max_repeated_character_run=30,
        max_code_line_ratio=0.05,
        max_code_math_char_ratio=0.08,
        min_quality_score=0.55,
        strip_html=True,
        mask_pii=True,
    )


def contains_code_or_math(text: str) -> bool:
    return bool(CODE_FENCE_RE.search(text) or LATEX_RE.search(text))


def atomic_json(path: Path, value: dict[str, Any]) -> None:
    temporary = path.with_suffix(path.suffix + ".tmp")
    temporary.write_text(
        json.dumps(value, ensure_ascii=False, indent=2) + "\n",
        encoding="utf-8",
    )
    os.replace(temporary, path)


def validation_assignment(text: str, permyriad: int) -> bool:
    digest = hashlib.blake2b(text.encode("utf-8"), digest_size=8).digest()
    value = int.from_bytes(digest, "little") % 10_000
    return value < permyriad


class RecordPacker:
    def __init__(
        self,
        *,
        prefix: Path,
        sequence_length: int,
        target_tokens: int,
        pad_token_id: int,
        resume_records: int = 0,
        resume_nonpad_tokens: int = 0,
        resume_supervised_tokens: int = 0,
    ) -> None:
        self.sequence_length = sequence_length
        self.target_records = (target_tokens + sequence_length - 1) // sequence_length
        self.pad_token_id = pad_token_id
        self.input_path = Path(str(prefix) + ".input_ids.bin")
        self.mask_path = Path(str(prefix) + ".loss_mask.bin")
        self.input_path.parent.mkdir(parents=True, exist_ok=True)
        expected_tokens = resume_records * sequence_length
        for path, item_size in ((self.input_path, 2), (self.mask_path, 1)):
            if resume_records and not path.is_file():
                raise FileNotFoundError(path)
            if path.exists():
                with path.open("r+b") as handle:
                    handle.truncate(expected_tokens * item_size)
        self.input_handle = self.input_path.open("ab")
        self.mask_handle = self.mask_path.open("ab")
        self.records = resume_records
        self.nonpad_tokens = resume_nonpad_tokens
        self.supervised_tokens = resume_supervised_tokens
        self.buffer_ids: list[int] = []
        self.buffer_mask: list[int] = []

    @property
    def complete(self) -> bool:
        return self.records >= self.target_records

    @property
    def capacity_tokens(self) -> int:
        return self.records * self.sequence_length

    def add(self, input_ids: list[int], loss_mask: list[int]) -> None:
        if self.complete:
            return
        if len(input_ids) != len(loss_mask) or not input_ids:
            raise ValueError("Invalid SFT example")
        if len(input_ids) > self.sequence_length:
            raise ValueError("SFT example exceeds sequence length")
        if self.buffer_ids and len(self.buffer_ids) + len(input_ids) > self.sequence_length:
            self._write_buffer()
        if self.complete:
            return
        self.buffer_ids.extend(input_ids)
        self.buffer_mask.extend(loss_mask)
        if len(self.buffer_ids) == self.sequence_length:
            self._write_buffer()

    def _write_buffer(self) -> None:
        if not self.buffer_ids or self.complete:
            return
        used = len(self.buffer_ids)
        supervised = sum(self.buffer_mask)
        padding = self.sequence_length - used
        input_array = np.asarray(
            self.buffer_ids + [self.pad_token_id] * padding,
            dtype=np.uint16,
        )
        mask_array = np.asarray(
            self.buffer_mask + [0] * padding,
            dtype=np.uint8,
        )
        input_array.tofile(self.input_handle)
        mask_array.tofile(self.mask_handle)
        self.records += 1
        self.nonpad_tokens += used
        self.supervised_tokens += supervised
        self.buffer_ids.clear()
        self.buffer_mask.clear()

    def finalize_partial(self) -> None:
        if not self.complete:
            self._write_buffer()

    def sync(self) -> None:
        for handle in (self.input_handle, self.mask_handle):
            handle.flush()
            os.fsync(handle.fileno())

    def close(self) -> None:
        self.sync()
        self.input_handle.close()
        self.mask_handle.close()

    def state(self) -> dict[str, int]:
        return {
            "target_records": self.target_records,
            "records": self.records,
            "capacity_tokens": self.capacity_tokens,
            "nonpad_tokens": self.nonpad_tokens,
            "supervised_tokens": self.supervised_tokens,
        }


def normalize_blocks(blocks: list[tuple[str, str]]) -> list[tuple[str, str]]:
    normalized: list[tuple[str, str]] = []
    for role, content in blocks:
        cleaned = normalize_text(content, strip_html=True, mask_pii=True)
        if cleaned:
            normalized.append((role, cleaned))
    return normalized


def main() -> None:
    configure_utf8_stdio()
    args = parse_args()
    for name in (
        "train_tokens",
        "validation_tokens",
        "sequence_length",
        "shuffle_buffer",
        "batch_size",
    ):
        if getattr(args, name) <= 0:
            raise ValueError(f"--{name.replace('_', '-')} must be positive")
    if not 0 < args.validation_permyriad < 10_000:
        raise ValueError("--validation-permyriad must be between 1 and 9,999")

    output_dir = Path(args.output_dir)
    state_path = output_dir / "state.json"
    output_dir.mkdir(parents=True, exist_ok=True)
    tokenizer = AutoTokenizer.from_pretrained(
        args.tokenizer_dir, use_fast=False, legacy=True
    )
    tokenizer.model_max_length = args.sequence_length
    if len(tokenizer) > np.iinfo(np.uint16).max:
        raise ValueError("uint16 requires vocabulary <= 65,535")
    if tokenizer.pad_token_id is None:
        raise ValueError("Tokenizer must define pad_token_id")

    expected = {
        "dataset": args.dataset,
        "data_files": list(args.data_file),
        "split": args.split,
        "revision": args.revision,
        "tokenizer_vocab_size": len(tokenizer),
        "sequence_length": args.sequence_length,
        "train_tokens_requested": args.train_tokens,
        "validation_tokens_requested": args.validation_tokens,
        "validation_permyriad": args.validation_permyriad,
        "shuffle_buffer": args.shuffle_buffer,
        "seed": args.seed,
        "allowed_licenses": sorted(value.casefold() for value in args.allowed_license),
        "exclude_source_regex": args.exclude_source_regex,
    }
    if args.resume:
        if not state_path.is_file():
            raise FileNotFoundError(state_path)
        state = json.loads(state_path.read_text(encoding="utf-8"))
        for key, value in expected.items():
            if state.get(key) != value:
                raise ValueError(
                    f"Resume state mismatch for {key}: "
                    f"saved={state.get(key)!r}, requested={value!r}"
                )
        if state.get("complete"):
            print(json.dumps(state, ensure_ascii=False, indent=2))
            return
        documents_seen = int(state["documents_seen"])
        counters = Counter({key: int(value) for key, value in state["counts"].items()})
        train_state = state["train"]
        validation_state = state["validation"]
    else:
        existing = [
            output_dir / "train.input_ids.bin",
            output_dir / "train.loss_mask.bin",
            output_dir / "validation.input_ids.bin",
            output_dir / "validation.loss_mask.bin",
        ]
        if state_path.exists() or any(path.exists() for path in existing):
            raise FileExistsError(f"{output_dir} contains previous SFT data")
        documents_seen = 0
        counters: Counter[str] = Counter()
        train_state = {}
        validation_state = {}

    train = RecordPacker(
        prefix=output_dir / "train",
        sequence_length=args.sequence_length,
        target_tokens=args.train_tokens,
        pad_token_id=int(tokenizer.pad_token_id),
        resume_records=int(train_state.get("records", 0)),
        resume_nonpad_tokens=int(train_state.get("nonpad_tokens", 0)),
        resume_supervised_tokens=int(train_state.get("supervised_tokens", 0)),
    )
    validation = RecordPacker(
        prefix=output_dir / "validation",
        sequence_length=args.sequence_length,
        target_tokens=args.validation_tokens,
        pad_token_id=int(tokenizer.pad_token_id),
        resume_records=int(validation_state.get("records", 0)),
        resume_nonpad_tokens=int(validation_state.get("nonpad_tokens", 0)),
        resume_supervised_tokens=int(validation_state.get("supervised_tokens", 0)),
    )
    allowed_licenses = {value.casefold() for value in args.allowed_license}
    source_pattern = (
        re.compile(args.exclude_source_regex) if args.exclude_source_regex else None
    )
    filter_config = sft_filter_config()

    def state_value(*, complete: bool) -> dict[str, Any]:
        return {
            **expected,
            "tokenizer": str(Path(args.tokenizer_dir).resolve()),
            "documents_seen": documents_seen,
            "counts": dict(sorted(counters.items())),
            "train": train.state(),
            "validation": validation.state(),
            "complete": complete,
        }

    dataset = load_dataset(
        args.dataset,
        data_files=args.data_file or None,
        split=args.split,
        revision=args.revision,
        streaming=True,
    ).shuffle(seed=args.seed, buffer_size=args.shuffle_buffer)
    if documents_seen:
        dataset = dataset.skip(documents_seen)

    progress = tqdm(initial=documents_seen, unit="rows")
    batch: list[dict[str, Any]] = []

    def commit_batch() -> bool:
        nonlocal documents_seen
        for row in batch:
            counters["seen"] += 1
            license_name = str(row.get("license", "")).casefold()
            counters[f"license_{license_name or 'missing'}"] += 1
            if allowed_licenses and license_name not in allowed_licenses:
                counters["rejected_license"] += 1
                continue
            source_name = str(row.get("source_name", ""))
            if source_pattern and source_pattern.search(source_name):
                counters["rejected_source"] += 1
                continue
            raw_text = row.get("text")
            if not isinstance(raw_text, str):
                counters["rejected_missing_text"] += 1
                continue
            blocks = normalize_blocks(parse_chatml(raw_text))
            roles = {role for role, _ in blocks}
            if "user" not in roles or "assistant" not in roles:
                counters["rejected_chatml"] += 1
                continue
            rendered = "\n\n".join(
                ROLE_HEADERS[role] + content
                for role, content in blocks
                if role in ROLE_HEADERS
            )
            if contains_code_or_math(rendered):
                counters["rejected_explicit_code_or_math"] += 1
                continue
            reason = rejection_reason(
                rendered,
                filter_config,
                metrics=measure_text(rendered),
            )
            if reason is not None:
                counters[f"rejected_{reason}"] += 1
                continue
            packer = (
                validation
                if validation_assignment(raw_text, args.validation_permyriad)
                else train
            )
            if packer.complete:
                counters["skipped_split_complete"] += 1
                continue
            examples = list(
                build_assistant_examples(
                    blocks,
                    tokenizer,
                    max_length=args.sequence_length,
                )
            )
            if not examples:
                counters["rejected_no_assistant_example"] += 1
                continue
            for input_ids, loss_mask in examples:
                packer.add(input_ids, loss_mask)
                counters["examples"] += 1
                if packer.complete:
                    break
            counters["accepted_conversations"] += 1

        documents_seen += len(batch)
        progress.update(len(batch))
        batch.clear()
        train.sync()
        validation.sync()
        complete = train.complete and validation.complete
        atomic_json(state_path, state_value(complete=complete))
        return complete

    complete = False
    try:
        for row in dataset:
            batch.append(row)
            if len(batch) >= args.batch_size and commit_batch():
                complete = True
                break
        else:
            if batch:
                complete = commit_batch()
            train.finalize_partial()
            validation.finalize_partial()
            complete = train.complete and validation.complete
    finally:
        train.close()
        validation.close()
        progress.close()

    final_state = state_value(complete=complete)
    atomic_json(state_path, final_state)
    print(json.dumps(final_state, ensure_ascii=False, indent=2))
    if not complete:
        raise RuntimeError("Dataset ended before both SFT token targets were reached")
    sys.stdout.flush()
    sys.stderr.flush()


if __name__ == "__main__":
    main()