from __future__ import annotations

from pathlib import Path
from typing import Any

import yaml
from transformers import LlamaConfig


def load_yaml(path: str | Path) -> dict[str, Any]:
    config_path = Path(path)
    with config_path.open("r", encoding="utf-8") as handle:
        data = yaml.safe_load(handle)
    if not isinstance(data, dict):
        raise ValueError(f"YAML root must be a mapping: {config_path}")
    return data


def _positive_int(value: Any, name: str) -> int:
    if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
        raise ValueError(f"{name} must be a positive integer, got {value!r}")
    return value


def build_llama_config(
    model_data: dict[str, Any],
    *,
    tokenizer_vocab_size: int | None = None,
) -> tuple[LlamaConfig, int | None]:
    """Validate a model mapping and return a Hugging Face LlamaConfig."""
    if "model" in model_data:
        model_data = model_data["model"]
    if not isinstance(model_data, dict):
        raise ValueError("model configuration must be a mapping")

    values = dict(model_data)
    expected_parameters = values.pop("expected_parameters", None)

    required = (
        "vocab_size",
        "hidden_size",
        "intermediate_size",
        "num_hidden_layers",
        "num_attention_heads",
        "num_key_value_heads",
        "max_position_embeddings",
    )
    for name in required:
        values[name] = _positive_int(values.get(name), name)

    if values["hidden_size"] % values["num_attention_heads"] != 0:
        raise ValueError("hidden_size must be divisible by num_attention_heads")
    if values["num_attention_heads"] % values["num_key_value_heads"] != 0:
        raise ValueError(
            "num_attention_heads must be divisible by num_key_value_heads"
        )
    if tokenizer_vocab_size is not None and values["vocab_size"] != tokenizer_vocab_size:
        raise ValueError(
            "Tokenizer/model vocabulary mismatch: "
            f"tokenizer={tokenizer_vocab_size}, model={values['vocab_size']}"
        )

    config = LlamaConfig(**values)
    return config, expected_parameters


def count_unique_parameters(model: Any) -> int:
    """Count parameters without double-counting tied tensors."""
    seen: set[int] = set()
    total = 0
    for parameter in model.parameters():
        pointer = parameter.untyped_storage().data_ptr()
        if pointer not in seen:
            seen.add(pointer)
            total += parameter.numel()
    return total