import json
import os
from datetime import datetime

import torch
from transformers import AutoProcessor, Qwen2_5_VLForConditionalGeneration

from qwen_vl_utils import process_vision_info

MODEL_PATH = os.environ.get("QWEN_VL_MODEL_PATH", "./qwen2_5_vl_model")
DEFAULT_INPUT_JSON = os.environ.get("EVAL_INPUT_JSON", "test.json")
DEFAULT_OUTPUT_JSON = os.environ.get("EVAL_OUTPUT_JSON", "results/qwen_sft_eval_results.json")

model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
    MODEL_PATH, torch_dtype="auto", device_map="auto"
)
processor = AutoProcessor.from_pretrained(MODEL_PATH)


def build_prompt(action):
    return (
        "Given a video and an action description, reply with one of the following options ONLY:\n"
        "- 'yes' if the action is completed,\n"
        "- 'no' if the action is not completed,\n"
        "- 'Not exists' if the action in the video does not match the given action.\n\n"
        f"Action: {action}"
    )


def call_qwen_vl_with_video(prompt, video_path, max_pixels=151200, fps=0.5):
    if not os.path.exists(video_path):
        print(f"[error] Video not found: {video_path}")
        return "Error: Video not found"
    try:
        messages = [
            {
                "role": "user",
                "content": [
                    {
                        "type": "video",
                        "video": f"file://{video_path}",
                        "max_pixels": max_pixels,
                        "fps": fps,
                    },
                    {"type": "text", "text": prompt},
                ],
            }
        ]
        text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
        image_inputs, video_inputs = process_vision_info(messages)
        inputs = processor(
            text=[text],
            images=image_inputs,
            videos=video_inputs,
            fps=fps,
            padding=True,
            return_tensors="pt",
        ).to(model.device)
        generated_ids = model.generate(**inputs, max_new_tokens=20)
        generated_ids_trimmed = [
            out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
        ]
        output_text = processor.batch_decode(
            generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
        )
        return output_text[0].strip().lower()
    except Exception as exc:
        print(f"[error] Failed to process {video_path}: {exc}")
        return "Error: Video processing failed"


def get_processed_videos(output_json_path):
    if not os.path.exists(output_json_path):
        return set()
    try:
        with open(output_json_path, "r", encoding="utf-8") as file:
            data = json.load(file)
        return {item["video"] for item in data}
    except (json.JSONDecodeError, FileNotFoundError):
        return set()


def save_result_json_list(output_path, result_entry):
    result_entry["timestamp"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    if os.path.exists(output_path):
        try:
            with open(output_path, "r", encoding="utf-8") as file:
                data = json.load(file)
        except json.JSONDecodeError:
            data = []
    else:
        data = []
    data.append(result_entry)
    with open(output_path, "w", encoding="utf-8") as file:
        json.dump(data, file, indent=2, ensure_ascii=False)


def evaluate(json_path, output_json_path):
    processed_videos = get_processed_videos(output_json_path)
    print(f"[info] Previously processed videos: {len(processed_videos)}")
    with open(json_path, "r", encoding="utf-8") as file:
        data = json.load(file)
    total = 0
    correct = 0
    skipped = 0
    for idx, item in enumerate(data):
        video_path = item["video"]
        action = item["action"]
        ground_truth = item["if_finish"].strip().lower()
        if video_path in processed_videos:
            print(
                f"[{idx + 1}/{len(data)}] Skip {os.path.basename(video_path)} (already processed)"
            )
            skipped += 1
            continue
        print(f"[{idx + 1}/{len(data)}] Process {os.path.basename(video_path)}")
        if not os.path.exists(video_path):
            print(f"[warning] Missing file: {video_path}")
            continue
        prompt = build_prompt(action)
        prediction = call_qwen_vl_with_video(prompt, video_path)
        if prediction.startswith("Error:"):
            print(f"[warning] Skipping {video_path}: {prediction}")
            continue
        if "not exists" in prediction:
            predicted_label = "Not exists"
        elif "yes" in prediction:
            predicted_label = "yes"
        elif "no" in prediction:
            predicted_label = "no"
        else:
            print(f"[warning] Unrecognized output: {prediction}")
            predicted_label = "Unknown"
        is_correct = predicted_label.lower() == ground_truth.lower()
        result_entry = {
            "video": video_path,
            "action": action,
            "ground_truth": ground_truth,
            "prediction": predicted_label,
            "raw_output": prediction,
            "correct": is_correct,
        }
        save_result_json_list(output_json_path, result_entry)
        total += 1
        if is_correct:
            correct += 1
    if total > 0:
        current_accuracy = correct / total
        print(f"[session] Accuracy: {current_accuracy * 100:.2f}% ({correct}/{total})")
    else:
        print("[session] No new videos processed.")
    processed_entries = get_processed_videos(output_json_path)
    all_total = len(processed_entries)
    if all_total > 0:
        with open(output_json_path, "r", encoding="utf-8") as file:
            results_data = json.load(file)
        all_correct = sum(1 for item in results_data if item.get("correct", False))
        overall_accuracy = all_correct / all_total
        print(f"[overall] Accuracy: {overall_accuracy * 100:.2f}% ({all_correct}/{all_total})")
        print(f"[overall] Skipped videos: {skipped}")


def main():
    json_path = DEFAULT_INPUT_JSON
    output_json_path = DEFAULT_OUTPUT_JSON
    output_dir = os.path.dirname(output_json_path)
    if output_dir:
        os.makedirs(output_dir, exist_ok=True)
    print("Starting Qwen2.5-VL evaluation...")
    evaluate(json_path, output_json_path)


if __name__ == "__main__":
    main()