import os
import time
import json
import re
import hashlib
import argparse
from pathlib import Path

import cv2
from google import genai
from google.genai import types

MODEL = "gemini-3.1-pro-preview"
FPS = 1.0
TARGET_W = 720
TARGET_H = 480
VIDEO_EXTENSIONS = {".mp4", ".mov", ".avi", ".mkv", ".webm"}

PROMPT_TEMPLATE = """
You are an expert computer vision judge evaluating a video object removal
task using THREE separate videos.

The three videos provided represent:
INPUT Video: The original reference video where the target object and its
aftereffects ARE PRESENT.
GT Video (Ground Truth): The IDEAL result video where the object and
aftereffects are perfectly removed, showing the true background
across all frames.
RESULT Video: Our method’s output video. Your goal is to evaluate how
well the RESULT video removes the target object and reconstructs a
plausible, natural background.

Context for this sample:
Target object (present in INPUT; absent in GT): {fg_object}
Aftereffect types to check: {focus_effect}

EVALUATION PROCESS (THINKING STEPS)
Before scoring, you MUST output a step-by-step reasoning process using
the following structure:
Step 1: Target Identification: Watch the INPUT video and identify the
exact appearance, movement, and location of the Target Object ({fg_object})
and its Aftereffects ({focus_effect}).
Step 2: Expected Background Pattern (GT Analysis): Watch the GT video.
Understand the general context, texture, and lighting of the
background where the object used to be.
Step 3: Output vs GT Comparison (Naturalness Check): Compare the RESULT
video against the GT. Evaluate the inpainted area. Does the filled
background look natural and fit the surrounding scene harmoniously?
Did the model successfully create a clean background, or did it
hallucinate a new foreground object?
Step 4: Error Categorization: Determine which identified differences are
related to the main Target Object removal, and which are related to
the Aftereffect removal. Find the specific flaws based on the rubrics
below.

SCORING RUBRICS (1-5 Scale)
HUMAN-LIKE JUDGING GUIDELINES:
- Humans care most about SEMANTIC removal. If the identifiable features
of the target object are gone, humans consider the removal mostly
successful (Score 4), EVEN IF a blurry smudge or a dark moving blob
is left behind.
- A score of 3 should be reserved for partial temporal failures or when a
small piece of the object remains.
- Punish heavily (Scores 1-2) ONLY if the object is fully visible for a
long time, if the model hallucinates a completely new recognizable
object, or if the artifact left behind is grotesquely out of place.

ObjectScore Rubric (How well the main target object was removed):
5 Points: Perfect or Near Perfect. The object is completely removed. The
inpainted background seamlessly matches the GT. Minor, almost
unnoticeable imperfections are acceptable.
4 Points: Good (Forgiving of Smudges). The core semantic features of the
target object are completely gone. The inpainted area might contain
noticeable smudges, blurriness, or dark moving blobs, but it does not
severely break the overall geometry of the scene. The human eye
forgives these as long as the object itself is unrecognizable.
3 Points: Fair (Partial/Distracting). The removal is flawed but not a
total failure. Use this if: 1) A small but recognizable part of the
object remains. 2) Temporal failure: The object is removed, but
suddenly reappears for a few frames. 3) The object is gone, but the
artifact left behind is highly distracting and physically illogical
for the scene.
2 Points: Poor. Huge remnants of the target object are still clearly
visible and moving. OR the model hallucinated a completely new,
identifiable foreground object that completely ruins the background.
1 Point: Fail. The object is practically untouched and fully visible for
the majority of the video, or the generated artifacts cause extreme,
video-breaking corruption.

AftereffectScore Rubric (How well object-caused effects like shadows/
reflections were removed):
5 Points: Perfect. The aftereffect is completely removed, matching the GT
seamlessly.
4 Points: Good. Aftereffect is successfully removed and the area looks
natural, even if lighting/texture slightly differs from the exact GT.
3 Points: Fair. Aftereffect area is noticeably blurry, smudged, or
improperly lit compared to the rest of the scene.
2 Points: Poor. Severe visual artifacts in the aftereffect region.
1 Point: Fail. The aftereffect is still clearly visible in the RESULT
video, completely ignored by the removal process.

OUTPUT FORMAT
You MUST format your response exactly like this:
Reasoning:
Step 1: [Your reasoning]
Step 2: [Your reasoning]
Step 3: [Your reasoning]
Step 4: [Your reasoning]
AftereffectScore: X, ObjectScore: Y
"""


def natural_key(value):
    return [
        int(token) if token.isdigit() else token.lower()
        for token in re.split(r"(\d+)", str(value))
    ]


def normalize_id(value):
    value = str(value)

    if value.isdigit():
        return str(int(value))

    return value


def get_video_fps(cap):
    fps = cap.get(cv2.CAP_PROP_FPS)

    if fps is None or fps <= 0 or fps != fps:
        return 25.0

    return float(fps)


def resize_video(src_path, preproc_dir):
    src_path = Path(src_path)
    preproc_dir.mkdir(parents=True, exist_ok=True)

    stat = src_path.stat()
    fingerprint = hashlib.sha1(
        f"{src_path.resolve()}_{stat.st_size}_{stat.st_mtime_ns}".encode()
    ).hexdigest()[:16]

    output_path = preproc_dir / (
        f"{src_path.stem}_{fingerprint}_{TARGET_W}x{TARGET_H}.mp4"
    )

    if output_path.exists() and output_path.stat().st_size > 0:
        return output_path

    cap = cv2.VideoCapture(str(src_path))

    if not cap.isOpened():
        raise RuntimeError(f"Could not open video: {src_path}")

    output_fps = get_video_fps(cap)

    writer = cv2.VideoWriter(
        str(output_path),
        cv2.VideoWriter_fourcc(*"mp4v"),
        output_fps,
        (TARGET_W, TARGET_H),
    )

    if not writer.isOpened():
        cap.release()
        raise RuntimeError(f"Could not create output video: {output_path}")

    try:
        while True:
            success, frame = cap.read()

            if not success:
                break

            resized = cv2.resize(
                frame,
                (TARGET_W, TARGET_H),
                interpolation=cv2.INTER_AREA,
            )

            writer.write(resized)

    finally:
        cap.release()
        writer.release()

    if not output_path.exists() or output_path.stat().st_size == 0:
        raise RuntimeError(f"Resized video was not created: {output_path}")

    return output_path


def upload_and_wait(client, file_path, timeout_seconds=180):
    uploaded_file = client.files.upload(file=str(file_path))
    deadline = time.time() + timeout_seconds

    while True:
        remote_file = client.files.get(name=uploaded_file.name)
        state = getattr(remote_file.state, "name", str(remote_file.state))

        if state == "ACTIVE":
            part = types.Part(
                file_data=types.FileData(
                    file_uri=remote_file.uri,
                    mime_type=remote_file.mime_type or "video/mp4",
                ),
                video_metadata=types.VideoMetadata(fps=FPS),
            )
            return remote_file, part

        if state in {"FAILED", "DELETED"}:
            raise RuntimeError(
                f"Video processing failed on Gemini: {file_path}"
            )

        if time.time() > deadline:
            raise TimeoutError(
                f"Video upload timed out: {file_path}"
            )

        time.sleep(2)


def delete_remote_file(client, remote_file):
    if remote_file is None:
        return

    try:
        client.files.delete(name=remote_file.name)
    except Exception:
        pass


def generate_with_retry(client, contents, max_attempts=5):
    wait_seconds = 20
    last_error = None

    for attempt in range(1, max_attempts + 1):
        try:
            return client.models.generate_content(
                model=MODEL,
                contents=contents,
                config=types.GenerateContentConfig(
                    temperature=0.0
                ),
            )

        except Exception as error:
            last_error = error
            error_text = str(error).lower()

            retryable = any(
                keyword in error_text
                for keyword in [
                    "429",
                    "500",
                    "502",
                    "503",
                    "504",
                    "unavailable",
                    "high demand",
                    "rate limit",
                    "resource exhausted",
                    "internal error",
                ]
            )

            if not retryable or attempt == max_attempts:
                raise

            print(
                f"    Retry {attempt}/{max_attempts}: {error}"
            )

            time.sleep(wait_seconds)
            wait_seconds = min(wait_seconds * 2, 180)

    raise RuntimeError(f"Gemini request failed: {last_error}")


def get_sample_id(video_path, root_dir, is_result=False):
    relative = video_path.relative_to(root_dir).with_suffix("")
    sample_id = relative.as_posix()

    if is_result and sample_id.endswith("_remove"):
        sample_id = sample_id[:-7]

    if "/" not in sample_id:
        sample_id = normalize_id(sample_id)

    return sample_id


def build_video_index(folder, is_result=False):
    index = {}

    for path in folder.rglob("*"):
        if not path.is_file():
            continue

        if path.suffix.lower() not in VIDEO_EXTENSIONS:
            continue

        sample_id = get_sample_id(path, folder, is_result)

        if sample_id not in index:
            index[sample_id] = path
            continue

        current_name = index[sample_id].stem
        candidate_name = path.stem

        if candidate_name == sample_id and current_name != sample_id:
            index[sample_id] = path

    return index


def load_metadata(data_json_path):
    with open(data_json_path, "r", encoding="utf-8") as file:
        raw_data = json.load(file)

    metadata = {}

    for item in raw_data:
        sample_id = normalize_id(item["id"])
        metadata[sample_id] = item

    return metadata


def load_results(output_path):
    if not output_path.exists():
        return []

    try:
        with open(output_path, "r", encoding="utf-8") as file:
            data = json.load(file)

        if isinstance(data, list):
            return data

    except json.JSONDecodeError:
        pass

    return []


def save_results(output_path, results):
    temp_path = output_path.with_suffix(".tmp")

    with open(temp_path, "w", encoding="utf-8") as file:
        json.dump(results, file, ensure_ascii=False, indent=2)

    temp_path.replace(output_path)


def parse_score(text, field_name):
    match = re.search(
        rf"{field_name}\s*:\s*([1-5])",
        text,
        flags=re.IGNORECASE,
    )

    if match:
        return int(match.group(1))

    return None


def evaluate_sample(
    client,
    sample_id,
    fg_path,
    bg_path,
    result_path,
    item_data,
    preproc_dir,
):
    remote_fg = None
    remote_bg = None
    remote_result = None

    fg_object = str(item_data["fg_object"])
    effects = item_data["after_effect_type"]

    if isinstance(effects, list):
        focus_effect = ", ".join(map(str, effects))
    else:
        focus_effect = str(effects)

    try:
        fg_720 = resize_video(fg_path, preproc_dir)
        bg_720 = resize_video(bg_path, preproc_dir)
        result_720 = resize_video(result_path, preproc_dir)

        remote_fg, part_fg = upload_and_wait(client, fg_720)
        remote_bg, part_bg = upload_and_wait(client, bg_720)
        remote_result, part_result = upload_and_wait(client, result_720)

        prompt = PROMPT_TEMPLATE.format(
            fg_object=fg_object,
            focus_effect=focus_effect,
        )

        contents = [
            "INPUT VIDEO",
            part_fg,
            "GT VIDEO",
            part_bg,
            "RESULT VIDEO",
            part_result,
            prompt,
        ]

        response = generate_with_retry(client, contents)
        model_output = response.text or ""

        return {
            "id": sample_id,
            "fg_object": fg_object,
            "after_effects": focus_effect,
            "fg_video": str(fg_path),
            "bg_video": str(bg_path),
            "result_video": str(result_path),
            "ObjectScore": parse_score(model_output, "ObjectScore"),
            "AftereffectScore": parse_score(
                model_output,
                "AftereffectScore",
            ),
            "model_output": model_output,
            "status": "ok",
        }

    except Exception as error:
        return {
            "id": sample_id,
            "fg_object": fg_object,
            "after_effects": focus_effect,
            "fg_video": str(fg_path),
            "bg_video": str(bg_path),
            "result_video": str(result_path),
            "status": "error",
            "error": str(error),
        }

    finally:
        delete_remote_file(client, remote_fg)
        delete_remote_file(client, remote_bg)
        delete_remote_file(client, remote_result)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--root", type=str, default=".")
    parser.add_argument(
        "--api_key",
        type=str,
        default=os.getenv("GEMINI_API_KEY"),
    )
    args = parser.parse_args()

    if not args.api_key:
        raise RuntimeError(
            "API key was not found. Set GEMINI_API_KEY or use --api_key."
        )

    root_dir = Path(args.root)
    fg_dir = root_dir / "fg"
    bg_dir = root_dir / "bg"
    result_dir = root_dir / "result"
    data_json_path = root_dir / "data.json"
    preproc_dir = root_dir / "_preproc_720x480"
    output_path = root_dir / "core_evaluation_results.json"

    for folder in [fg_dir, bg_dir, result_dir]:
        if not folder.is_dir():
            raise FileNotFoundError(
                f"Required folder was not found: {folder}"
            )

    if not data_json_path.exists():
        raise FileNotFoundError(
            f"data.json was not found: {data_json_path}"
        )

    client = genai.Client(api_key=args.api_key)
    metadata = load_metadata(data_json_path)

    fg_index = build_video_index(fg_dir)
    bg_index = build_video_index(bg_dir)
    result_index = build_video_index(result_dir, is_result=True)

    common_ids = sorted(
        set(fg_index) & set(bg_index) & set(result_index),
        key=natural_key,
    )

    existing_results = load_results(output_path)

    completed_ids = {
        normalize_id(result["id"])
        for result in existing_results
        if result.get("status") == "ok"
    }

    print(f"Matched fg/bg/result video triples: {len(common_ids)}")

    for index, sample_id in enumerate(common_ids, start=1):
        normalized_id = normalize_id(sample_id)

        if normalized_id not in metadata:
            print(
                f"[{index}/{len(common_ids)}] "
                f"{sample_id}: not found in data.json, skipping."
            )
            continue

        if normalized_id in completed_ids:
            print(
                f"[{index}/{len(common_ids)}] "
                f"{sample_id}: already completed, skipping."
            )
            continue

        print(
            f"[{index}/{len(common_ids)}] "
            f"{sample_id}: starting Gemini evaluation."
        )

        record = evaluate_sample(
            client=client,
            sample_id=normalized_id,
            fg_path=fg_index[sample_id],
            bg_path=bg_index[sample_id],
            result_path=result_index[sample_id],
            item_data=metadata[normalized_id],
            preproc_dir=preproc_dir,
        )

        existing_results.append(record)
        save_results(output_path, existing_results)

        if record["status"] == "ok":
            print(
                f"[{index}/{len(common_ids)}] "
                f"{sample_id}: completed | "
                f"ObjectScore={record['ObjectScore']} | "
                f"AftereffectScore={record['AftereffectScore']}"
            )
        else:
            print(
                f"[{index}/{len(common_ids)}] "
                f"{sample_id}: failed | {record['error']}"
            )

        time.sleep(1)

    print(f"Evaluation completed. Results saved to: {output_path}")


if __name__ == "__main__":
    main()