from __future__ import annotations

import math
from collections.abc import Sequence
from pathlib import Path

import numpy as np
import torch


class SFTPackedDataset:
    """Memory-map fixed-length input IDs and assistant-only loss masks."""

    def __init__(
        self,
        prefixes: str | Path | Sequence[str | Path],
        sequence_length: int,
    ) -> None:
        if sequence_length <= 0:
            raise ValueError("sequence_length must be positive")
        raw_prefixes = (
            [prefixes] if isinstance(prefixes, (str, Path)) else list(prefixes)
        )
        self.sequence_length = sequence_length
        self.inputs: list[np.memmap] = []
        self.masks: list[np.memmap] = []
        self.sequence_offsets: list[int] = []
        running_total = 0
        for raw_prefix in raw_prefixes:
            prefix = Path(raw_prefix)
            input_path = Path(str(prefix) + ".input_ids.bin")
            mask_path = Path(str(prefix) + ".loss_mask.bin")
            if not input_path.is_file() or not mask_path.is_file():
                raise FileNotFoundError(
                    f"Missing SFT pair: {input_path} and {mask_path}"
                )
            input_stream = np.memmap(input_path, mode="r", dtype=np.uint16)
            mask_stream = np.memmap(mask_path, mode="r", dtype=np.uint8)
            if len(input_stream) != len(mask_stream):
                raise ValueError(f"Input/mask length mismatch for {prefix}")
            if len(input_stream) % sequence_length != 0:
                raise ValueError(f"SFT data is not record-aligned: {prefix}")
            records = len(input_stream) // sequence_length
            if records == 0:
                raise ValueError(f"SFT data contains no records: {prefix}")
            self.inputs.append(input_stream)
            self.masks.append(mask_stream)
            running_total += records
            self.sequence_offsets.append(running_total)
        if not self.inputs:
            raise ValueError("At least one SFT data prefix is required")
        self.num_sequences = running_total
        self._affine_cache: dict[tuple[int, int], tuple[int, int]] = {}

    def __len__(self) -> int:
        return self.num_sequences

    def _locate(self, index: int) -> tuple[int, int]:
        if not 0 <= index < self.num_sequences:
            raise IndexError(index)
        previous = 0
        for stream_index, end in enumerate(self.sequence_offsets):
            if index < end:
                return stream_index, index - previous
            previous = end
        raise IndexError(index)

    def sequence(self, index: int) -> tuple[np.ndarray, np.ndarray]:
        stream_index, local_index = self._locate(index)
        start = local_index * self.sequence_length
        stop = start + self.sequence_length
        return (
            np.asarray(self.inputs[stream_index][start:stop], dtype=np.int64),
            np.asarray(self.masks[stream_index][start:stop], dtype=np.bool_),
        )

    def _affine_parameters(self, epoch: int, seed: int) -> tuple[int, int]:
        key = (epoch, seed)
        if key in self._affine_cache:
            return self._affine_cache[key]
        rng = np.random.default_rng(seed + epoch * 1_000_003)
        multiplier = int(rng.integers(1, max(self.num_sequences, 2)))
        while math.gcd(multiplier, self.num_sequences) != 1:
            multiplier += 1
            if multiplier >= self.num_sequences:
                multiplier = 1
        offset = int(rng.integers(0, self.num_sequences))
        self._affine_cache[key] = (multiplier, offset)
        return multiplier, offset

    def training_batch(
        self,
        *,
        micro_step: int,
        batch_size: int,
        rank: int,
        world_size: int,
        seed: int,
        device: torch.device,
    ) -> tuple[torch.Tensor, torch.Tensor]:
        global_batch_size = batch_size * world_size
        first = micro_step * global_batch_size + rank * batch_size
        indices = []
        for local_index in range(batch_size):
            ordinal = first + local_index
            epoch, position = divmod(ordinal, self.num_sequences)
            multiplier, offset = self._affine_parameters(epoch, seed)
            indices.append((multiplier * position + offset) % self.num_sequences)
        return self._to_tensors(indices, device)

    def evaluation_batch(
        self,
        *,
        batch_index: int,
        batch_size: int,
        rank: int,
        world_size: int,
        device: torch.device,
    ) -> tuple[torch.Tensor, torch.Tensor]:
        first = (batch_index * world_size + rank) * batch_size
        indices = [
            (first + local_index) % self.num_sequences
            for local_index in range(batch_size)
        ]
        return self._to_tensors(indices, device)

    def _to_tensors(
        self,
        indices: list[int],
        device: torch.device,
    ) -> tuple[torch.Tensor, torch.Tensor]:
        rows = [self.sequence(index) for index in indices]
        inputs = torch.from_numpy(np.stack([row[0] for row in rows]))
        masks = torch.from_numpy(np.stack([row[1] for row in rows]))
        inputs = inputs.to(device=device, dtype=torch.long, non_blocking=True)
        masks = masks.to(device=device, dtype=torch.bool, non_blocking=True)
        labels = inputs.clone()
        labels.masked_fill_(~masks, -100)
        return inputs, labels