"""Rank-8 policy using explicitly assumed official RoboTwin preprocessing."""
import hashlib
import json
from pathlib import Path

ADAPTER_SHA = '51563f4e588174361ef8ad61db63a23da4ec33c0b115095375bd9323025cf5f0'
CONFIG_SHA = 'f0c1f8f2e9add85ac9bf573feba91ce52fa4bc24fb4927f175a8b7520e877449'
REVISION = '1d40e50988de2da6a07877e81a0941da3317733b'
MODEL = 'lora_r8_step10000'


def sha(path):
    h = hashlib.sha256()
    with Path(path).open('rb') as f:
        for data in iter(lambda: f.read(8 * 1024 * 1024), b''):
            h.update(data)
    return h.hexdigest()


def load_lora_policy(root, output):
    import torch
    import yaml
    from peft import LoraConfig
    from safetensors import safe_open
    from safetensors.torch import load_file
    from src.phase4_policy import prepare_base_runtime, streaming_server_class
    from src.lora_eval_loading import expand_fused_experts, inject_and_load_adapter

    root, output = Path(root), Path(output)
    adapter = root / 'outputs/lora_r8_smoke_preparation_20260929/adapter'
    if sha(adapter/'adapter_model.safetensors') != ADAPTER_SHA or sha(adapter/'adapter_config.json') != CONFIG_SHA:
        raise ValueError('Frozen adapter checksum mismatch')
    upstream = root/'third_party/lingbot-vla-v2'
    norm = upstream/'assets/norm_stats/robotwin.json'
    base = root/'checkpoints/base/lingbot-vla-v2-6b'
    # Verify the complete official base, not merely its model name or shapes.
    manifest = json.loads((root/'manifests/lingbot-vla-v2-6b.json').read_text())
    if manifest['revision'] != '11c703bf6a5c1f45b3b69168482da11fdbba53d7':
        raise ValueError('Wrong base revision')
    index = json.loads((base/'model.safetensors.index.json').read_text())
    siblings = {x['rfilename']: x for x in manifest['siblings']}
    for name in sorted(set(index['weight_map'].values())):
        if sha(base/name) != siblings[name]['lfs']['sha256']:
            raise ValueError('Base shard checksum mismatch: ' + name)
    checkpoint, provenance = prepare_base_runtime(base,
        root/'checkpoints/dependencies/Qwen3-VL-4B-Instruct', norm,
        output/'runtime', upstream=upstream)
    yaml_path = output/'runtime/lingbotvla_cli.yaml'
    cfg = yaml.safe_load(yaml_path.read_text())
    cfg['model']['moe_implementation'] = 'eager'
    yaml_path.write_text(yaml.safe_dump(cfg, sort_keys=False))

    class LoraServer(streaming_server_class(upstream)):
        def load_model_weights(self, path_to_pi_model, strict=True):
            if not strict:
                raise ValueError('Strict base loading required')
            expected = self.vla.state_dict()
            tensors = {}
            for name in sorted(set(index['weight_map'].values())):
                with safe_open(base/name, framework='pt', device='cpu') as shard:
                    raw = {}
                    for key in shard.keys():
                        if index['weight_map'].get(key) != name:
                            raise ValueError('Wrong shard assignment: ' + key)
                        t = shard.get_tensor(key)
                        raw[key] = t.float() if t.is_floating_point() else t
                    for key, t in expand_fused_experts(raw).items():
                        if key in tensors or key not in expected or t.shape != expected[key].shape:
                            raise ValueError('Converted base key/shape mismatch: ' + key)
                        tensors[key] = t
                print('Loaded and expanded base shard', name, flush=True)
            if set(tensors) != set(expected):
                raise ValueError('Converted base inventory does not match eager policy')
            self.vla.load_state_dict(tensors, strict=True, assign=True)
            if any(t.is_meta for t in list(self.vla.parameters()) + list(self.vla.buffers())):
                raise ValueError('Meta tensors remain after loading')
            self.vla = inject_and_load_adapter(self.vla,
                LoraConfig.from_pretrained(str(adapter)),
                load_file(str(adapter/'adapter_model.safetensors'), device='cpu'))
            self.loaded_parameter_count = sum(p.numel() for p in self.vla.parameters())
            self.loaded_tensor_count = len(self.vla.state_dict())
            print('Strict eager base + complete LoRA loaded', self.loaded_parameter_count, flush=True)

    policy = LoraServer(path_to_pi_model=str(checkpoint), robot_norm_path=str(norm),
        use_bf16=False, use_fp32=True, use_compile=False, use_length=50, chunk_ret=True)
    policy.reset('robotwin')
    metadata = {'checkpoint_source_kind': 'lora_adapter', 'adapter_revision': REVISION,
        'adapter_sha256': ADAPTER_SHA, 'adapter_config_sha256': CONFIG_SHA,
        'base_revision': manifest['revision'], 'base_shards_verified': True,
        'adapter_tensors_verified': 8494, 'lora_rank': 8, 'lora_alpha': 8,
        'moe_implementation': 'eager', 'training_configuration_verified': False,
        'configuration_assumption': 'User-authorized official RoboTwin model/preprocessing/normalization; eager expert layout for LoRA',
        'norm_sha256': sha(norm), 'runtime_yaml_sha256': sha(yaml_path)}
    (output/'checkpoint_verified.json').write_text(json.dumps(metadata, indent=2)+'\n')
    return policy, norm, metadata