"""Reference-EQUIVALENT submission for `dist-moe-a2a-dispatch` — validation only, NOT shipped.

No torch.distributed data collective and no pre-packaged fused collective: the count matrix goes through
ctx.all_gather_object (the sanctioned metadata path) and the payload through a shared MAPPED HOST buffer
(mmap of /dev/shm + cudaHostRegister PORTABLE|MAPPED) with sequence-counter flags.  Only the block destined
for the peer is published; the rank's own tokens never touch the link.
"""
import mmap
import os

import torch

MAX_BYTES = 1 << 29
_S = {}


def _map(path, nbytes, ctx, register):
    if ctx.rank == 0:
        with open(path, "wb") as f:
            f.truncate(nbytes)
    ctx.barrier()
    f = open(path, "r+b")
    mm = mmap.mmap(f.fileno(), nbytes)
    t = torch.frombuffer(mm, dtype=torch.uint8)
    if register:
        err = torch.cuda.cudart().cudaHostRegister(t.data_ptr(), nbytes, 3)
        assert int(err) == 0, f"cudaHostRegister failed: {err}"
    ctx.barrier()
    if ctx.rank == 0:
        os.unlink(path)
    return f, mm, t


def _setup(ctx):
    if "data" in _S:
        return
    tag = os.environ.get("MASTER_PORT", "0")
    _S["data"] = _map(f"/dev/shm/a2ad_data_{tag}", ctx.world_size * MAX_BYTES, ctx, True)
    _S["flag"] = _map(f"/dev/shm/a2ad_flag_{tag}", 4096, ctx, False)
    _S["flags"] = _S["flag"][2].view(torch.int64)
    _S["flags"].zero_()
    _S["seq"] = 0
    ctx.barrier()


def _wait(flags, i, seq):
    while int(flags[i]) < seq:
        pass


def moe_a2a_dispatch(x, expert_idx, num_experts, ctx):
    _setup(ctx)
    W, r = ctx.world_size, ctx.rank
    peer = 1 - r
    E, EL = num_experts, num_experts // ctx.world_size
    T, H = x.shape
    dev = x.device
    flags = _S["flags"]
    _S["seq"] += 1
    seq = _S["seq"]

    idx = expert_idx.long()
    order = torch.argsort(idx, stable=True)
    xs = x[order].contiguous()
    cnt = torch.bincount(idx, minlength=E).to(torch.int32)

    all_cnt = ctx.all_gather_object(cnt.tolist())                    # metadata only: E ints per rank
    recv = torch.tensor([[all_cnt[s][r * EL + e] for e in range(EL)] for s in range(W)],
                        dtype=torch.int32, device=dev)
    send = [sum(all_cnt[r][d * EL:(d + 1) * EL]) for d in range(W)]  # rows I send to each destination
    start = sum(send[:peer])                                         # where the peer's block sits in xs
    n_send = send[peer]

    slot = _S["data"][2].view(torch.bfloat16).view(W, -1)
    if n_send:
        slot[r][:n_send * H].view(n_send, H).copy_(xs[start:start + n_send], non_blocking=True)
    torch.cuda.synchronize()
    flags[r] = seq
    _wait(flags, peer, seq)

    rc = recv.tolist()
    n_from_peer = sum(rc[peer])
    buf = torch.empty(n_from_peer, H, dtype=x.dtype, device=dev)
    if n_from_peer:
        buf.copy_(slot[peer][:n_from_peer * H].view(n_from_peer, H), non_blocking=True)

    R = int(recv.sum())
    y = torch.empty(R, H, dtype=x.dtype, device=dev)
    mine_off = sum(send[:r])          # my own block inside xs, already expert-sorted
    peer_off = 0
    out_off = 0
    for e in range(EL):
        for s in range(W):
            n = rc[s][e]
            if n:
                if s == r:
                    y[out_off:out_off + n] = xs[mine_off:mine_off + n]
                    mine_off += n
                else:
                    y[out_off:out_off + n] = buf[peer_off:peer_off + n]
                    peer_off += n
                out_off += n
    torch.cuda.synchronize()
    flags[W + r] = seq
    _wait(flags, W + peer, seq)
    return y, recv