"""Strict CPU loading helpers for the unwrapped LingBot rank-8 adapter.

These helpers do not select training preprocessing or normalization. Those must
come from the training run before constructing a policy for closed-loop use.
"""
import re


def expand_fused_experts(state):
    """Convert official [expert, out, in] weights to eager nn.Linear keys."""
    result = {}
    for name, tensor in state.items():
        match = re.fullmatch(r"(.+\.experts)\.(gate_proj|up_proj|down_proj)", name)
        if match:
            if tensor.ndim != 3:
                raise ValueError("Fused expert must have three dimensions: " + name)
            items = [(f"{match[1]}.{i}.{match[2]}.weight", value)
                     for i, value in enumerate(tensor.unbind(0))]
        else:
            items = [(name, tensor)]
        for key, value in items:
            if key in result:
                raise ValueError("Duplicate converted key: " + key)
            result[key] = value
    return result


def validate_adapter(state, targets, expected_weights, rank=8):
    """Reject partial, malformed or nonfinite adapters before policy startup."""
    import torch

    expected = {target + suffix for target in targets
                for suffix in ('.lora_A.weight', '.lora_B.weight')}
    if set(state) != expected:
        raise ValueError("Adapter key inventory differs from target modules")
    for target in targets:
        a, b = (state[target + suffix]
                for suffix in ('.lora_A.weight', '.lora_B.weight'))
        weight = expected_weights[target + '.weight']
        if (a.ndim != 2 or b.ndim != 2 or a.shape[0] != rank or
                b.shape[1] != rank or tuple(weight.shape) != (b.shape[0], a.shape[1])):
            raise ValueError("Adapter/base shape mismatch: " + target)
        if any(t.dtype != torch.float32 or not torch.isfinite(t).all().item()
               for t in (a, b)):
            raise ValueError("Adapter must contain finite FP32 values: " + target)


def inject_and_load_adapter(policy, config, state):
    """Use in-place PEFT injection and verify every loaded adapter value."""
    import torch
    from peft import inject_adapter_in_model
    from peft.utils.save_and_load import set_peft_model_state_dict

    if config.r != 8 or config.lora_alpha != 8 or config.bias != 'none':
        raise ValueError("This profile requires rank=8, alpha=8, bias=none")
    if config.modules_to_save or config.use_dora or config.use_rslora:
        raise ValueError("Unsupported adapter variant")
    validate_adapter(state, config.target_modules, policy.state_dict(), rank=config.r)
    policy = inject_adapter_in_model(config, policy, adapter_name='default')
    loaded = set_peft_model_state_dict(policy, state, adapter_name='default')
    if loaded.unexpected_keys or any('lora_' in k for k in loaded.missing_keys):
        raise ValueError("Adapter loading left missing or unexpected adapter keys")
    actual = policy.state_dict()
    for key, tensor in state.items():
        target = key.replace('.lora_A.weight', '.lora_A.default.weight').replace(
            '.lora_B.weight', '.lora_B.default.weight')
        if not torch.equal(actual[target].cpu(), tensor.cpu()):
            raise ValueError("Loaded adapter differs from source: " + key)
    policy.requires_grad_(False)
    policy.eval()
    return policy