import torch
import torch.nn as nn
import os

from .models import EvalEditModel
from .preprocess import Processor
import yaml
import argparse
import random
import numpy as np


device='cuda'
class VEBenchModel(nn.Module):
    def __init__(self, seed=42):
        super().__init__()
        
        random.seed(seed)
        np.random.seed(seed)
        torch.manual_seed(seed)
        np.random.seed(seed)
        torch.cuda.manual_seed_all(seed)
        
        base_dir = os.path.dirname(os.path.abspath(__file__))
        # 构造配置文件的绝对路径
        dover_config = os.path.join(base_dir, 'configs', 'dover.yaml')
        doublestream_config = os.path.join(base_dir, 'configs', 'doublestream.yaml')
        text_config = os.path.join(base_dir, 'configs', 'text.yaml')
        
        

        with open(dover_config, "r") as f:
            dover_opt = yaml.safe_load(f)
        with open(doublestream_config, "r") as f:
            doublestream_opt = yaml.safe_load(f)
        with open(text_config, "r") as f:
            text_opt = yaml.safe_load(f)
        self.model = EvalEditModel(dover_opt, doublestream_opt, text_opt).cuda()
        self.traditional_processor=Processor(dover_opt['data']['videoQA']['args'])
        self.text_pocessor=Processor(text_opt['data']['videoQA']['args'])
        self.doublestream_processor=Processor(doublestream_opt['data']['videoQA']['args'])

    
    def read_data(self, path):
        traditional_data=self.traditional_processor.preprocess(path)
        text_data=self.text_pocessor.preprocess(path)
        doublestream_data = self.doublestream_processor.preprocess(path)
        data={}
        for branch_data in[traditional_data,text_data,doublestream_data]:
            for key in branch_data.keys():
                data[key]=branch_data[key]
        return data
    
    
    @torch.no_grad()
    def evaluate(self, prompt, src_path, dst_path):
        src_video = self.read_data(src_path)
        dst_video = self.read_data(dst_path)
        result = self.model(src_video, dst_video, prompt)
        return result

if __name__ == "__main__":

    parser = argparse.ArgumentParser(description='Process video files with VEBenchModel.')


    parser.add_argument('--single_test', action='store_true', help='Run a single test with specified paths and prompt.')
    parser.add_argument('--src_path', type=str, help='Source video path for single test.')
    parser.add_argument('--dst_path', type=str, help='Destination video path for single test.')
    parser.add_argument('--prompt', type=str, help='Prompt for single test.')
    parser.add_argument('--data_path', type=str, help='Data path for batch processing.')
    parser.add_argument('--label_path', type=str, help='Label path for batch processing.')


    args = parser.parse_args()


    if args.single_test:
        if args.src_path and args.dst_path and args.prompt:
            src_path = args.src_path
            dst_path = args.dst_path
            prompt = args.prompt
            ebench = VEBenchModel()
            result = ebench.evaluate(prompt, src_path, dst_path)
            print(f"The result is {result}")
        else:
            print("Error: For single test, --src_path, --dst_path, and --prompt must be provided.")
    else:
        if args.data_path and args.label_path:
            data_path = args.data_path
            label_path = args.label_path
            src=[]
            dst=[]
            prompts=[]
            with open(label_path,'r') as file:
                for line in file:
                    video_name,_,prompt=line.split('|')
                    src+=[data_path+"src/"+video_name]
                    dst += [data_path + "edited/" + video_name]
                    prompts+=[prompt]
            ebench = EBenchModel()
            results=[]
            for src_path,dst_path,prompt in zip(src,dst,prompts):
                result = ebench.evaluate(prompt, src_path, dst_path)
                results+=[result]
                print(len(results))
            with open("label.txt","w") as file:
                for src_path,result in zip(src,results):
                    file.write(f"{src_path.split('/')[-1]},{result}\n")
        else:
            print("Error: For batch test, --data_path, --label_path must be provided.")