import os
import warnings
from typing import Optional

import torch
import torch.distributed as dist

try:
    import horovod.torch as hvd
except ImportError:
    hvd = None


def is_global_master(args):
    return args.rank == 0


def is_local_master(args):
    return args.local_rank == 0


def is_master(args, local=False):
    return is_local_master(args) if local else is_global_master(args)


def is_device_available(device):
    device_type = torch.device(device).type
    is_avail = False
    is_known = False
    if device_type == 'cuda':
        is_avail = torch.cuda.is_available()
        is_known = True
    elif device_type == 'npu':
        # NOTE autoload device extension needed for this not to error out on this check
        is_avail = torch.npu.is_available()
        is_known = True
    elif device_type == 'mps':
        is_avail = torch.backends.mps.is_available()
        is_known = True
    elif device_type == 'cpu':
        is_avail = True
        is_known = True

    return is_avail, is_known


def set_device(device):
    if device.startswith('cuda:'):
        torch.cuda.set_device(device)
    elif device.startswith('npu:'):
        torch.npu.set_device(device)


def is_using_horovod():
    # NOTE w/ horovod run, OMPI vars should be set, but w/ SLURM PMI vars will be set
    # Differentiating between horovod and DDP use via SLURM may not be possible, so horovod arg still required...
    ompi_vars = ["OMPI_COMM_WORLD_RANK", "OMPI_COMM_WORLD_SIZE"]
    pmi_vars = ["PMI_RANK", "PMI_SIZE"]
    if all([var in os.environ for var in ompi_vars]) or all([var in os.environ for var in pmi_vars]):
        return True
    else:
        return False


def is_using_distributed():
    # 普通单卡/CPU: WORLD_SIZE 不存在
    # 启动器单卡（torchrun --nproc_per_node=1 ...）: WORLD_SIZE 存在且等于 1
    # 单机多卡、多机多卡 :  WORLD_SIZE 存在且大于 1
    # 它表示所有节点（Nodes）上的所有进程（Processes/GPUs）的总和
    if 'WORLD_SIZE' in os.environ:
        return int(os.environ['WORLD_SIZE']) > 1
    # SLURM_NTASKS 是高性能计算调度系统 Slurm (Simple Linux Utility for Resource Management) 自动生成的一个环境变量
    # 简单来说：SLURM_NTASKS 等同于深度学习中的 WORLD_SIZE
    # 它代表了整个作业（Job）中启动的总任务（Task）数，也就是所有节点上运行的进程总和
    if 'SLURM_NTASKS' in os.environ:
        return int(os.environ['SLURM_NTASKS']) > 1
    return False


def world_info_from_env():
    local_rank = 0
    for v in ('LOCAL_RANK', 'MPI_LOCALRANKID', 'SLURM_LOCALID', 'OMPI_COMM_WORLD_LOCAL_RANK'):
        if v in os.environ:
            local_rank = int(os.environ[v])
            break
    global_rank = 0
    for v in ('RANK', 'PMI_RANK', 'SLURM_PROCID', 'OMPI_COMM_WORLD_RANK'):
        if v in os.environ:
            global_rank = int(os.environ[v])
            break
    world_size = 1
    for v in ('WORLD_SIZE', 'PMI_SIZE', 'SLURM_NTASKS', 'OMPI_COMM_WORLD_SIZE'):
        if v in os.environ:
            world_size = int(os.environ[v])
            break

    return local_rank, global_rank, world_size


def init_distributed_device(args):
    # Distributed training = training on more than one GPU.
    # Works in both single and multi-node scenarios.
    # args 是 argparse.Namespace（或同样支持动态属性设置的对象），在 Python 中你可以在运行时动态给对象添加属性
    # distributed.py 的 init_distributed_device 函数里明确把这些属性初始化了（例如 args.distributed = False, args.world_size = 1 等），随后调用 init_distributed_device_so 来更新这些值。因此即使 parse_args 没有添加这些字段，后续代码仍然能访问这些属性并避免 AttributeError
    # 这样设计的好处是可以避免在 parse_args 阶段就必须定义所有可能的参数，提供了更大的灵活性
    args.distributed = False
    args.world_size = 1
    args.rank = 0  # global rank
    args.local_rank = 0
    # 不安全的写法：
    # device = args.device
    # 如果用户运行脚本时没有定义 --device 参数，或者 args 对象里根本没有 device 这个属性，程序会直接崩溃抛出 AttributeError: 'Namespace' object has no attribute 'device'
    # 这段代码的的逻辑是：“尝试去 args 里找 device。如果找到了就用它；如果找不到（或者 args 里没这东西），别报错，直接给我返回 'cuda'

    # getattr 是 Python 的一个内置函数（Built-in Function），全称是 Get Attribute
    # 它的核心作用是：根据属性的名称（字符串格式），从一个对象中获取对应的值
    # 它最强大的地方在于**“容错机制”**：如果属性不存在，它可以返回一个默认值，而不是报错
    # 但注意：getattr 是“只读”的操作。它只是把那个默认值（比如 cuda）“临时” 拿出来给你赋值给左边的变量，它绝对不会修改 args (或 conf) 对象本身，但实际上， 后续 args 对象里依然没有 device 这个属性
    result = init_distributed_device_so(
        device=getattr(args, 'device', 'cuda'),
        dist_backend=getattr(args, 'dist_backend', None),
        dist_url=getattr(args, 'dist_url', None),
        horovod=getattr(args, 'horovod', False),
        no_set_device_rank=getattr(args, 'no_set_device_rank', False),
    )
    args.device = result['device']
    args.world_size = result['world_size']
    args.rank = result['global_rank']
    args.local_rank = result['local_rank']
    args.distributed = result['distributed']
    device = torch.device(args.device)
    return device


def init_distributed_device_so(
        device: str = 'cuda',
        dist_backend: Optional[str] = None,
        dist_url: Optional[str] = None,
        horovod: bool = False,
        no_set_device_rank: bool = False,
):
    # Distributed training = training on more than one GPU.
    # Works in both single and multi-node scenarios.
    distributed = False
    world_size = 1
    global_rank = 0
    local_rank = 0
    # 尝试用冒号 : 切割字符串，且最多切 1 刀
    # 把等号右边列表 剩余的所有元素 打包成一个新的列表，赋值给 device_idx（即使剩下的元素是 0 个，也会是一个空列表）
    # 把等号右边列表的 第 1 个元素 赋值给 device_type。

    # 把等号右边列表 剩余的所有元素 打包成一个新的列表，赋值给 device_idx（即使剩下的元素是 0 个，也会是一个空列表）。
    device_type, *device_idx = device.split(':', maxsplit=1)
    is_avail, is_known = is_device_available(device_type)
    if not is_known:
        warnings.warn(f"Device {device} was not known and checked for availability, trying anyways.")
    elif not is_avail:
        warnings.warn(f"Device {device} was not available, falling back to CPU.")
        device_type = device = 'cpu'

    if horovod:
        import horovod.torch as hvd
        assert hvd is not None, "Horovod is not installed"
        hvd.init()
        local_rank = int(hvd.local_rank())
        global_rank = hvd.rank()
        world_size = hvd.size()
        distributed = True
    elif is_using_distributed():
        if dist_backend is None:
            dist_backends = {
                "cuda": "nccl",
                "hpu": "hccl",
                "npu": "hccl",
                "xpu": "ccl",
            }
            # 如果 device_type 不在字典里（比如是 cpu、mps 或者是未知的设备），就默认使用 'gloo'
            dist_backend = dist_backends.get(device_type, 'gloo')

        # 'env://' 代表 Environment Variable（环境变量）初始化模式
        # 当你把 dist_url 设置为 'env://' 时，PyTorch 会自动去读取操作系统中的以下两个环境变量来建立连接：
        # MASTER_ADDR: 这个变量指定了主节点（Master Node）的 IP 地址或主机名。所有其他节点都会连接到这个地址。（主节点（Rank 0）的 IP 地址）
        # MASTER_PORT: 主节点开放的一个空闲端口号。 其他节点通过这个端口与主节点进行通信。
        dist_url = dist_url or 'env://'

        if 'SLURM_PROCID' in os.environ:
            # DDP via SLURM
            local_rank, global_rank, world_size = world_info_from_env()
            # SLURM var -> torch.distributed vars in case needed
            os.environ['LOCAL_RANK'] = str(local_rank)
            os.environ['RANK'] = str(global_rank)
            os.environ['WORLD_SIZE'] = str(world_size)
            torch.distributed.init_process_group(
                backend=dist_backend,
                init_method=dist_url,
                world_size=world_size,
                rank=global_rank,
            )
        else:
            # DDP via torchrun, torch.distributed.launch
            # Question
            local_rank, _, _ = world_info_from_env()
            torch.distributed.init_process_group(
                backend=dist_backend,
                init_method=dist_url,
            )
            # torch.distributed.init_process_group(...) 是分布式通信的初始化点。对于非 SLURM 的初始化（例如使用 torchrun），最准确的 rank 和 world_size 信息应从已初始化的 torch.distributed 中获取（get_rank() / get_world_size()），这样能保证返回的是“真实的、与通信组（process group）一致”的值
            # 环境变量可能不总是可信或最新（例如某些 launcher 会在 init 后调整配置），或者 pipeline/launcher 会以不同方式设置这些值；调用 get_* 能避免这些潜在来源的不一致
            # 通常 torchrun 会通过 env:// 或 launcher 注入环境变量来设置通信。torch.distributed.init_process_group() 在没有显式传入 rank/world_size 时，会根据环境或 backend 的逻辑创建 process group，进而确定最终的 get_rank()/get_world_size()。因此初始化后使用 get_* 能反映初始化完毕的最终值
            # local_rank 代表本机上的设备编号（如第 0 号 GPU、1 号 GPU ...）。这在分布式设置时用来调用 torch.cuda.set_device() 以确保每个进程使用正确的 GPU。获取 local_rank 一般不需要等待 init_process_group，因为多个 launcher（SLURM、torchrun、MPI）都会在环境变量里设置 LOCAL_RANK（或等价字段），而这个信息更早可用于设备选择
            world_size = torch.distributed.get_world_size()
            global_rank = torch.distributed.get_rank()
        distributed = True

    if distributed and not no_set_device_rank and device_type not in ('cpu', 'mps'):
        # Ignore manually specified device index in distributed mode and
        # override with resolved local rank, fewer headaches in most setups.
        if device_idx:
            warnings.warn(f'device index {device_idx[0]} removed from specified ({device}).')
        device = f'{device_type}:{local_rank}'
        set_device(device)

    return dict(
        device=device,
        global_rank=global_rank,
        local_rank=local_rank,
        world_size=world_size,
        distributed=distributed,
    )


def broadcast_object(args, obj, src=0):
    # broadcast a pickle-able python object from rank-0 to all ranks
    if args.horovod:
        return hvd.broadcast_object(obj, root_rank=src)
    else:
        if args.rank == src:
            objects = [obj]
        else:
            # PyTorch 的 dist.broadcast_object_list API 强制要求传入一个列表 (List)。它被设计为原地修改 (In-place modification
            # 接收者：列表里放什么不重要（通常放 None），因为在这个函数执行完后，列表里的内容会被发送者发来的数据覆盖掉
            objects = [None]
        # 执行广播
        # 这是一个集合通信 (Collective Communication) 操作
        # 程序会在这里阻塞 (Block)，直到所有进程都执行到这一行
        # 发生了什么？ PyTorch 将 Rank 0 的 objects 里的数据序列化（Pickle），通过网络发给其他 Rank，然后其他 Rank 将收到的二进制解包，替换掉自己 objects 列表里的 None
        dist.broadcast_object_list(objects, src=src)
        # 因为刚才我们为了迎合 API 把数据包了一层列表，现在我们要把它取出来返回给调用者。此时，所有 Rank 上的 objects[0] 都是一模一样的数据了
        return objects[0]


def all_gather_object(args, obj, dst=0):
    # gather a pickle-able python object across all ranks
    if args.horovod:
        return hvd.allgather_object(obj)
    else:
        objects = [None for _ in range(args.world_size)]
        dist.all_gather_object(objects, obj)
        return objects