"""Reusable official base-policy loading for local Phase 4 interface checks.

Only construction/loading changes: parameters are constructed on meta and loaded
in the requested dtype on CPU before official device placement. The upstream
inference implementation, action transform, and websocket protocol are retained.
This is a base checkpoint, not a RoboTwin-finetuned evaluation checkpoint.
"""

import contextlib
import hashlib
import json
import os
from pathlib import Path
import sys
import threading


ROOT = Path(__file__).resolve().parents[1]
DEFAULT_UPSTREAM = ROOT / "third_party/lingbot-vla-v2"
_CONSTRUCTION_LOCK = threading.RLock()


@contextlib.contextmanager
def upstream_working_directory(path):
    previous = Path.cwd()
    os.chdir(path)
    try:
        yield
    finally:
        os.chdir(previous)


def prepare_base_runtime(base_path, qwen_path, norm_stats_path, runtime_dir, upstream=DEFAULT_UPSTREAM):
    """Build the directory topology expected by the unchanged official loader."""
    import yaml

    base_path = Path(base_path).resolve()
    qwen_path = Path(qwen_path).resolve()
    norm_stats_path = Path(norm_stats_path).resolve()
    runtime_dir = Path(runtime_dir).resolve()
    upstream = Path(upstream).resolve()
    index_path = base_path / "model.safetensors.index.json"
    index = json.loads(index_path.read_text())
    if not index.get("weight_map"):
        raise ValueError("Checkpoint index has no weight_map")
    shard_names = sorted(set(index["weight_map"].values()))
    if any(Path(name).name != name or not name.endswith(".safetensors") for name in shard_names):
        raise ValueError("Expected plain safetensors shard filenames in checkpoint index")
    for name in shard_names:
        if not (base_path / name).is_file():
            raise FileNotFoundError(base_path / name)
    if not (qwen_path / "config.json").is_file() or not norm_stats_path.is_file():
        raise FileNotFoundError("Qwen config and normalization statistics must exist locally")
    # Fused MoE weights contain 3D experts.*_proj; eager uses experts.N.*.weight.
    eager_keys = [key for key in index["weight_map"] if ".experts." in key and key.endswith(".weight")]
    fused_keys = [key for key in index["weight_map"] if ".experts." in key and key.endswith((".gate_proj", ".up_proj", ".down_proj"))]
    if eager_keys or not fused_keys:
        raise ValueError("This base loader expects the released fused-MoE checkpoint; no automatic key conversion is performed")
    cfg = yaml.safe_load((upstream / "configs/vla/robotwin/robotwin.yaml").read_text())
    if cfg["model"].get("moe_implementation") != "fused":
        raise ValueError("Official runtime configuration must retain fused MoE for these weights")
    cfg["model"]["model_path"] = str(base_path)
    cfg["model"]["tokenizer_path"] = str(qwen_path)
    # The training argument parser serializes these dict-like values as strings.
    for key in ("joints", "norm_type"):
        cfg["data"][key] = [str(value) for value in cfg["data"][key]]
    cfg["data"]["norm_stats_file"] = str(norm_stats_path)
    cfg["data"]["img_size"] = 256
    cfg["train"]["use_compile"] = False
    hf_checkpoint = runtime_dir / "checkpoints/global_step_0/hf_ckpt"
    hf_checkpoint.mkdir(parents=True, exist_ok=True)
    for name in shard_names + [index_path.name]:
        target = base_path / name
        link = hf_checkpoint / name
        if link.exists() or link.is_symlink():
            if not link.is_symlink() or link.resolve() != target:
                raise FileExistsError(f"Runtime checkpoint entry conflicts with requested source: {link}")
        else:
            link.symlink_to(target)
    configuration_path = runtime_dir / "lingbotvla_cli.yaml"
    configuration_text = yaml.safe_dump(cfg, sort_keys=False)
    if configuration_path.exists() and configuration_path.read_text() != configuration_text:
        raise FileExistsError(f"Use a fresh runtime directory for changed configuration: {runtime_dir}")
    configuration_path.write_text(configuration_text)
    provenance = {"base_path": str(base_path), "qwen_path": str(qwen_path),
        "norm_stats_path": str(norm_stats_path), "upstream": str(upstream),
        "checkpoint_index_sha256": hashlib.sha256(index_path.read_bytes()).hexdigest(),
        "checkpoint_tensor_count": len(index["weight_map"]), "checkpoint_shard_count": len(shard_names),
        "checkpoint_expert_layout": "fused", "fused_expert_tensor_count": len(fused_keys),
        "base_checkpoint_only": True, "robotwin_finetuning_performed": False}
    (runtime_dir / "runtime_source.json").write_text(json.dumps(provenance, indent=2) + "\n")
    return hf_checkpoint, provenance


def streaming_server_class(upstream=DEFAULT_UPSTREAM):
    """Return a subclass with the official constructor, infer, and reset interface."""
    import torch
    from accelerate import init_empty_weights
    from safetensors import safe_open

    upstream = Path(upstream).resolve()
    if str(upstream) not in sys.path:
        sys.path.insert(0, str(upstream))
    import deploy.lingbot_vla_v2_policy as official

    class StreamingBaseServer(official.LingbotVLAv2Server):
        def __init__(self, *args, **kwargs):
            # Official use_bf16 is positional argument 6, default True.
            use_bf16 = kwargs.get("use_bf16", args[6] if len(args) > 6 else True)
            self._checkpoint_dtype = torch.bfloat16 if use_bf16 else torch.float32
            with upstream_working_directory(upstream):
                super().__init__(*args, **kwargs)

        def load_vla(self, path_to_pi_model):
            with _CONSTRUCTION_LOCK, upstream_working_directory(upstream):
                original = official.LingBotVlaV2InferencePolicy

                def empty_constructor(*args, **kwargs):
                    # Keep initialized buffers on CPU. Meta is only for parameters;
                    # putting nonpersistent rotary buffers on meta loses their values.
                    with init_empty_weights(include_buffers=False):
                        return original(*args, **kwargs)

                official.LingBotVlaV2InferencePolicy = empty_constructor
                try:
                    return super().load_vla(path_to_pi_model)
                finally:
                    official.LingBotVlaV2InferencePolicy = original

        def load_model_weights(self, path_to_pi_model, strict=True):
            if not strict:
                raise ValueError("The base-policy wrapper requires strict checkpoint loading")
            path = Path(path_to_pi_model)
            index = json.loads((path / "model.safetensors.index.json").read_text())
            expected = self.vla.state_dict()
            index_keys = set(index["weight_map"])
            if set(expected) != index_keys:
                missing = sorted(set(expected) - index_keys)
                unexpected = sorted(index_keys - set(expected))
                raise ValueError(f"Checkpoint/model key mismatch before tensor loading; missing={missing[:20]}, unexpected={unexpected[:20]}")
            tensors = {}
            for name in sorted(set(index["weight_map"].values())):
                with safe_open(path / name, framework="pt", device="cpu") as shard:
                    for key in shard.keys():
                        if key in tensors:
                            raise ValueError(f"Duplicate checkpoint key: {key}")
                        if key not in expected or index["weight_map"].get(key) != name:
                            raise ValueError(f"Unexpected checkpoint key/shard assignment: {key} in {name}")
                        tensor = shard.get_tensor(key)
                        if tensor.shape != expected[key].shape:
                            raise ValueError(f"Checkpoint shape mismatch: {key}, {tensor.shape} != {expected[key].shape}")
                        tensors[key] = tensor.to(self._checkpoint_dtype) if tensor.is_floating_point() else tensor
                print("Loaded shard", name, flush=True)
            result = self.vla.load_state_dict(tensors, strict=True, assign=True)
            if result.missing_keys or result.unexpected_keys:
                raise ValueError(f"Strict checkpoint load failed: {result}")
            remaining_meta = [name for name, value in list(self.vla.named_parameters()) + list(self.vla.named_buffers()) if value.is_meta]
            if remaining_meta:
                raise ValueError(f"Uninitialized meta tensors after strict loading: {remaining_meta[:20]}")
            self.loaded_parameter_count = sum(param.numel() for param in self.vla.parameters())
            self.loaded_tensor_count = len(tensors)
            print("Strict load complete; parameters", self.loaded_parameter_count, "tensors", self.loaded_tensor_count, flush=True)

        def reset(self, robo_name, path_to_pi_model=None):
            # Upstream reset resolves configs/robot_configs relative to cwd.
            with upstream_working_directory(upstream):
                return super().reset(robo_name, path_to_pi_model)

    return StreamingBaseServer


def load_base_policy(base_path, qwen_path, norm_stats_path, runtime_dir,
        upstream=DEFAULT_UPSTREAM, use_bf16=True, use_compile=False,
        use_length=50, chunk_ret=True, robo_name="robotwin"):
    """Strictly load and reset the official policy; `.infer()` stays upstream's."""
    qwen_path = Path(qwen_path).resolve()
    norm_stats_path = Path(norm_stats_path).resolve()
    os.environ["QWEN3VL_PATH"] = str(qwen_path)
    os.environ.setdefault("HF_HUB_OFFLINE", "1")
    os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
    checkpoint, provenance = prepare_base_runtime(base_path, qwen_path,
        norm_stats_path, runtime_dir, upstream=upstream)
    server_type = streaming_server_class(upstream)
    policy = server_type(path_to_pi_model=str(checkpoint), robot_norm_path=str(norm_stats_path),
        use_bf16=use_bf16, use_fp32=not use_bf16, use_compile=use_compile,
        use_length=use_length, chunk_ret=chunk_ret)
    policy.reset(robo_name)
    policy.phase4_source = provenance
    return policy