import argparse
import json
import os
from pathlib import Path
from VLABench.evaluation.evaluator import VLMEvaluator
from VLABench.evaluation.model.vlm import *

def initialize_model(model_name, *args, **kwargs):
    cls = globals().get(model_name)
    if cls is None:
        raise ValueError(f"Model '{model_name}' not found in the current namespace.")
    
    return cls(*args, **kwargs)

def parse_args():
    parser = argparse.ArgumentParser(description="Run VLM benchmark with specified model and parameters.")
    parser.add_argument("--vlm_name", type=str, default="GPT_4v", choices=["GPT_4v", "Qwen2_VL", "InternVL2", "MiniCPM_V2_6", "GLM4v", "Llava_NeXT", "Gemini", "Claude"], help="Name of the model class to instantiate")
    parser.add_argument("--save_interval", type=int, default=1, help="Interval for saving benchmark results")
    parser.add_argument("--few-shot-num", type=int, default=0, help="Number of few-shot examples")
    parser.add_argument("--eval-dimension", nargs="+", type=str, default=["M&T", "CommonSense", "Semantic", "Spatial", "PhysicalLaw", "Complex"], help="evaluation dimensions")
    parser.add_argument("--tasks", nargs='+', default=None, help="Specific tasks to run, default is None, meaning evaluate on all the tasks")
    parser.add_argument("--n-episodes", type=int, default=100, help="Number of episodes to evaluate for a task")
    parser.add_argument("--with-cot", default=False, action="store_true", help="Whether to use chain of thought")
    parser.add_argument("--task-list-json", type=str, default=None, help="Optional JSON file defining the task list")
    parser.add_argument("--save-dir", type=str, default=None, help="Directory to store evaluation outputs")
    parser.add_argument("--data-root", type=str, default=None, help="Root directory of the VLM evaluation dataset")
    return parser.parse_args()

def main():
    args = parse_args()
    assert len(args.eval_dimension) > 0, "Please specify the evaluation dimension"
    vlabench_root = os.getenv("VLABENCH_ROOT")
    if not vlabench_root:
        raise EnvironmentError("VLABENCH_ROOT is not set. Please export it before running the script.")

    data_root = Path(args.data_root or os.path.join(vlabench_root, "../dataset"))
    save_root = Path(args.save_dir or os.path.join(vlabench_root, "../logs/vlm")).resolve()
    save_root.mkdir(parents=True, exist_ok=True)

    for eval_dim in args.eval_dimension:
        dim_data_path = data_root / f"vlm_evaluation_v1.0/{eval_dim}"
        if not dim_data_path.exists():
            raise FileNotFoundError(f"Data path not found: {dim_data_path}")

        if args.tasks is None:
            task_list = sorted(os.listdir(dim_data_path))
        else:
            task_list = args.tasks

        if args.task_list_json is not None:
            task_list_path = Path(args.task_list_json)
            if not task_list_path.is_file():
                raise FileNotFoundError(f"Task list JSON not found: {task_list_path}")
            with open(task_list_path, 'r') as f:
                task_list = json.load(f)
            if not isinstance(task_list, (list, tuple)):
                raise ValueError("task_list_json must contain a list of tasks")

        evaluator = VLMEvaluator(
            tasks=task_list, 
            n_episodes=args.n_episodes,
            data_path=str(dim_data_path),
            save_path=str(save_root),
        )
        
        vlm = initialize_model(args.vlm_name) 

        evaluator.evaluate(
            vlm,
            save_interval=args.save_interval,
            few_shot_num=args.few_shot_num,
            with_CoT=args.with_cot,
            eval_dim=eval_dim,
        )
        result = evaluator.get_final_score_dict(
            args.vlm_name,
            few_shot_num=args.few_shot_num,
            with_CoT=args.with_cot,
        )
        model_save_dir = save_root / args.vlm_name
        model_save_dir.mkdir(parents=True, exist_ok=True)
        with open(model_save_dir / f"{eval_dim}_result.json", "w") as f:
            json.dump(result, f, indent=4)

if __name__ == "__main__":
    main()