"""Stateless uint16 window sampling with explicit resume-compatible versions.
Version 1 preserves legacy length-weighted sampling and exclusive last offset.
Version 2 weights by valid windows and includes every valid offset (default).
"""
import json
import math
import os
from pathlib import Path
import sys
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from common.paths import PROJECT_ROOT
import numpy as np
import torch

ROOT = PROJECT_ROOT
SAMPLER_VERSION = 2
_abs = lambda p: p if os.path.isabs(p) else os.path.join(ROOT, p)


def validate_sampler_resume(metadata, requested):
    stored = metadata.get('sampler_version', metadata.get('config', {}).get('sampler_version', 1))
    if stored != requested:
        raise ValueError(f'Sampler version mismatch: checkpoint={stored}, requested={requested}. '
                         'Use the original sampler_version explicitly or start a new run directory.')


def open_tokens(path):
    path = _abs(path)
    size = os.path.getsize(path)
    if size == 0 or size % 2:
        raise ValueError(f'Expected nonempty, uint16-aligned token shard: {path}')
    return np.memmap(path, dtype=np.uint16, mode='r')


class MixSampler:
    def __init__(self, mix_path, seq_len, seed=1234, version=SAMPLER_VERSION):
        if type(seq_len) is not int or seq_len < 1:
            raise ValueError('seq_len must be a positive integer')
        if type(version) is not int or version not in (1, 2):
            raise ValueError('Unknown sampler version')
        if type(seed) is not int or seed < 0:
            raise ValueError('seed must be a nonnegative integer')
        with open(_abs(mix_path)) as f:
            mix = json.load(f)
        if not isinstance(mix.get('sources'), dict) or not mix['sources']:
            raise ValueError('Mix requires nonempty sources')
        if mix.get('sampler_version', version) != version:
            raise ValueError('Mix sampler version differs from requested version')
        self.seq_len, self.seed, self.version = seq_len, seed, version
        self.names, weights, self.shards = [], [], []
        T = seq_len + 1
        seen_paths = set()
        for name, source in mix['sources'].items():
            weight = source['weight']
            if isinstance(weight, bool) or not isinstance(weight, (int, float)) or not math.isfinite(weight) or weight <= 0:
                raise ValueError(f'Invalid positive finite weight for {name}')
            files = source.get('files')
            if not isinstance(files, list) or not files:
                raise ValueError(f'No shards for {name}')
            shards = []
            for file in files:
                path = str(Path(_abs(file)).resolve())
                if path in seen_paths:
                    raise ValueError(f'Repeated shard path: {file}')
                seen_paths.add(path)
                mm = open_tokens(path)
                windows = len(mm) - T + (1 if version == 2 else 0)
                if windows < 1:
                    raise ValueError(f'Shard too short for sampler v{version}: {file}')
                shards.append((mm, len(mm)))
            self.names.append(name);weights.append(weight);self.shards.append(shards)
        total = sum(weights)
        if not math.isfinite(total):
            raise ValueError('Weight sum must be finite')
        self.w = np.array(weights, dtype=np.float64) / total
        self.window_counts = [np.array([n - T + 1 for _, n in shards], dtype=np.int64) for shards in self.shards]
        self.shard_probabilities = [self._sizes(i) / self._sizes(i).sum() for i in range(len(self.shards))]

    def _sizes(self, i):
        if self.version == 1:
            return np.array([n for _, n in self.shards[i]], dtype=np.float64)
        return self.window_counts[i].astype(np.float64)

    def batch(self, step, rank, micro, bsz):
        if any(type(x) is not int or x < 0 for x in (step, rank, micro)) or type(bsz) is not int or bsz < 1:
            raise ValueError('Expected nonnegative step/rank/micro and positive integer batch size')
        rng = np.random.default_rng([self.seed, step, rank, micro])
        T = self.seq_len + 1
        x = np.empty((bsz, T), dtype=np.int64)
        for b in range(bsz):
            i = rng.choice(len(self.w), p=self.w)
            j = rng.choice(len(self.shards[i]), p=self.shard_probabilities[i])
            mm, n = self.shards[i][j]
            high = n - T + (1 if self.version == 2 else 0)
            o = int(rng.integers(0, high))
            x[b] = mm[o:o + T]
        x = torch.from_numpy(x)
        return x[:, :-1].contiguous(), x[:, 1:].contiguous()


class HoldoutSet:
    """Fixed next-token windows; incomplete tails are ignored for train-time probes.
    Publication PPL uses the separate full-coverage evaluator instead.
    """
    def __init__(self, files, seq_len, n_windows=64):
        if type(seq_len) is not int or seq_len < 1 or type(n_windows) is not int or n_windows < 1:
            raise ValueError('seq_len and n_windows must be positive integers')
        self.seq_len = seq_len; T = seq_len + 1
        wins = []
        for file in files:
            mm = open_tokens(file)
            for w in range(min(n_windows, len(mm) // T)):
                wins.append(np.asarray(mm[w * T:(w + 1) * T], dtype=np.int64))
        self.wins = torch.from_numpy(np.stack(wins)) if wins else None

    def __len__(self):
        return 0 if self.wins is None else len(self.wins)