"""Pure-Python admission checks for the common SFT LoRA adapter.

These checks deliberately run before importing PEFT or allocating a model.  An
RL plan may only consume the exact adapter shape frozen by the experiment
protocol, and a loaded model may only expose LoRA parameters as trainable.
"""

from __future__ import annotations

import json
from collections.abc import Mapping
from pathlib import Path
from typing import Any

from ..hashing import canonical_json_hash


def adapter_checkpoint_errors(
    checkpoint: str | Path,
    runtime: Mapping[str, Any],
) -> list[str]:
    """Return semantic errors for a frozen PEFT adapter checkpoint."""

    root = Path(checkpoint)
    if not root.is_dir():
        return [f"initial checkpoint is not a directory: {root}"]
    config_path = root / "adapter_config.json"
    try:
        config = json.loads(config_path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError) as exc:
        return [f"cannot read PEFT adapter_config.json: {exc}"]
    if not isinstance(config, dict):
        return ["PEFT adapter_config.json must be an object"]

    errors: list[str] = []
    expected = {
        "r": int(runtime["lora_rank"]),
        "lora_alpha": int(runtime["lora_alpha"]),
        "lora_dropout": float(runtime["lora_dropout"]),
        "bias": "none",
        "peft_type": "LORA",
        "task_type": "CAUSAL_LM",
    }
    for field, wanted in expected.items():
        if config.get(field) != wanted:
            errors.append(f"PEFT adapter {field}={config.get(field)!r}, expected {wanted!r}")

    targets = config.get("target_modules")
    if isinstance(targets, str):
        target_names = [targets]
    elif isinstance(targets, list) and all(isinstance(item, str) and item for item in targets):
        target_names = list(targets)
    else:
        target_names = []
    if not target_names:
        errors.append("PEFT adapter target_modules is empty or malformed")
    forbidden = [
        name for name in target_names if "embed" in name.lower() or "lm_head" in name.lower()
    ]
    if forbidden:
        errors.append(f"PEFT adapter targets forbidden modules: {sorted(forbidden)}")
    if config.get("modules_to_save") not in (None, []):
        errors.append("PEFT adapter modules_to_save must be empty")
    if config.get("rank_pattern") not in (None, {}):
        errors.append("PEFT adapter rank_pattern must be empty")
    if bool(config.get("use_dora", False)):
        errors.append("PEFT adapter use_dora must be false")
    base = str(config.get("base_model_name_or_path", ""))
    allowed_bases = {
        str(runtime.get("model_path", "")),
        str(Path(str(runtime.get("model_path", ""))).resolve()),
        "Qwen/Qwen3.5-2B",
    }
    if base not in allowed_bases:
        errors.append("PEFT adapter base_model_name_or_path is not the frozen base model")
    excludes = config.get("exclude_modules")
    if not isinstance(excludes, list) or "lm_head" not in excludes:
        errors.append("PEFT adapter exclude_modules must include lm_head")

    weight_candidates = (
        root / "adapter_model.safetensors",
        root / "adapter_model.bin",
    )
    if not any(path.is_file() and path.stat().st_size > 0 for path in weight_candidates):
        errors.append("PEFT adapter has no non-empty adapter_model weights")
    return errors


def trainable_parameter_manifest(model: Any) -> tuple[list[dict[str, Any]], str]:
    """Return the canonical manifest and SHA of every trainable parameter."""

    rows: list[dict[str, Any]] = []
    for name, parameter in model.named_parameters():
        if not bool(getattr(parameter, "requires_grad", False)):
            continue
        shape = [int(value) for value in getattr(parameter, "shape", ())]
        rows.append(
            {
                "name": str(name),
                "shape": shape,
                "dtype": str(getattr(parameter, "dtype", "")),
            }
        )
    rows.sort(key=lambda row: row["name"])
    return rows, canonical_json_hash(rows)


def trainable_parameter_errors(model: Any) -> list[str]:
    """Reject a loaded adapter unless only non-embedding LoRA weights train."""

    rows, _ = trainable_parameter_manifest(model)
    if not rows:
        return ["model has no trainable parameters"]
    errors: list[str] = []
    non_lora = [row["name"] for row in rows if "lora_" not in row["name"].lower()]
    if non_lora:
        errors.append(f"non-LoRA parameters are trainable: {non_lora[:8]}")
    forbidden = [
        row["name"]
        for row in rows
        if "embed" in row["name"].lower() or "lm_head" in row["name"].lower()
    ]
    if forbidden:
        errors.append(f"forbidden embedding/lm_head parameters are trainable: {forbidden[:8]}")
    return errors