# import os
# import pdb
# import cv2
# 


# def get_video_resolution(video_path):
#     """
#     获取视频文件的分辨率（宽度和高度）。

#     参数:
#     video_path (str): 视频文件的路径。

#     返回:
#     tuple: 一个包含 (宽度, 高度) 的元组，如果无法打开视频则返回 None。
#     """
#     try:
#         # 打开视频文件
#         vid = cv2.VideoCapture(video_path)

#         if not vid.isOpened():
#             print(f"错误: 无法打开视频文件: {video_path}")
#             return None

#         # 获取视频的宽度和高度
#         # cv2.CAP_PROP_FRAME_WIDTH 的整数值为 3
#         # cv2.CAP_PROP_FRAME_HEIGHT 的整数值为 4
#         width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
#         height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))

#         # 释放视频捕获对象
#         vid.release()

#         return (width, height)

#     except Exception as e:
#         print(f"处理视频时发生错误: {e}")
#         return None



# model_base_path = ['/nfs/ywang29/Reward_finetuning/VideoX-Fun/output_videoalign/output_Sep30']
# for bsae_path in model_base_path[::5]:
#     all_entries = os.listdir(bsae_path)
#     video_file = f'{bsae_path}/train_sample_full/sample-0-0.mp4' 
#     resolution = get_video_resolution(video_file)

#     lora_paths = [entry for entry in all_entries if entry.endswith('.safetensors')]
#     # pdb.set_trace()
#     for lora_path in lora_paths:
#         predict_t2v(sample_size = [resolution[1], resolution[0]], lora_path = f'{bsae_path}/{lora_path}', num_inference_steps = 25, num_generated_videos=50)


import os
import torch
import torch.nn as nn
import torch.distributed as dist
import torch.multiprocessing as mp
from videox_fun.utils.predict_t2v import predict_t2v
# 定义一个简单的神经网络，这就是我们要在每个卡上运行的“子程序”

def cleanup():
    """销毁分布式进程组"""
    dist.destroy_process_group()

def worker(rank, lora_paths):
    """
    这个 'worker' 函数就是被唤起到每个 GPU 上的核心子程序。
    'rank' 参数是当前进程的 ID，也对应了 GPU 的 ID (0, 1, 2, ...)。
    """
    print(f"工作进程已在 Rank {rank} (GPU {rank}) 上启动...")
    
    path = lora_paths[rank]
    
    # 关键步骤：设置当前进程使用的 GPU 设备
    torch.cuda.set_device(rank)
    
    predict_t2v(sample_size = [512, 288], lora_path = path, num_inference_steps = 30, num_generated_videos=50, seed=0, device=rank)

    print(f"--- 进程 {rank} 在 GPU {rank} 上运行完毕 ---\n")

    # 6. 清理
    cleanup()

def main():
        
    num_gpus = torch.cuda.device_count()
    print(f"检测到 {num_gpus} 个 GPU。")

    # 1. 为每个 GPU 定义不同的参数集
    # 注意：这个列表的长度应该等于或小于你的 GPU 数量
    lora_paths = [
        '/nfs/ywang29/Reward_finetuning/VideoX-Fun/output_Oct2_1/checkpoint-1000.safetensors',
        '/nfs/ywang29/Reward_finetuning/VideoX-Fun/output_Oct2_1/checkpoint-1500.safetensors',
        '/nfs/ywang29/Reward_finetuning/VideoX-Fun/output_Oct2_1/checkpoint-2000.safetensors',
        '/nfs/ywang29/Reward_finetuning/VideoX-Fun/output_Oct2_1/checkpoint-5000.safetensors',
        '/nfs/ywang29/Reward_finetuning/VideoX-Fun/output_Oct2_1/checkpoint-8000.safetensors',
    ]

    # 确保我们不会启动比可用 GPU 更多的进程
    procs_to_start = min(num_gpus, len(lora_paths))
    if procs_to_start < len(lora_paths):
        print(f"警告: 定义了 {len(lora_paths)} 组参数，但只有 {num_gpus} 个 GPU 可用。")
        print(f"将只为前 {procs_to_start} 组参数启动进程。")


    # 2. 使用 spawn 启动进程
    # 我们将整个 param_list 作为参数传递给每个 worker
    # worker 内部会使用自己的 rank 来索引到对应的参数
    mp.spawn(worker,
             args=(lora_paths,),
             nprocs=procs_to_start,
             join=True)


if __name__ == "__main__":
    main()