from __future__ import annotations

import argparse
from typing import Any


def build_llm(args: argparse.Namespace) -> Any:
    from vllm import LLM

    llm_kwargs: dict[str, Any] = {
        "model": args.model,
        "tokenizer": args.tokenizer or args.model,
        "tensor_parallel_size": args.tensor_parallel_size,
        "dtype": args.dtype,
        "max_model_len": args.max_model_len,
        "gpu_memory_utilization": args.gpu_memory_utilization,
        "trust_remote_code": args.trust_remote_code,
        "enforce_eager": args.enforce_eager,
        "enable_prefix_caching": args.enable_prefix_caching,
    }
    if args.max_num_batched_tokens is not None:
        llm_kwargs["max_num_batched_tokens"] = args.max_num_batched_tokens
    if args.max_num_seqs is not None:
        llm_kwargs["max_num_seqs"] = args.max_num_seqs
    if args.seed is not None:
        llm_kwargs["seed"] = args.seed
    return LLM(**llm_kwargs)


def build_sampling_params(args: argparse.Namespace) -> Any:
    from vllm import SamplingParams

    return SamplingParams(
        temperature=args.temperature,
        top_p=args.top_p,
        top_k=args.top_k,
        max_tokens=args.max_tokens,
        skip_special_tokens=True,
    )


def load_tokenizer(args: argparse.Namespace) -> Any:
    from transformers import AutoTokenizer

    return AutoTokenizer.from_pretrained(
        args.tokenizer or args.model,
        trust_remote_code=args.trust_remote_code,
    )


def apply_chat_template(tokenizer: Any, messages: list[dict[str, str]], *, enable_thinking: bool) -> str:
    kwargs = {"tokenize": False, "add_generation_prompt": True}
    try:
        return tokenizer.apply_chat_template(messages, enable_thinking=enable_thinking, **kwargs)
    except TypeError as exc:
        message = str(exc)
        if "enable_thinking" not in message and "unexpected" not in message:
            raise
        return tokenizer.apply_chat_template(messages, **kwargs)


def generate_reply(
    *,
    llm: Any,
    tokenizer: Any,
    sampling_params: Any,
    messages: list[dict[str, str]],
    enable_thinking: bool,
) -> str:
    replies = generate_replies(
        llm=llm,
        tokenizer=tokenizer,
        sampling_params=sampling_params,
        message_batches=[messages],
        enable_thinking=enable_thinking,
    )
    return replies[0] if replies else ""


def generate_replies(
    *,
    llm: Any,
    tokenizer: Any,
    sampling_params: Any,
    message_batches: list[list[dict[str, str]]],
    enable_thinking: bool,
) -> list[str]:
    prompts = [
        apply_chat_template(tokenizer, messages, enable_thinking=enable_thinking)
        for messages in message_batches
    ]
    request_outputs = llm.generate(prompts, sampling_params, use_tqdm=False)
    replies: list[str] = []
    for request_output in request_outputs:
        if not request_output.outputs:
            replies.append("")
            continue
        replies.append(request_output.outputs[0].text.strip())
    return replies