"""Shared batched generation and measured, log-friendly progress (no prompt text)."""
import gc
import inspect
import sys
import threading
import time
from itertools import groupby

from token_cache import padded_batch


class Progress:
    def __init__(self, label, total=0, quiet=False, interval=5):
        self.label, self.total, self.quiet = label, total, quiet
        self.interval = interval
        self.done = self.tokens = 0
        self.stage = 'starting'
        self.started = time.monotonic()
        self.last = 0.0
        self.lock = threading.RLock()
        self.stop = threading.Event()

    def update(self, stage=None, done=None, tokens=None, force=False):
        with self.lock:
            if stage is not None:
                self.stage = stage
            if done is not None:
                self.done = done
            if tokens is not None:
                self.tokens = tokens
            self.render(force)

    def render(self, force=False):
        now = time.monotonic()
        if self.quiet or (not force and now-self.last < self.interval):
            return
        self.last = now
        elapsed = max(now-self.started, 1e-6)
        rate = self.done/elapsed
        eta = f'{(self.total-self.done)/rate:.0f}s' if rate and self.total else 'pending'
        print(f'{self.label}: {self.stage} | {self.done}/{self.total} complete | '
              f'{self.tokens} generated tokens | {rate:.2f}/s | elapsed {elapsed:.0f}s | ETA {eta}',
              file=sys.stderr, flush=True)

    def __enter__(self):
        self.update(force=True)
        def heartbeat():
            while not self.stop.wait(self.interval):
                with self.lock:
                    self.render()
        self.thread = threading.Thread(target=heartbeat, daemon=True)
        if not self.quiet:
            self.thread.start()
        return self

    def __exit__(self, kind, value, tb):
        self.stop.set()
        if self.thread.is_alive():
            self.thread.join(timeout=1)
        self.update(stage='failed' if kind else 'finished', force=True)


def eos_ids(model, tokenizer):
    value = getattr(model.generation_config, 'eos_token_id', None)
    if value is None:
        value = tokenizer.eos_token_id
    return set(value if isinstance(value, (list, tuple)) else [] if value is None else [value])


class TokenProgress:
    """Transformers streamer: count actual decode steps without decoding text."""
    def __init__(self, progress, batch_size, eos, base_tokens=0):
        self.progress = progress
        self.active = [True]*batch_size
        self.eos = eos
        self.first = True
        self.count = 0
        self.base = base_tokens

    def put(self, value):
        if self.first:  # Initial prompt (or decoder-start IDs), not generated tokens.
            self.first = False
            return
        values = value.tolist()
        for i, token in enumerate(values):
            if self.active[i]:
                self.count += 1
                if token in self.eos:
                    self.active[i] = False
        self.progress.update(stage='decoding', tokens=self.base+self.count)

    def end(self):
        pass


def trim_after_eos(sequences, eos):
    result = []
    for tokens in sequences:
        end = next((i+1 for i,t in enumerate(tokens) if t in eos), len(tokens))
        result.append(tokens[:end])
    return result


def generate_batches(model, tokenizer, compiled, rows, budget_for, batch_size, emit,
                     progress, is_seq2seq=False, keep_special_tokens=False):
    """Length/budget buckets, KV cache, greedy decoding, and CUDA OOM backoff."""
    import torch
    ordered = sorted(rows, key=lambda q: (budget_for(q), len(compiled[q['id']]['input_ids'])))
    eos = eos_ids(model, tokenizer)
    done = tokens_done = 0
    effective_batch = batch_size
    stats = dict(batches=0, oom_retries=0, generated_tokens=0, input_tokens=0, padded_input_tokens=0, eos_completions=0, token_limit_completions=0,
                 token_limit_question_ids=[])
    # Models exposing this documented optimization need only the next-token logits
    # during generation, not a vocabulary projection for every prefill position.
    generation_options = {}
    forward = getattr(model, 'forward', None)
    if forward is not None and not is_seq2seq:
        parameters = inspect.signature(forward).parameters
        for name in ('logits_to_keep', 'num_logits_to_keep'):
            if name in parameters:
                generation_options[name] = 1
                break
    stats['last_token_logits'] = bool(generation_options)
    # Tokenizers can emit segment IDs even when their paired model rejects them.
    # Keep cached IDs intact, but pass them only to models declaring support.
    include_token_types = any(
        method is not None and 'token_type_ids' in inspect.signature(method).parameters
        for method in (forward, getattr(model, 'prepare_inputs_for_generation', None))
    )

    def generate(group, budget):
        data = padded_batch([compiled[q['id']] for q in group], tokenizer.pad_token_id,
                            tokenizer.padding_side, include_token_types=include_token_types)
        width = data['input_ids'].shape[1]
        device = model.get_input_embeddings().weight.device
        data = {k:v.to(device) for k,v in data.items()}
        progress.update(stage=f'prefill batch={len(group)} input_width={width}', force=True)
        stream = TokenProgress(progress, len(group), eos, tokens_done)
        # Explicit defaults prevent a checkpoint's sampling/beam config changing the task.
        output = model.generate(**data, max_new_tokens=budget, do_sample=False, num_beams=1,
                                num_return_sequences=1, pad_token_id=tokenizer.pad_token_id,
                                use_cache=True, streamer=stream, return_dict_in_generate=False,
                                output_scores=False, **generation_options)
        prefix = 1 if is_seq2seq else width
        sequences = trim_after_eos(output[:, prefix:].tolist(), eos)
        answers = tokenizer.batch_decode(sequences, skip_special_tokens=not keep_special_tokens,
                                         clean_up_tokenization_spaces=False)
        if len(answers) != len(group):
            raise RuntimeError('Generation returned an unexpected number of sequences')
        return answers, [len(s) for s in sequences], width, [bool(s and s[-1] in eos) for s in sequences]

    with torch.inference_mode():
        for budget, family in groupby(ordered, key=budget_for):
            family = list(family)
            offset = 0
            while offset < len(family):
                group = family[offset:offset+effective_batch]
                try:
                    answers, lengths, width, ended = generate(group, budget)
                except torch.cuda.OutOfMemoryError:
                    if len(group) == 1:
                        raise
                    effective_batch = max(1, len(group)//2)
                    stats['oom_retries'] += 1
                    progress.update(stage=f'CUDA OOM; retry batch={effective_batch}', tokens=tokens_done, force=True)
                else:
                    emit([(q['id'], text, length) for q,text,length in zip(group,answers,lengths)])
                    done += len(group)
                    tokens_done += sum(lengths)
                    stats['batches'] += 1
                    stats['eos_completions'] += sum(ended)
                    limited = [q['id'] for q,n,end in zip(group,lengths,ended) if n >= budget and not end]
                    stats['token_limit_completions'] += len(limited)
                    stats['token_limit_question_ids'] = (stats['token_limit_question_ids'] + limited)[:25]
                    stats['input_tokens'] += sum(len(compiled[q['id']]['input_ids']) for q in group)
                    stats['padded_input_tokens'] += width*len(group)
                    progress.update(stage='batch saved', done=done, tokens=tokens_done, force=True)
                    offset += len(group)
                    continue
                # Release the exception traceback (and its tensors) before GC.
                gc.collect()
                if torch.cuda.is_available():
                    torch.cuda.empty_cache()
    stats.update(generated_tokens=tokens_done, final_batch_size=effective_batch)
    return stats