check_diff.py

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import threading
import subprocess
import json
import os
import tempfile
import hashlib
from pathlib import Path
from dataclasses import dataclass
from typing import Any, Dict, List, Optional, Tuple, Union
from datetime import datetime
import numpy as np
from PIL import Image
import imagehash
import librosa
import cv2
import base64
from io import BytesIO
import matplotlib
matplotlib.use('Agg')  # Use non-interactive backend
import matplotlib.pyplot as plt
from scipy import signal
from scipy.spatial.distance import cosine as cosine_distance
from sklearn.metrics.pairwise import cosine_similarity as sklearn_cosine_similarity

# Optional: CLIP for deep content embedding
try:
    import torch
    import clip as clip_module
    CLIP_AVAILABLE = True
    CLIP_MODEL = None
    CLIP_PREPROCESS = None
    CLIP_DEVICE = None
except ImportError:
    CLIP_AVAILABLE = False
    CLIP_MODEL = None
    CLIP_PREPROCESS = None
    CLIP_DEVICE = None

# Optional: YOLO for logo/watermark detection
try:
    from ultralytics import YOLO
    YOLO_AVAILABLE = True
    YOLO_MODEL = None
except ImportError:
    YOLO_AVAILABLE = False
    YOLO_MODEL = None

# Optional: Chromaprint for audio fingerprinting
try:
    import acoustid
    import chromaprint
    CHROMAPRINT_AVAILABLE = True
except ImportError:
    CHROMAPRINT_AVAILABLE = False

# Optional: Tesseract for OCR text detection
try:
    import pytesseract
    from pytesseract import TesseractNotFoundError
    TESSERACT_AVAILABLE = True

    # Auto-detect Tesseract path on Windows
    if os.name == 'nt':  # Windows
        possible_paths = [
            r'libs\Tesseract-OCR\tesseract.exe',
            r'libs\Tesseract-OCR\tTesseract-OCR\tesseract.exe',
            r'C:\Program Files\Tesseract-OCR\tesseract.exe',
            r'C:\Program Files (x86)\Tesseract-OCR\tesseract.exe',
            r'C:\Tesseract-OCR\tesseract.exe',
            os.path.expanduser(r'~\AppData\Local\Programs\Tesseract-OCR\tesseract.exe'),
            os.path.expanduser(r'~\AppData\Local\Tesseract-OCR\tesseract.exe'),
        ]

        # Try to find Tesseract
        tesseract_found = False
        for path in possible_paths:
            if os.path.exists(path):
                pytesseract.pytesseract.tesseract_cmd = path
                tesseract_found = True
                break

        if not tesseract_found:
            print("Warning: Tesseract not found in common locations. OCR features will be disabled.")
            print("See guilde at /libs/README.md for more information.")
            TESSERACT_AVAILABLE = False
except ImportError:
    TESSERACT_AVAILABLE = False
    TesseractNotFoundError = Exception  # Fallback
except Exception as e:
    print(f"Tesseract configuration error: {e}")
    TESSERACT_AVAILABLE = False
    TesseractNotFoundError = Exception  # Fallback

# Optional: Report generation libraries
try:
    from reportlab.lib.pagesizes import letter, A4
    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
    from reportlab.lib.units import inch
    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image as RLImage, Table, TableStyle, PageBreak
    from reportlab.lib import colors
    from reportlab.lib.enums import TA_CENTER, TA_LEFT, TA_RIGHT
    REPORTLAB_AVAILABLE = True
except ImportError:
    REPORTLAB_AVAILABLE = False

try:
    from jinja2 import Template
    JINJA2_AVAILABLE = True
except ImportError:
    JINJA2_AVAILABLE = False

def _to_float(x: Any) -> Optional[float]:
    try:
        return float(x)
    except Exception:
        return None

def _to_int(x: Any) -> Optional[int]:
    try:
        return int(x)
    except Exception:
        return None

def validate_number(x: Any, default: Optional[Union[int, float]] = None) -> Optional[Union[int, float]]:
    """
    Validate and convert input to number (int or float).
    Returns default if conversion fails.
    """
    if x is None:
        return default

    # Check if already a number type
    try:
        import numbers
        if isinstance(x, numbers.Number):
            return x
    except:
        pass

    # Try conversion
    try:
        # Try int first if it looks like an integer
        if isinstance(x, str) and '.' not in x:
            return int(x)
        return float(x)
    except:
        return default

def clamp01(x: float) -> float:
    """Clamp value to [0, 1] range."""
    return max(0.0, min(1.0, x))

def parse_ratio(r: Optional[str]) -> Optional[float]:
    if not r or "/" not in r:
        return None
    a, b = r.split("/", 1)
    try:
        den = float(b)
        if den == 0:
            return None
        return float(a) / den
    except Exception:
        return None

# ===========================
# Utils: ffprobe / ffmpeg
# ===========================
def run_cmd(cmd: List[str]) -> subprocess.CompletedProcess:
    p = subprocess.run(cmd, capture_output=True, text=True, encoding='utf-8', errors='ignore')
    if p.returncode != 0:
        raise RuntimeError(f"Command failed:\n{' '.join(cmd)}\n\nSTDERR:\n{p.stderr.strip()}")
    return p

def ffprobe_json(video_path: str) -> Dict[str, Any]:
    """Extract video metadata using ffprobe with validation"""
    # Check if file exists
    if not os.path.exists(video_path):
        raise FileNotFoundError(f"Video file not found: {video_path}")

    # Check if file is readable and not empty
    file_size = os.path.getsize(video_path)
    if file_size == 0:
        raise RuntimeError(f"Video file is empty: {video_path}")

    cmd = [
        "ffprobe", "-v", "error",
        "-print_format", "json",
        "-show_format", "-show_streams",
        video_path
    ]

    try:
        out = run_cmd(cmd).stdout
        if not out or not out.strip():
            raise RuntimeError(f"ffprobe returned empty output for: {video_path}")
        return json.loads(out)
    except json.JSONDecodeError as e:
        raise RuntimeError(f"Failed to parse ffprobe output for {video_path}: {e}")
    except Exception as e:
        # Check if it's the moov atom error
        if "moov atom not found" in str(e).lower():
            raise RuntimeError(
                f"Invalid or incomplete MP4 file: {video_path}\n\n"
                f"The file may be:\n"
                f"- Still being created/processed\n"
                f"- Corrupted or incomplete\n"
                f"- Not properly finalized by ffmpeg\n\n"
                f"Please wait for the encoding to complete and try again."
            )
        raise

def extract_frames_ffmpeg(video_path: str, out_dir: str, every_sec: float, max_frames: int) -> List[Path]:
    """
    Extract frames every `every_sec` seconds, up to `max_frames`.
    Scale down for faster/robust hashing.
    """
    out_pattern = str(Path(out_dir) / "frame_%05d.jpg")
    vf = f"fps=1/{every_sec},scale=320:-1"
    cmd = [
        "ffmpeg", "-hide_banner", "-loglevel", "error",
        "-i", video_path,
        "-vf", vf,
        "-frames:v", str(max_frames),
        out_pattern
    ]
    run_cmd(cmd)
    frames = sorted(Path(out_dir).glob("frame_*.jpg"))
    return frames

def extract_audio_wav(video_path: str, wav_path: str, sr: int = 22050) -> None:
    cmd = [
        "ffmpeg", "-hide_banner", "-loglevel", "error",
        "-i", video_path,
        "-vn",
        "-ac", "1",
        "-ar", str(sr),
        "-f", "wav",
        wav_path
    ]
    run_cmd(cmd)

@dataclass
class VideoMeta:
    duration: Optional[float]
    size: Optional[int]
    format_name: Optional[str]
    overall_bitrate: Optional[int]
    tags: Dict[str, Any]

    v_codec: Optional[str]
    v_width: Optional[int]
    v_height: Optional[int]
    v_fps: Optional[float]
    v_pix_fmt: Optional[str]
    v_bitrate: Optional[int]
    v_frame_count: Optional[int]  # Added: number of frames

    a_codec: Optional[str]
    a_sample_rate: Optional[int]
    a_channels: Optional[int]
    a_bitrate: Optional[int]

def parse_metadata(meta: Dict[str, Any]) -> VideoMeta:
    fmt = meta.get("format", {}) or {}
    streams = meta.get("streams", []) or []
    v = next((s for s in streams if s.get("codec_type") == "video"), None)
    a = next((s for s in streams if s.get("codec_type") == "audio"), None)

    duration = _to_float(fmt.get("duration"))
    size = _to_int(fmt.get("size"))
    format_name = fmt.get("format_name")
    overall_bitrate = _to_int(fmt.get("bit_rate"))
    tags = fmt.get("tags", {}) or {}

    v_codec = v.get("codec_name") if v else None
    v_width = _to_int(v.get("width")) if v else None
    v_height = _to_int(v.get("height")) if v else None
    v_fps = parse_ratio((v.get("avg_frame_rate") or v.get("r_frame_rate")) if v else None)
    v_pix_fmt = v.get("pix_fmt") if v else None
    v_bitrate = _to_int(v.get("bit_rate")) if v else None

    # Calculate frame count from nb_frames or duration * fps
    v_frame_count = None
    if v:
        v_frame_count = _to_int(v.get("nb_frames"))
        if v_frame_count is None and duration and v_fps:
            v_frame_count = int(duration * v_fps)

    a_codec = a.get("codec_name") if a else None
    a_sample_rate = _to_int(a.get("sample_rate")) if a else None
    a_channels = _to_int(a.get("channels")) if a else None
    a_bitrate = _to_int(a.get("bit_rate")) if a else None

    return VideoMeta(
        duration=duration,
        size=size,
        format_name=format_name,
        overall_bitrate=overall_bitrate,
        tags=tags,
        v_codec=v_codec,
        v_width=v_width,
        v_height=v_height,
        v_fps=v_fps,
        v_pix_fmt=v_pix_fmt,
        v_bitrate=v_bitrate,
        v_frame_count=v_frame_count,
        a_codec=a_codec,
        a_sample_rate=a_sample_rate,
        a_channels=a_channels,
        a_bitrate=a_bitrate,
    )

def sim_equal(a: Any, b: Any) -> float:
    if a is None or b is None:
        return 0.0
    return 1.0 if a == b else 0.0

def sim_close(a: Optional[float], b: Optional[float], tol_ratio: float) -> float:
    """
    Similarity based on relative closeness:
    1.0 if within tol_ratio, smoothly decreases.
    """
    if a is None or b is None:
        return 0.0
    if a == 0 and b == 0:
        return 1.0
    denom = max(abs(a), abs(b), 1e-9)
    rel = abs(a - b) / denom
    if rel <= tol_ratio:
        return 1.0
    # decay after tolerance
    return max(0.0, 1.0 - (rel - tol_ratio) / (1.0 - tol_ratio))

def metadata_similarity(m1: VideoMeta, m2: VideoMeta) -> Tuple[float, Dict[str, float]]:
    """
    Weighted similarity from 0..1.
    This is "deep" in the sense of codec/fps/resolution/bitrate/duration/tags.
    BUT note: metadata can differ even for same content if re-encoded.
    """
    parts: Dict[str, float] = {}

    # Core content-ish fields
    parts["duration"] = sim_close(m1.duration, m2.duration, tol_ratio=0.02)  # 2%
    parts["resolution"] = 0.5 * sim_equal(m1.v_width, m2.v_width) + 0.5 * sim_equal(m1.v_height, m2.v_height)
    parts["fps"] = sim_close(m1.v_fps, m2.v_fps, tol_ratio=0.03)  # 3%
    parts["frame_count"] = sim_close(
        float(m1.v_frame_count) if m1.v_frame_count else None,
        float(m2.v_frame_count) if m2.v_frame_count else None,
        tol_ratio=0.03  # 3% tolerance for frame count
    )
    parts["v_codec"] = sim_equal(m1.v_codec, m2.v_codec)
    parts["a_codec"] = sim_equal(m1.a_codec, m2.a_codec)

    # Encode-ish fields (help detect exact reupload / same encode profile)
    parts["format_name"] = sim_equal(m1.format_name, m2.format_name)
    parts["overall_bitrate"] = sim_close(
        float(m1.overall_bitrate) if m1.overall_bitrate else None,
        float(m2.overall_bitrate) if m2.overall_bitrate else None,
        tol_ratio=0.15
    )
    parts["v_bitrate"] = sim_close(
        float(m1.v_bitrate) if m1.v_bitrate else None,
        float(m2.v_bitrate) if m2.v_bitrate else None,
        tol_ratio=0.20
    )
    parts["a_bitrate"] = sim_close(
        float(m1.a_bitrate) if m1.a_bitrate else None,
        float(m2.a_bitrate) if m2.a_bitrate else None,
        tol_ratio=0.20
    )
    parts["sample_rate"] = sim_equal(m1.a_sample_rate, m2.a_sample_rate)
    parts["channels"] = sim_equal(m1.a_channels, m2.a_channels)
    parts["pix_fmt"] = sim_equal(m1.v_pix_fmt, m2.v_pix_fmt)
    parts["size_bytes"] = sim_close(
        float(m1.size) if m1.size else None,
        float(m2.size) if m2.size else None,
        tol_ratio=0.25
    )

    # Tags: only compare a small, stable subset if present
    tag_keys = ["encoder", "major_brand", "minor_version", "compatible_brands", "creation_time"]
    tag_hits = 0
    tag_total = 0
    for k in tag_keys:
        v1 = m1.tags.get(k)
        v2 = m2.tags.get(k)
        if v1 is None or v2 is None:
            continue
        tag_total += 1
        if str(v1) == str(v2):
            tag_hits += 1
    parts["tags_subset"] = (tag_hits / tag_total) if tag_total else 0.0

    # Weights (sum ~ 1.0) - adjusted to include frame_count
    weights = {
        "duration": 0.14,
        "frame_count": 0.08,  # New: helps detect trim
        "resolution": 0.11,
        "fps": 0.07,
        "v_codec": 0.05,
        "a_codec": 0.04,
        "format_name": 0.05,
        "overall_bitrate": 0.09,
        "v_bitrate": 0.06,
        "a_bitrate": 0.05,
        "sample_rate": 0.04,
        "channels": 0.03,
        "pix_fmt": 0.04,
        "size_bytes": 0.09,
        "tags_subset": 0.06,
    }

    score = 0.0
    for k, w in weights.items():
        score += parts.get(k, 0.0) * w

    return max(0.0, min(1.0, score)), parts

# -----------------------------
# Visual fingerprint similarity
# -----------------------------
def phash_frames(
    video_path: str,
    every_sec: float,
    max_frames: int,
) -> List[imagehash.ImageHash]:
    with tempfile.TemporaryDirectory() as td:
        frames = extract_frames_ffmpeg(video_path, td, every_sec=every_sec, max_frames=max_frames)
        if not frames:
            return []
        out: List[imagehash.ImageHash] = []
        for fp in frames:
            img = Image.open(fp).convert("RGB")
            out.append(imagehash.phash(img))  # 64-bit
        return out

# -----------------------------
# ORB Feature Matching (Robust to Crop/Resize)
# -----------------------------
def extract_orb_features(video_path: str, num_frames: int = 20, features_per_frame: int = 500) -> List[Tuple[Any, Any]]:
    """
    Extract ORB features from sampled frames.
    Returns list of (keypoints, descriptors) tuples.
    ORB is robust to rotation, scale, and illumination changes.
    """
    try:
        cap = cv2.VideoCapture(video_path)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

        if total_frames == 0:
            cap.release()
            return []

        # Sample frames evenly
        sample_indices = np.linspace(0, total_frames - 1, min(num_frames, total_frames), dtype=int)

        orb = cv2.ORB_create(nfeatures=features_per_frame)
        features_list = []

        for idx in sample_indices:
            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
            ret, frame = cap.read()
            if not ret:
                continue

            # Convert to grayscale
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

            # Detect and compute ORB features
            keypoints, descriptors = orb.detectAndCompute(gray, None)

            if descriptors is not None and len(descriptors) > 0:
                features_list.append((keypoints, descriptors))

        cap.release()
        return features_list

    except Exception as e:
        print(f"ORB feature extraction failed: {e}")
        return []

def orb_similarity(v1: str, v2: str, num_frames: int = 20) -> Tuple[float, Dict[str, Any]]:
    """
    Compare videos using ORB feature matching.
    Robust to crop, resize, rotation, and watermarks.
    Uses feature matching with cross-checking.
    """
    features1 = extract_orb_features(v1, num_frames=num_frames)
    features2 = extract_orb_features(v2, num_frames=num_frames)

    if not features1 or not features2:
        return 0.0, {"note": "failed to extract ORB features"}

    # Match features between corresponding frames
    bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)

    match_ratios = []
    for i in range(min(len(features1), len(features2))):
        kp1, desc1 = features1[i]
        kp2, desc2 = features2[i]

        if desc1 is None or desc2 is None:
            continue

        try:
            # Match descriptors
            matches = bf.match(desc1, desc2)

            if len(matches) > 0:
                # Sort by distance (lower = better match)
                matches = sorted(matches, key=lambda x: x.distance)

                # Good matches: distance < threshold
                good_matches = [m for m in matches if m.distance < 50]

                # Calculate match ratio
                max_features = max(len(desc1), len(desc2))
                match_ratio = len(good_matches) / max_features if max_features > 0 else 0.0
                match_ratios.append(match_ratio)
        except Exception as e:
            print(f"Frame {i} matching error: {e}")
            continue

    if not match_ratios:
        return 0.0, {"note": "no valid feature matches"}

    # Calculate similarity metrics
    avg_match_ratio = float(np.mean(match_ratios))
    median_match_ratio = float(np.median(match_ratios))
    min_match_ratio = float(np.min(match_ratios))

    # Convert match ratio to similarity score
    # > 0.3 = very similar (allowing for crops/changes)
    # > 0.2 = similar
    # > 0.1 = somewhat similar
    # < 0.1 = different

    if avg_match_ratio >= 0.3:
        sim = 0.85 + (avg_match_ratio - 0.3) * 0.5  # 0.85-1.0
    elif avg_match_ratio >= 0.2:
        sim = 0.65 + (avg_match_ratio - 0.2) * 2.0  # 0.65-0.85
    elif avg_match_ratio >= 0.1:
        sim = 0.35 + (avg_match_ratio - 0.1) * 3.0  # 0.35-0.65
    else:
        sim = avg_match_ratio * 3.5  # 0-0.35

    return round(clamp01(sim), 2), {
        "frames_compared": len(match_ratios),
        "avg_match_ratio": round(avg_match_ratio, 3),
        "median_match_ratio": round(median_match_ratio, 3),
        "min_match_ratio": round(min_match_ratio, 3),
        "note": "ORB feature matching (robust to crop/resize/watermark)"
    }

# -----------------------------
# CLIP Deep Content Embedding (Advanced)
# -----------------------------
def init_clip_model():
    """Initialize CLIP model (lazy loading) with GPU optimization."""
    global CLIP_MODEL, CLIP_PREPROCESS, CLIP_DEVICE

    if not CLIP_AVAILABLE:
        return False

    if CLIP_MODEL is None:
        try:
            # Multi-GPU support: use the first available GPU or CPU
            if torch.cuda.is_available():
                CLIP_DEVICE = "cuda"
                # For multi-GPU, could use DataParallel
                gpu_count = torch.cuda.device_count()
                print(f"CUDA available with {gpu_count} GPU(s)")
            else:
                CLIP_DEVICE = "cpu"
                print("CUDA not available, using CPU")

            CLIP_MODEL, CLIP_PREPROCESS = clip_module.load("ViT-B/32", device=CLIP_DEVICE)
            CLIP_MODEL.eval()

            # Enable mixed precision for faster inference on GPU
            if CLIP_DEVICE == "cuda":
                CLIP_MODEL = CLIP_MODEL.half()  # Use FP16

            print(f"CLIP model loaded on {CLIP_DEVICE}")
            return True
        except Exception as e:
            print(f"Failed to load CLIP model: {e}")
            return False
    return True

def extract_clip_embedding(video_path: str, num_frames: int = 10) -> Optional[np.ndarray]:
    """
    Extract CLIP embedding from video frames with GPU optimization.
    Returns averaged 512D embedding vector.
    Extremely robust to crop, resize, watermark, re-encode.
    """
    if not init_clip_model():
        return None

    try:
        cap = cv2.VideoCapture(video_path)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

        if total_frames == 0:
            cap.release()
            return None

        # Sample frames evenly
        sample_indices = np.linspace(0, total_frames - 1, min(num_frames, total_frames), dtype=int)

        embeddings = []

        # Batch processing for GPU efficiency
        batch_size = 4 if CLIP_DEVICE == "cuda" else 1
        batch_frames = []

        for idx in sample_indices:
            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
            ret, frame = cap.read()
            if not ret:
                continue

            # Convert BGR to RGB
            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            image = Image.fromarray(frame_rgb)
            batch_frames.append(image)

            # Process batch when full
            if len(batch_frames) >= batch_size:
                try:
                    # Stack images into batch
                    image_tensors = torch.stack([CLIP_PREPROCESS(img) for img in batch_frames]).to(CLIP_DEVICE)

                    if CLIP_DEVICE == "cuda":
                        image_tensors = image_tensors.half()  # FP16 for speed

                    with torch.no_grad():
                        batch_embeddings = CLIP_MODEL.encode_image(image_tensors)
                        # Normalize
                        batch_embeddings = batch_embeddings / batch_embeddings.norm(dim=-1, keepdim=True)
                        embeddings.extend(batch_embeddings.cpu().float().numpy())

                    batch_frames = []
                except Exception as e:
                    print(f"Batch processing error: {e}")
                    batch_frames = []

        # Process remaining frames
        if batch_frames:
            try:
                image_tensors = torch.stack([CLIP_PREPROCESS(img) for img in batch_frames]).to(CLIP_DEVICE)
                if CLIP_DEVICE == "cuda":
                    image_tensors = image_tensors.half()

                with torch.no_grad():
                    batch_embeddings = CLIP_MODEL.encode_image(image_tensors)
                    batch_embeddings = batch_embeddings / batch_embeddings.norm(dim=-1, keepdim=True)
                    embeddings.extend(batch_embeddings.cpu().float().numpy())
            except Exception as e:
                print(f"Final batch processing error: {e}")

        cap.release()

        if not embeddings:
            return None

        # Average embeddings across frames
        avg_embedding = np.mean(embeddings, axis=0).astype(np.float32)

        # Normalize again
        norm = np.linalg.norm(avg_embedding) + 1e-9
        return avg_embedding / norm

    except Exception as e:
        print(f"CLIP embedding extraction failed: {e}")
        return None

def clip_similarity(v1: str, v2: str, num_frames: int = 10) -> Tuple[float, Dict[str, Any]]:
    """
    Compare videos using CLIP deep embeddings.
    Most robust method for detecting same content regardless of:
    - Crop, resize, rotation
    - Watermarks, logos
    - Color grading, filters
    - Re-encoding, format changes
    - Minor edits
    """
    if not CLIP_AVAILABLE:
        return 0.0, {"note": "CLIP not available (requires: pip install torch clip)"}

    emb1 = extract_clip_embedding(v1, num_frames=num_frames)
    emb2 = extract_clip_embedding(v2, num_frames=num_frames)

    if emb1 is None or emb2 is None:
        return 0.0, {"note": "failed to extract CLIP embeddings"}

    # Cosine similarity (already normalized, so just dot product)
    cosine = float(np.dot(emb1, emb2))
    cosine = max(-1.0, min(1.0, cosine))

    # CLIP embeddings are very robust, high cosine = same content
    # > 0.95 = identical/near-identical content
    # > 0.90 = very similar content
    # > 0.80 = similar with modifications
    # > 0.70 = somewhat related content
    # < 0.70 = different content

    if cosine >= 0.95:
        sim = 1.0
    elif cosine >= 0.90:
        sim = 0.9 + (cosine - 0.90) / (0.95 - 0.90) * 0.1
    elif cosine >= 0.80:
        sim = 0.75 + (cosine - 0.80) / (0.90 - 0.80) * 0.15
    elif cosine >= 0.70:
        sim = 0.50 + (cosine - 0.70) / (0.80 - 0.70) * 0.25
    else:
        sim = max(0.0, cosine / 0.70 * 0.5)

    return round(clamp01(sim), 2), {
        "cosine_similarity": round(cosine, 4),
        "frames_analyzed": num_frames,
        "embedding_dim": len(emb1),
        "method": "CLIP ViT-B/32",
        "note": "Deep content embedding (most robust method)"
    }

# -----------------------------
# YOLO Logo/Watermark Detection (Advanced)
# -----------------------------
def init_yolo_model():
    """Initialize YOLO model for logo detection (lazy loading)."""
    global YOLO_MODEL

    if not YOLO_AVAILABLE:
        return False

    if YOLO_MODEL is None:
        try:
            # Use YOLOv8n (nano) for fast detection
            # For production, train custom model on logo dataset
            YOLO_MODEL = YOLO('yolov8n.pt')  # Pre-trained COCO model
            print("YOLO model loaded for object detection")
            return True
        except Exception as e:
            print(f"Failed to load YOLO model: {e}")
            return False
    return True

def detect_logos_yolo(video_path: str, num_samples: int = 10, known_logos: Optional[List[str]] = None) -> Dict[str, Any]:
    """
    Detect logos/watermarks using YOLOv8.

    Args:
        video_path: Path to video file
        num_samples: Number of frames to sample
        known_logos: List of known logo templates (paths to images)

    Returns:
        Dictionary with logo detection results including:
        - detected_objects: List of detected objects with confidence
        - logo_regions: Bounding boxes of potential logos
        - template_matches: If known_logos provided, template matching results
    """
    if not init_yolo_model():
        return {"detected": False, "note": "YOLO not available"}

    try:
        cap = cv2.VideoCapture(video_path)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

        if total_frames == 0:
            cap.release()
            return {"detected": False, "note": "no frames"}

        # Sample frames
        sample_indices = np.linspace(0, total_frames - 1, min(num_samples, total_frames), dtype=int)

        all_detections = []
        logo_regions = []

        for idx in sample_indices:
            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
            ret, frame = cap.read()
            if not ret:
                continue

            # Run YOLO detection
            results = YOLO_MODEL(frame, verbose=False)

            for result in results:
                boxes = result.boxes
                for box in boxes:
                    cls = int(box.cls[0])
                    conf = float(box.conf[0])
                    xyxy = box.xyxy[0].cpu().numpy()

                    x1, y1, x2, y2 = xyxy
                    width = x2 - x1
                    height = y2 - y1

                    # Filter for small objects in corners (likely logos)
                    frame_h, frame_w = frame.shape[:2]
                    area_percent = (width * height) / (frame_w * frame_h) * 100

                    # Check if in corner regions
                    in_corner = (x1 < frame_w * 0.25 or x2 > frame_w * 0.75) and \
                               (y1 < frame_h * 0.25 or y2 > frame_h * 0.75)

                    if area_percent < 15 and conf > 0.3:  # Small objects with decent confidence
                        detection = {
                            "class": cls,
                            "confidence": round(conf, 3),
                            "bbox": [int(x1), int(y1), int(x2), int(y2)],
                            "area_percent": round(area_percent, 2),
                            "in_corner": in_corner,
                            "frame": int(idx)
                        }
                        all_detections.append(detection)

                        if in_corner:
                            logo_regions.append(detection)

        cap.release()

        # Perform template matching if known logos provided
        template_matches = []
        if known_logos:
            template_matches = match_logo_templates(video_path, known_logos, num_samples)

        detected = len(logo_regions) > 0 or len(template_matches) > 0

        return {
            "detected": detected,
            "yolo_detections": len(all_detections),
            "logo_regions": logo_regions[:10],  # Top 10
            "template_matches": template_matches,
            "frames_analyzed": len(sample_indices),
            "note": "YOLO object detection for logos/watermarks"
        }

    except Exception as e:
        print(f"YOLO logo detection failed: {e}")
        return {"detected": False, "note": f"error: {str(e)}"}

def match_logo_templates(video_path: str, template_paths: List[str], num_samples: int = 10) -> List[Dict[str, Any]]:
    """
    Match known logo templates in video using OpenCV template matching.

    Args:
        video_path: Path to video file
        template_paths: List of paths to logo template images
        num_samples: Number of frames to sample

    Returns:
        List of template matches with locations and confidence
    """
    try:
        # Load templates
        templates = []
        for path in template_paths:
            if os.path.exists(path):
                template = cv2.imread(path)
                if template is not None:
                    # Convert to grayscale
                    template_gray = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)
                    templates.append({
                        "path": path,
                        "name": Path(path).stem,
                        "image": template_gray,
                        "height": template.shape[0],
                        "width": template.shape[1]
                    })

        if not templates:
            return []

        cap = cv2.VideoCapture(video_path)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

        if total_frames == 0:
            cap.release()
            return []

        sample_indices = np.linspace(0, total_frames - 1, min(num_samples, total_frames), dtype=int)

        matches = []

        for idx in sample_indices:
            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
            ret, frame = cap.read()
            if not ret:
                continue

            frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

            for template_info in templates:
                template = template_info["image"]

                # Multi-scale template matching
                scales = [0.5, 0.75, 1.0, 1.25, 1.5]
                best_match = None
                best_val = -1

                for scale in scales:
                    # Resize template
                    w = int(template_info["width"] * scale)
                    h = int(template_info["height"] * scale)

                    if w > frame_gray.shape[1] or h > frame_gray.shape[0]:
                        continue

                    resized_template = cv2.resize(template, (w, h))

                    # Template matching
                    result = cv2.matchTemplate(frame_gray, resized_template, cv2.TM_CCOEFF_NORMED)
                    min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)

                    if max_val > best_val:
                        best_val = max_val
                        best_match = {
                            "location": max_loc,
                            "scale": scale,
                            "width": w,
                            "height": h
                        }

                # Accept matches with confidence > 0.6
                if best_match and best_val > 0.6:
                    x, y = best_match["location"]
                    w, h = best_match["width"], best_match["height"]

                    matches.append({
                        "logo_name": template_info["name"],
                        "confidence": round(best_val, 3),
                        "bbox": [int(x), int(y), int(x + w), int(y + h)],
                        "scale": best_match["scale"],
                        "frame": int(idx)
                    })

        cap.release()
        return matches

    except Exception as e:
        print(f"Template matching failed: {e}")
        return []

def logo_detection_similarity(v1: str, v2: str, known_logos: Optional[List[str]] = None) -> Tuple[float, Dict[str, Any]]:
    """
    Compare logo/watermark presence between two videos using YOLO and template matching.

    Returns:
        Similarity score (1.0 = both have same logos, 0.0 = completely different)
    """
    logo1 = detect_logos_yolo(v1, num_samples=10, known_logos=known_logos)
    logo2 = detect_logos_yolo(v2, num_samples=10, known_logos=known_logos)

    detected1 = logo1.get("detected", False)
    detected2 = logo2.get("detected", False)

    # Both have or both don't have logos
    if detected1 == detected2:
        if not detected1:
            # Both clean
            sim = 1.0
            note = "No logos detected in either video"
        else:
            # Both have logos - compare template matches
            matches1 = logo1.get("template_matches", [])
            matches2 = logo2.get("template_matches", [])

            if matches1 and matches2:
                # Compare logo names
                names1 = set(m["logo_name"] for m in matches1)
                names2 = set(m["logo_name"] for m in matches2)

                intersection = len(names1 & names2)
                union = len(names1 | names2)

                if union > 0:
                    sim = intersection / union
                else:
                    sim = 0.8  # Both have logos but can't compare

                note = f"Template match comparison: {intersection}/{union} common logos"
            else:
                # Use YOLO detections
                regions1 = len(logo1.get("logo_regions", []))
                regions2 = len(logo2.get("logo_regions", []))

                # Similar number of logo regions
                if regions1 > 0 and regions2 > 0:
                    sim = 1.0 - min(abs(regions1 - regions2) / max(regions1, regions2), 0.5)
                else:
                    sim = 0.7

                note = f"Logo region comparison: {regions1} vs {regions2} regions"
    else:
        # One has logos, other doesn't
        sim = 0.3
        note = "Logos present in one video but not the other"

    return round(clamp01(sim), 2), {
        "video1_logos": detected1,
        "video2_logos": detected2,
        "video1_regions": len(logo1.get("logo_regions", [])),
        "video2_regions": len(logo2.get("logo_regions", [])),
        "note": note
    }

def visual_similarity(
    h1: List[imagehash.ImageHash],
    h2: List[imagehash.ImageHash],
    use_global_alignment: bool = False
) -> Tuple[float, Dict[str, Any]]:
    """
    Compare two sequences of pHash.

    Two modes:
    1. Window-based (default): Use best-match per frame with a sliding window
       to tolerate small trims. Faster and works well for aligned videos.
    2. Global alignment: Find global minimum Hamming distance for each frame.
       More robust for heavily cropped/trimmed videos, but slower.

    Return 0..1.
    """
    if not h1 or not h2:
        return 0.0, {"note": "no frames extracted"}

    # Use shorter sequence as reference
    a, b = (h1, h2) if len(h1) <= len(h2) else (h2, h1)
    Ls, Ll = len(a), len(b)

    dists: List[int] = []

    if use_global_alignment:
        # Global mode: for each frame in shorter seq, find best match in entire longer seq
        for i in range(Ls):
            best = None
            for j in range(Ll):
                d = (a[i] - b[j])  # Hamming distance
                best = d if best is None else min(best, d)
            dists.append(int(best if best is not None else 64))
    else:
        # Window mode: for each frame, search in local window around expected position
        window = max(2, int(0.10 * Ll))  # 10% length window (min 2)

        for i in range(Ls):
            # Map frame i to approximate aligned position in longer sequence
            j0 = int(i * Ll / Ls)
            lo = max(0, j0 - window)
            hi = min(Ll, j0 + window + 1)

            best = None
            for j in range(lo, hi):
                d = (a[i] - b[j])  # Hamming distance
                best = d if best is None else min(best, d)
            dists.append(int(best if best is not None else 64))

    # Convert Hamming distance to similarity.
    # For 64-bit hash: distance 0 = identical.
    # A common "near-duplicate" threshold is around <= 10~15.
    dist_mean = float(np.mean(dists))
    dist_p90 = float(np.percentile(dists, 90))

    # Map to [0..1] with soft thresholds
    def dist_to_sim(d: float) -> float:
        # 0..10 => high sim; 10..25 decays; >25 low
        if d <= 10:
            return 1.0
        if d >= 25:
            return 0.0
        return 1.0 - (d - 10) / (25 - 10)

    sim = 0.7 * dist_to_sim(dist_mean) + 0.3 * dist_to_sim(dist_p90)
    sim = float(max(0.0, min(1.0, sim)))

    return round(sim, 2), {
        "frames_a": len(h1),
        "frames_b": len(h2),
        "mean_hamming": round(dist_mean, 2),
        "p90_hamming": round(dist_p90, 2),
        "alignment_mode": "global" if use_global_alignment else "window",
    }

# -----------------------------
# Temporal Alignment Detection (Trim Detection)
# -----------------------------
def detect_temporal_offset(
    h1: List[imagehash.ImageHash],
    h2: List[imagehash.ImageHash],
    max_offset: int = 20
) -> Tuple[int, float, Dict[str, Any]]:
    """
    Detect if one video is a trimmed version of another.
    Returns (best_offset, similarity_at_offset, details).

    Positive offset: h2 starts later than h1 (h1 has intro cut)
    Negative offset: h2 starts earlier than h1 (h2 has intro cut)
    """
    if not h1 or not h2:
        return 0, 0.0, {"note": "no frames to compare"}

    # Try different temporal offsets
    best_offset = 0
    best_sim = 0.0
    offset_scores = []

    for offset in range(-max_offset, max_offset + 1):
        # Calculate overlap region
        if offset >= 0:
            # h2 starts later, skip first 'offset' frames of h1
            start1, end1 = offset, len(h1)
            start2, end2 = 0, len(h2)
        else:
            # h2 starts earlier, skip first '-offset' frames of h2
            start1, end1 = 0, len(h1)
            start2, end2 = -offset, len(h2)

        # Find overlap
        overlap_len = min(end1 - start1, end2 - start2)
        if overlap_len <= 0:
            continue

        # Compare overlapping frames
        dists = []
        for i in range(overlap_len):
            idx1 = start1 + i
            idx2 = start2 + i
            if idx1 < len(h1) and idx2 < len(h2):
                d = int(h1[idx1] - h2[idx2])
                dists.append(d)

        if not dists:
            continue

        # Calculate similarity for this offset
        mean_dist = np.mean(dists)

        # Convert to similarity
        if mean_dist <= 10:
            sim = 1.0
        elif mean_dist >= 25:
            sim = 0.0
        else:
            sim = 1.0 - (mean_dist - 10) / (25 - 10)

        offset_scores.append((offset, sim, mean_dist, overlap_len))

        if sim > best_sim:
            best_sim = sim
            best_offset = offset

    # Find if there's a significant improvement with offset
    zero_offset_sim = next((s for o, s, _, _ in offset_scores if o == 0), 0.0)
    improvement = best_sim - zero_offset_sim

    details = {
        "best_offset": best_offset,
        "similarity_at_best": round(best_sim, 3),
        "similarity_at_zero": round(zero_offset_sim, 3),
        "improvement": round(improvement, 3),
        "offsets_tested": len(offset_scores),
        "note": f"Offset {best_offset} frames suggests " +
                ("no trim" if best_offset == 0 else f"video {'2' if best_offset > 0 else '1'} has {abs(best_offset)} frame intro/trim")
    }

    return best_offset, best_sim, details

# -----------------------------
# Color Histogram Analysis
# -----------------------------
def extract_color_histograms(video_path: str, num_samples: int = 20) -> Optional[np.ndarray]:
    """
    Extract color histograms from sampled frames.
    Returns averaged histogram across HSV color space.
    Useful for detecting color grading, filters, brightness/contrast changes.
    """
    try:
        cap = cv2.VideoCapture(video_path)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
        if total_frames == 0:
            cap.release()
            return None

        # Sample frames evenly throughout the video
        sample_indices = np.linspace(0, total_frames - 1, num_samples, dtype=int)

        histograms = []
        for idx in sample_indices:
            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
            ret, frame = cap.read()
            if not ret:
                continue

            # Convert to HSV for better color representation
            hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

            # Calculate histogram for each channel
            h_hist = cv2.calcHist([hsv], [0], None, [180], [0, 180])
            s_hist = cv2.calcHist([hsv], [1], None, [256], [0, 256])
            v_hist = cv2.calcHist([hsv], [2], None, [256], [0, 256])

            # Normalize
            h_hist = h_hist.flatten() / (h_hist.sum() + 1e-9)
            s_hist = s_hist.flatten() / (s_hist.sum() + 1e-9)
            v_hist = v_hist.flatten() / (v_hist.sum() + 1e-9)

            # Concatenate
            hist = np.concatenate([h_hist, s_hist, v_hist])
            histograms.append(hist)

        cap.release()

        if not histograms:
            return None

        # Average across all sampled frames
        avg_hist = np.mean(histograms, axis=0).astype(np.float32)
        return avg_hist

    except Exception as e:
        print(f"Color histogram extraction failed: {e}")
        return None

def color_similarity(v1: str, v2: str, num_samples: int = 20) -> Tuple[float, Dict[str, Any]]:
    """
    Compare color distributions of two videos.
    Detects color grading, filters, brightness/contrast changes.
    """
    h1 = extract_color_histograms(v1, num_samples)
    h2 = extract_color_histograms(v2, num_samples)

    if h1 is None or h2 is None:
        return 0.0, {"note": "failed to extract color histograms"}

    # Use correlation as similarity metric
    correlation = np.corrcoef(h1, h2)[0, 1]
    correlation = max(-1.0, min(1.0, correlation))

    # Map [-1, 1] to [0, 1], where 1 = identical, 0 = completely different
    # correlation >= 0.95 => very similar colors
    # correlation >= 0.80 => similar with minor grading
    # correlation < 0.60 => different color treatment
    if correlation >= 0.95:
        sim = 1.0
    elif correlation >= 0.80:
        sim = 0.7 + (correlation - 0.80) / (0.95 - 0.80) * 0.3
    elif correlation >= 0.60:
        sim = 0.4 + (correlation - 0.60) / (0.80 - 0.60) * 0.3
    else:
        sim = max(0.0, correlation / 0.60 * 0.4)

    return round(clamp01(sim), 2), {
        "correlation": round(float(correlation), 2),
        "samples": num_samples,
        "note": "HSV color histogram comparison"
    }

# -----------------------------
# Scene Detection & Temporal Analysis
# -----------------------------
def detect_scene_changes(video_path: str, threshold: float = 30.0) -> List[int]:
    """
    Detect scene changes (cuts) in video.
    Returns list of frame indices where scenes change.
    """
    try:
        cap = cv2.VideoCapture(video_path)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

        if total_frames == 0:
            cap.release()
            return []

        scene_changes = []
        prev_frame = None
        frame_idx = 0

        # Sample every Nth frame for speed
        sample_rate = max(1, total_frames // 500)  # Sample ~500 frames max

        while True:
            ret, frame = cap.read()
            if not ret:
                break

            if frame_idx % sample_rate == 0:
                gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                gray = cv2.resize(gray, (320, 180))  # Resize for speed

                if prev_frame is not None:
                    # Calculate frame difference
                    diff = cv2.absdiff(prev_frame, gray)
                    mean_diff = np.mean(diff)

                    if mean_diff > threshold:
                        scene_changes.append(frame_idx)

                prev_frame = gray

            frame_idx += 1

        cap.release()
        return scene_changes

    except Exception as e:
        print(f"Scene detection failed: {e}")
        return []

def scene_similarity(v1: str, v2: str) -> Tuple[float, Dict[str, Any]]:
    """
    Compare scene structure of two videos.
    Similar number and timing of scene cuts suggests same content.
    """
    scenes1 = detect_scene_changes(v1)
    scenes2 = detect_scene_changes(v2)

    if not scenes1 and not scenes2:
        # Both have no scene changes (or detection failed)
        return 0.5, {"note": "no scene changes detected in either video"}

    # Compare number of scenes
    count_sim = 0.0
    if scenes1 and scenes2:
        ratio = min(len(scenes1), len(scenes2)) / max(len(scenes1), len(scenes2))
        count_sim = ratio

    # Compare relative timing of scene changes (normalized by video length)
    timing_sim = 0.0
    if scenes1 and scenes2:
        # Normalize scene positions to [0, 1]
        # Get video durations
        try:
            cap1 = cv2.VideoCapture(v1)
            cap2 = cv2.VideoCapture(v2)
            frames1 = cap1.get(cv2.CAP_PROP_FRAME_COUNT)
            frames2 = cap2.get(cv2.CAP_PROP_FRAME_COUNT)
            cap1.release()
            cap2.release()

            if frames1 > 0 and frames2 > 0:
                norm_scenes1 = np.array(scenes1) / frames1
                norm_scenes2 = np.array(scenes2) / frames2

                # Use DTW-like alignment to find best match
                min_len = min(len(norm_scenes1), len(norm_scenes2))
                if min_len > 0:
                    # Simple comparison: average distance between aligned scenes
                    dists = []
                    for i in range(min_len):
                        j = int(i * len(norm_scenes2) / len(norm_scenes1))
                        if j < len(norm_scenes2):
                            dists.append(abs(norm_scenes1[i] - norm_scenes2[j]))

                    if dists:
                        avg_dist = np.mean(dists)
                        # Convert distance to similarity (0.1 = 10% difference)
                        timing_sim = max(0.0, 1.0 - avg_dist / 0.2)
        except:
            pass

    # Combined similarity (60% count, 40% timing)
    sim = 0.6 * count_sim + 0.4 * timing_sim

    return round(clamp01(sim), 2), {
        "scenes_v1": len(scenes1),
        "scenes_v2": len(scenes2),
        "count_similarity": round(float(count_sim), 2),
        "timing_similarity": round(float(timing_sim), 2),
    }

# -----------------------------
# Motion Analysis
# -----------------------------
def extract_motion_features(video_path: str, num_samples: int = 30) -> Optional[np.ndarray]:
    """
    Extract motion intensity features from video.
    Robust to watermarks and minor crops.
    """
    try:
        cap = cv2.VideoCapture(video_path)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

        if total_frames < 2:
            cap.release()
            return None

        # Sample frame pairs
        sample_indices = np.linspace(0, total_frames - 10, num_samples, dtype=int)

        motion_features = []
        for idx in sample_indices:
            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
            ret1, frame1 = cap.read()
            ret2, frame2 = cap.read()

            if not ret1 or not ret2:
                continue

            # Convert to grayscale and resize
            gray1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
            gray2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
            gray1 = cv2.resize(gray1, (320, 180))
            gray2 = cv2.resize(gray2, (320, 180))

            # Calculate optical flow magnitude
            flow = cv2.calcOpticalFlowFarneback(
                gray1, gray2, None,
                pyr_scale=0.5, levels=3, winsize=15,
                iterations=3, poly_n=5, poly_sigma=1.2, flags=0
            )

            # Motion magnitude
            mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])

            # Extract features: mean, std, max of motion
            features = [
                np.mean(mag),
                np.std(mag),
                np.percentile(mag, 90),
                np.percentile(mag, 50),
            ]
            motion_features.append(features)

        cap.release()

        if not motion_features:
            return None

        # Average features across samples
        avg_features = np.mean(motion_features, axis=0).astype(np.float32)
        return avg_features

    except Exception as e:
        print(f"Motion feature extraction failed: {e}")
        return None

def motion_similarity(v1: str, v2: str, num_samples: int = 30) -> Tuple[float, Dict[str, Any]]:
    """
    Compare motion patterns of two videos.
    Robust to watermarks and small crops.
    """
    m1 = extract_motion_features(v1, num_samples)
    m2 = extract_motion_features(v2, num_samples)

    if m1 is None or m2 is None:
        return 0.0, {"note": "failed to extract motion features"}

    # Calculate similarity based on feature distance
    # Use normalized euclidean distance
    m1_norm = m1 / (np.linalg.norm(m1) + 1e-9)
    m2_norm = m2 / (np.linalg.norm(m2) + 1e-9)

    distance = np.linalg.norm(m1_norm - m2_norm)

    # Convert distance to similarity
    # distance < 0.2 => very similar motion
    # distance > 0.6 => very different motion
    if distance < 0.2:
        sim = 1.0
    elif distance > 0.6:
        sim = 0.0
    else:
        sim = 1.0 - (distance - 0.2) / (0.6 - 0.2)

    return round(clamp01(sim), 2), {
        "distance": round(float(distance), 2),
        "samples": num_samples,
        "motion_v1": [round(x, 2) for x in m1.tolist()],
        "motion_v2": [round(x, 2) for x in m2.tolist()],
    }

# -----------------------------
# Audio fingerprint similarity (Advanced)
# -----------------------------
def audio_features(video_path: str, sr: int, seconds: float) -> Optional[np.ndarray]:
    """
    Extract comprehensive audio embedding with advanced features:
    - MFCC mean & std
    - Chroma mean & std
    - Spectral features (centroid, bandwidth, rolloff, contrast)
    - Zero crossing rate
    - Tonnetz (tonal centroid features)
    """
    with tempfile.TemporaryDirectory() as td:
        wav = str(Path(td) / "a.wav")
        extract_audio_wav(video_path, wav, sr=sr)

        y, _ = librosa.load(wav, sr=sr, mono=True, duration=seconds)
        if y.size == 0:
            return None

        # Normalize
        y = librosa.util.normalize(y)

        # Extract multiple features
        mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=20)
        chroma = librosa.feature.chroma_stft(y=y, sr=sr)

        # Spectral features
        spectral_centroid = librosa.feature.spectral_centroid(y=y, sr=sr)
        spectral_bandwidth = librosa.feature.spectral_bandwidth(y=y, sr=sr)
        spectral_rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr)
        spectral_contrast = librosa.feature.spectral_contrast(y=y, sr=sr)

        # Zero crossing rate
        zcr = librosa.feature.zero_crossing_rate(y)

        # Tonnetz (tonal centroid features)
        tonnetz = librosa.feature.tonnetz(y=y, sr=sr)

        # Concatenate all features
        feat = np.concatenate([
            mfcc.mean(axis=1),
            mfcc.std(axis=1),
            chroma.mean(axis=1),
            chroma.std(axis=1),
            spectral_centroid.mean(axis=1),
            spectral_bandwidth.mean(axis=1),
            spectral_rolloff.mean(axis=1),
            spectral_contrast.mean(axis=1),
            zcr.mean(axis=1),
            tonnetz.mean(axis=1),
        ], axis=0).astype(np.float32)

        # L2 normalize
        norm = np.linalg.norm(feat) + 1e-9
        return feat / norm

def extract_spectrogram_features(video_path: str, sr: int = 22050, duration: float = 90.0) -> Optional[Dict[str, Any]]:
    """
    Extract detailed spectrogram features for deep audio analysis.

    Returns:
        Dictionary containing:
        - mel_spectrogram: Mel-scaled spectrogram statistics
        - spectral_flatness: Measure of noise vs tones
        - harmonic_percussive: Ratio of harmonic to percussive content
        - tempo: Estimated tempo (BPM)
        - onset_strength: Onset detection for rhythm analysis
    """
    try:
        with tempfile.TemporaryDirectory() as td:
            wav = str(Path(td) / "audio.wav")
            extract_audio_wav(video_path, wav, sr=sr)

            y, _ = librosa.load(wav, sr=sr, mono=True, duration=duration)
            if y.size == 0:
                return None

            # Normalize
            y = librosa.util.normalize(y)

            # Mel spectrogram
            mel_spec = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128)
            mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max)

            # Spectral flatness (measure of noise vs tonal)
            flatness = librosa.feature.spectral_flatness(y=y)

            # Harmonic-percussive separation
            y_harmonic, y_percussive = librosa.effects.hpss(y)
            harmonic_energy = np.sum(y_harmonic ** 2)
            percussive_energy = np.sum(y_percussive ** 2)
            hp_ratio = harmonic_energy / (percussive_energy + 1e-9)

            # Tempo estimation
            tempo, _ = librosa.beat.beat_track(y=y, sr=sr)

            # Onset strength (for rhythm analysis)
            onset_env = librosa.onset.onset_strength(y=y, sr=sr)

            return {
                "mel_spec_mean": float(np.mean(mel_spec_db)),
                "mel_spec_std": float(np.std(mel_spec_db)),
                "mel_spec_max": float(np.max(mel_spec_db)),
                "spectral_flatness_mean": float(np.mean(flatness)),
                "spectral_flatness_std": float(np.std(flatness)),
                "harmonic_percussive_ratio": float(hp_ratio),
                "tempo_bpm": float(tempo) if isinstance(tempo, (int, float, np.number)) else float(tempo[0]) if hasattr(tempo, '__iter__') else 0.0,
                "onset_strength_mean": float(np.mean(onset_env)),
                "onset_strength_std": float(np.std(onset_env)),
                "energy": float(np.sum(y ** 2)),
            }

    except Exception as e:
        print(f"Spectrogram feature extraction failed: {e}")
        return None

def detect_voice_speech(video_path: str, sr: int = 22050, duration: float = 30.0) -> Dict[str, Any]:
    """
    Detect presence of voice/speech in audio using librosa.

    Returns:
        Dictionary with:
        - voice_detected: Boolean indicating voice presence
        - voice_confidence: Confidence score [0, 1]
        - speech_segments: Number of detected speech-like segments
        - fundamental_freq: Average fundamental frequency (F0)
    """
    try:
        with tempfile.TemporaryDirectory() as td:
            wav = str(Path(td) / "audio.wav")
            extract_audio_wav(video_path, wav, sr=sr)

            y, _ = librosa.load(wav, sr=sr, mono=True, duration=duration)
            if y.size == 0:
                return {"voice_detected": False, "note": "no audio"}

            # Normalize
            y = librosa.util.normalize(y)

            # Extract fundamental frequency (F0) - typical for voice
            f0, voiced_flag, voiced_probs = librosa.pyin(
                y, fmin=librosa.note_to_hz('C2'), fmax=librosa.note_to_hz('C7'), sr=sr
            )

            # Filter out NaN values
            f0_valid = f0[~np.isnan(f0)]

            # Calculate voice metrics
            if len(f0_valid) > 0:
                avg_f0 = float(np.mean(f0_valid))
                voice_ratio = len(f0_valid) / len(f0)

                # Voice typically in 85-255 Hz (male) or 165-255 Hz (female)
                voice_range = np.sum((f0_valid >= 85) & (f0_valid <= 400)) / len(f0_valid)

                # Combine metrics for confidence
                voice_confidence = (voice_ratio * 0.5 + voice_range * 0.5)
                voice_detected = voice_confidence > 0.3
            else:
                avg_f0 = 0.0
                voice_confidence = 0.0
                voice_detected = False

            # Count speech-like segments using onset detection
            onset_frames = librosa.onset.onset_detect(y=y, sr=sr, units='frames')
            num_segments = len(onset_frames)

            return {
                "voice_detected": bool(voice_detected),
                "voice_confidence": round(float(voice_confidence), 3),
                "speech_segments": int(num_segments),
                "fundamental_freq_hz": round(avg_f0, 2),
                "voiced_frames_ratio": round(float(voice_ratio) if len(f0_valid) > 0 else 0.0, 3),
                "note": "Voice detection using F0 and onset analysis"
            }

    except Exception as e:
        print(f"Voice detection failed: {e}")
        return {"voice_detected": False, "note": f"error: {str(e)}"}

def spectrogram_similarity(v1: str, v2: str, sr: int = 22050, duration: float = 90.0) -> Tuple[float, Dict[str, Any]]:
    """
    Compare videos using detailed spectrogram analysis.
    Detects differences in audio quality, effects, and processing.
    """
    spec1 = extract_spectrogram_features(v1, sr, duration)
    spec2 = extract_spectrogram_features(v2, sr, duration)

    if spec1 is None or spec2 is None:
        return 0.0, {"note": "failed to extract spectrogram features"}

    # Compare individual features
    features = [
        "mel_spec_mean", "mel_spec_std", "spectral_flatness_mean",
        "harmonic_percussive_ratio", "tempo_bpm", "onset_strength_mean"
    ]

    similarities = []
    for feat in features:
        val1 = spec1.get(feat, 0)
        val2 = spec2.get(feat, 0)

        if val1 == 0 and val2 == 0:
            sim_feat = 1.0
        else:
            # Relative difference
            rel_diff = abs(val1 - val2) / (max(abs(val1), abs(val2)) + 1e-9)
            sim_feat = max(0.0, 1.0 - rel_diff)

        similarities.append(sim_feat)

    # Average similarity
    avg_sim = np.mean(similarities)

    return round(float(avg_sim), 2), {
        "method": "spectrogram_analysis",
        "features_compared": features,
        "feature_similarities": [round(s, 2) for s in similarities],
        "spec1_summary": {k: round(v, 2) for k, v in spec1.items()},
        "spec2_summary": {k: round(v, 2) for k, v in spec2.items()},
    }

def voice_similarity(v1: str, v2: str) -> Tuple[float, Dict[str, Any]]:
    """
    Compare voice/speech presence between two videos.
    """
    voice1 = detect_voice_speech(v1)
    voice2 = detect_voice_speech(v2)

    detected1 = voice1.get("voice_detected", False)
    detected2 = voice2.get("voice_detected", False)

    if detected1 == detected2:
        if not detected1:
            # Both have no voice
            sim = 1.0
            note = "No voice detected in either video"
        else:
            # Both have voice - compare characteristics
            conf1 = voice1.get("voice_confidence", 0)
            conf2 = voice2.get("voice_confidence", 0)
            f0_1 = voice1.get("fundamental_freq_hz", 0)
            f0_2 = voice2.get("fundamental_freq_hz", 0)

            # Compare confidence
            conf_sim = 1.0 - abs(conf1 - conf2)

            # Compare F0 (pitch)
            if f0_1 > 0 and f0_2 > 0:
                f0_diff = abs(f0_1 - f0_2) / max(f0_1, f0_2)
                f0_sim = max(0.0, 1.0 - f0_diff)
            else:
                f0_sim = 0.5

            sim = (conf_sim * 0.6 + f0_sim * 0.4)
            note = f"Voice present in both (F0: {f0_1:.0f}Hz vs {f0_2:.0f}Hz)"
    else:
        # One has voice, other doesn't
        sim = 0.2
        note = "Voice present in one video but not the other"

    return round(clamp01(sim), 2), {
        "video1_voice": voice1,
        "video2_voice": voice2,
        "note": note
    }

def cosine_sim(a: np.ndarray, b: np.ndarray) -> float:
    return float(np.dot(a, b) / ((np.linalg.norm(a) + 1e-9) * (np.linalg.norm(b) + 1e-9)))

def audio_similarity(v1: str, v2: str, sr: int = 22050, seconds: float = 90.0) -> Tuple[float, Dict[str, Any]]:
    # Fallback: MFCC + Chroma embedding
    f1 = audio_features(v1, sr=sr, seconds=seconds)
    f2 = audio_features(v2, sr=sr, seconds=seconds)
    if f1 is None or f2 is None:
        return 0.0, {"note": "no audio or failed to extract"}

    cs = cosine_sim(f1, f2)  # typically -1..1 but should be >=0 for similar audio
    cs = max(-1.0, min(1.0, cs))

    # Map cosine similarity to [0..1]
    # treat >=0.90 as very similar, <=0.60 as low
    if cs >= 0.90:
        sim = 1.0
    elif cs <= 0.60:
        sim = 0.0
    else:
        sim = (cs - 0.60) / (0.90 - 0.60)

    return float(sim), {"method": "mfcc+chroma", "cosine": round(float(cs), 2), "sr": sr, "seconds": seconds}

# -----------------------------
# Audio Fingerprint (Chromaprint) - High Accuracy
# -----------------------------
def chromaprint_fingerprint(video_path: str, duration: int = 120) -> Optional[str]:
    """
    Extract Chromaprint audio fingerprint from video.
    More accurate than MFCC+Chroma for identical audio detection.

    Args:
        video_path: Path to video file
        duration: Duration in seconds to analyze

    Returns:
        Fingerprint string or None if failed
    """
    if not CHROMAPRINT_AVAILABLE:
        return None

    try:
        with tempfile.TemporaryDirectory() as td:
            wav = str(Path(td) / "audio.wav")
            # Extract audio to WAV for chromaprint
            extract_audio_wav(video_path, wav, sr=11025)

            # Calculate fingerprint using fpcalc (chromaprint command line tool)
            cmd = ["fpcalc", "-raw", "-length", str(duration), wav]
            result = subprocess.run(cmd, capture_output=True, text=True)

            if result.returncode == 0:
                # Parse fingerprint from output
                for line in result.stdout.split('\n'):
                    if line.startswith('FINGERPRINT='):
                        return line.split('=', 1)[1].strip()
            return None
    except Exception as e:
        print(f"Chromaprint fingerprint extraction failed: {e}")
        return None

def chromaprint_similarity(v1: str, v2: str, duration: int = 120) -> Tuple[float, Dict[str, Any]]:
    """
    Compare videos using Chromaprint audio fingerprints.
    Extremely accurate for detecting identical or near-identical audio.
    Robust to format changes, bitrate differences, and minor quality loss.

    Args:
        v1, v2: Video paths to compare
        duration: Duration in seconds to analyze

    Returns:
        Similarity score [0, 1] and details dict
    """
    if not CHROMAPRINT_AVAILABLE:
        # Fallback to existing audio similarity
        return audio_similarity(v1, v2)

    fp1 = chromaprint_fingerprint(v1, duration)
    fp2 = chromaprint_fingerprint(v2, duration)

    if fp1 is None or fp2 is None:
        # Fallback to MFCC+Chroma
        return audio_similarity(v1, v2)

    try:
        # Convert fingerprints to arrays
        arr1 = np.array([int(x) for x in fp1.split(',') if x.strip()])
        arr2 = np.array([int(x) for x in fp2.split(',') if x.strip()])

        # Align sequences (one might be shorter)
        min_len = min(len(arr1), len(arr2))
        if min_len == 0:
            return 0.0, {"note": "empty fingerprints"}

        arr1 = arr1[:min_len]
        arr2 = arr2[:min_len]

        # Calculate bit error rate
        # XOR to find differing bits, then count them
        xor_result = np.bitwise_xor(arr1, arr2)
        different_bits = np.sum([bin(x).count('1') for x in xor_result])
        total_bits = min_len * 32  # Each int is 32 bits

        bit_match_rate = 1.0 - (different_bits / total_bits)

        # Map to similarity score
        # Chromaprint is very sensitive:
        # > 0.95 = nearly identical audio
        # > 0.85 = very similar audio
        # > 0.70 = similar audio
        # < 0.70 = different audio

        if bit_match_rate >= 0.95:
            sim = 1.0
        elif bit_match_rate >= 0.85:
            sim = 0.85 + (bit_match_rate - 0.85) * 1.5
        elif bit_match_rate >= 0.70:
            sim = 0.60 + (bit_match_rate - 0.70) * 1.67
        else:
            sim = bit_match_rate * 0.857

        return round(clamp01(sim), 3), {
            "method": "chromaprint",
            "bit_match_rate": round(bit_match_rate, 4),
            "fingerprint_length": min_len,
            "note": "High-accuracy audio fingerprint"
        }
    except Exception as e:
        print(f"Chromaprint comparison failed: {e}")
        # Fallback to MFCC+Chroma
        return audio_similarity(v1, v2)

# -----------------------------
# Watermark/Logo Detection
# -----------------------------
def detect_watermark_regions(video_path: str, num_samples: int = 10, edge_threshold: int = 100) -> Dict[str, Any]:
    """
    Detect potential watermark/logo regions in video.
    Uses edge detection and corner analysis to find static overlays.

    Args:
        video_path: Path to video file
        num_samples: Number of frames to sample
        edge_threshold: Threshold for edge detection

    Returns:
        Dictionary with watermark detection results
    """
    try:
        cap = cv2.VideoCapture(video_path)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

        if total_frames == 0:
            cap.release()
            return {"detected": False, "note": "no frames"}

        # Sample frames evenly
        sample_indices = np.linspace(0, total_frames - 1, min(num_samples, total_frames), dtype=int)

        # Accumulate edge maps to find static regions
        accumulated_edges = None
        frame_count = 0

        for idx in sample_indices:
            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
            ret, frame = cap.read()
            if not ret:
                continue

            # Convert to grayscale
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

            # Detect edges using Canny
            edges = cv2.Canny(gray, edge_threshold, edge_threshold * 2)

            # Accumulate
            if accumulated_edges is None:
                accumulated_edges = edges.astype(np.float32)
            else:
                accumulated_edges += edges.astype(np.float32)

            frame_count += 1

        cap.release()

        if accumulated_edges is None or frame_count == 0:
            return {"detected": False, "note": "no valid frames"}

        # Average the accumulated edges
        avg_edges = accumulated_edges / frame_count

        # Threshold to find persistent edges (likely watermarks/logos)
        # If edge appears in >70% of frames, it's likely static
        persistent_edges = (avg_edges > (edge_threshold * 0.7)).astype(np.uint8) * 255

        # Find contours of persistent regions
        contours, _ = cv2.findContours(persistent_edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

        # Filter contours by size (watermarks are usually small to medium)
        height, width = persistent_edges.shape
        total_area = height * width

        watermark_regions = []
        for contour in contours:
            area = cv2.contourArea(contour)
            # Watermark typically 0.5% to 15% of frame
            if 0.005 * total_area < area < 0.15 * total_area:
                x, y, w, h = cv2.boundingRect(contour)
                # Check if in typical watermark locations (corners, bottom)
                in_corner = (x < width * 0.25 or x + w > width * 0.75) and \
                           (y < height * 0.25 or y + h > height * 0.75)

                watermark_regions.append({
                    "x": int(x), "y": int(y), "width": int(w), "height": int(h),
                    "area_percent": round(area / total_area * 100, 2),
                    "in_corner": in_corner
                })

        detected = len(watermark_regions) > 0

        return {
            "detected": detected,
            "num_regions": len(watermark_regions),
            "regions": watermark_regions[:5],  # Top 5 regions
            "frames_analyzed": frame_count,
            "note": "Static overlay detection via edge analysis"
        }

    except Exception as e:
        print(f"Watermark detection failed: {e}")
        return {"detected": False, "note": f"error: {str(e)}"}

def watermark_similarity(v1: str, v2: str) -> Tuple[float, Dict[str, Any]]:
    """
    Compare watermark presence between two videos.

    Returns:
        Score indicating watermark similarity (1.0 = both have similar watermarks or both don't)
    """
    wm1 = detect_watermark_regions(v1)
    wm2 = detect_watermark_regions(v2)

    detected1 = wm1.get("detected", False)
    detected2 = wm2.get("detected", False)

    # Both have or both don't have watermarks
    if detected1 == detected2:
        if not detected1:
            # Both clean
            sim = 1.0
        else:
            # Both have watermarks - compare number and positions
            num1 = wm1.get("num_regions", 0)
            num2 = wm2.get("num_regions", 0)

            # Similar number of watermarks
            if abs(num1 - num2) <= 1:
                sim = 0.9
            else:
                sim = 0.7
    else:
        # One has watermark, other doesn't
        sim = 0.3

    return round(sim, 2), {
        "v1_watermark": detected1,
        "v2_watermark": detected2,
        "v1_regions": wm1.get("num_regions", 0),
        "v2_regions": wm2.get("num_regions", 0),
        "note": "Watermark presence comparison"
    }

# -----------------------------
# Text/Subtitle Detection (OCR)
# -----------------------------
def detect_text_in_frames(video_path: str, num_samples: int = 20, confidence_threshold: int = 60) -> Dict[str, Any]:
    """
    Detect text/subtitles in video frames using OCR.
    Useful for detecting hardcoded subtitles or text overlays.

    Args:
        video_path: Path to video file
        num_samples: Number of frames to sample
        confidence_threshold: Minimum OCR confidence (0-100)

    Returns:
        Dictionary with text detection results
    """
    if not TESSERACT_AVAILABLE:
        return {
            "detected": False,
            "note": "Tesseract not available. Install from: https://github.com/UB-Mannheim/tesseract/wiki"
        }

    try:
        cap = cv2.VideoCapture(video_path)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

        if total_frames == 0:
            cap.release()
            return {"detected": False, "note": "no frames"}

        # Sample frames evenly
        sample_indices = np.linspace(0, total_frames - 1, min(num_samples, total_frames), dtype=int)

        text_frames = 0
        total_text_length = 0
        detected_texts = []
        ocr_errors = 0

        for idx in sample_indices:
            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
            ret, frame = cap.read()
            if not ret:
                continue

            # Convert to grayscale
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

            # Focus on bottom region where subtitles typically appear
            height, width = gray.shape
            subtitle_region = gray[int(height * 0.7):, :]  # Bottom 30%

            # Apply threshold to improve OCR accuracy
            _, thresh = cv2.threshold(subtitle_region, 200, 255, cv2.THRESH_BINARY)

            # Perform OCR with error handling
            try:
                data = pytesseract.image_to_data(thresh, output_type=pytesseract.Output.DICT,
                                                config='--psm 6')

                # Extract text with sufficient confidence
                frame_text = []
                for i, conf in enumerate(data['conf']):
                    if int(conf) > confidence_threshold:
                        text = data['text'][i].strip()
                        if len(text) > 2:  # Filter out noise
                            frame_text.append(text)

                if frame_text:
                    text_frames += 1
                    combined_text = ' '.join(frame_text)
                    total_text_length += len(combined_text)

                    if len(detected_texts) < 5:  # Keep sample of detected text
                        detected_texts.append({
                            "frame": int(idx),
                            "text": combined_text[:100]  # Truncate long text
                        })
            except pytesseract.TesseractNotFoundError:
                # Tesseract not found - stop trying
                cap.release()
                return {
                    "detected": False,
                    "note": "Tesseract executable not found. Please install Tesseract OCR."
                }
            except Exception as e:
                # Other OCR errors - log but continue
                ocr_errors += 1
                if ocr_errors <= 3:  # Only print first 3 errors
                    print(f"OCR error on frame {idx}: {e}")
                continue

        cap.release()

        # If too many errors, return as unavailable
        if ocr_errors > num_samples * 0.5:
            return {
                "detected": False,
                "note": f"Too many OCR errors ({ocr_errors}/{num_samples}). Check Tesseract installation."
            }

        text_ratio = text_frames / num_samples if num_samples > 0 else 0
        detected = text_ratio > 0.1  # If >10% of frames have text

        return {
            "detected": detected,
            "text_frames": text_frames,
            "total_frames_sampled": num_samples,
            "text_ratio": round(text_ratio, 3),
            "avg_text_length": round(total_text_length / max(text_frames, 1), 1),
            "sample_texts": detected_texts,
            "ocr_errors": ocr_errors,
            "note": "OCR-based text detection (subtitles/overlays)" if ocr_errors == 0
                   else f"OCR completed with {ocr_errors} errors"
        }

    except Exception as e:
        print(f"Text detection failed: {e}")
        return {"detected": False, "note": f"error: {str(e)}"}


def text_similarity(v1: str, v2: str) -> Tuple[float, Dict[str, Any]]:
    """
    Compare text/subtitle presence between two videos.

    Returns:
        Score indicating text similarity
    """
    text1 = detect_text_in_frames(v1)
    text2 = detect_text_in_frames(v2)

    detected1 = text1.get("detected", False)
    detected2 = text2.get("detected", False)

    # Both have or both don't have text
    if detected1 == detected2:
        if not detected1:
            # Both clean
            sim = 1.0
        else:
            # Both have text - compare ratios
            ratio1 = text1.get("text_ratio", 0)
            ratio2 = text2.get("text_ratio", 0)

            # Similar text presence
            ratio_diff = abs(ratio1 - ratio2)
            if ratio_diff < 0.1:
                sim = 0.95
            elif ratio_diff < 0.2:
                sim = 0.85
            else:
                sim = 0.70
    else:
        # One has text, other doesn't
        sim = 0.2

    return round(sim, 2), {
        "v1_text": detected1,
        "v2_text": detected2,
        "v1_text_ratio": text1.get("text_ratio", 0),
        "v2_text_ratio": text2.get("text_ratio", 0),
        "note": "Text/subtitle presence comparison"
    }

# -----------------------------
# Enhanced Audio Spectrum Analysis
# -----------------------------
def extract_audio_spectrum_features(video_path: str, sr: int = 22050, duration: float = 90.0) -> Optional[np.ndarray]:
    """
    Extract enhanced audio spectrum features including:
    - Mel-frequency spectrogram
    - Spectral centroid
    - Spectral rolloff
    - Spectral contrast
    - Zero crossing rate

    More comprehensive than basic MFCC+Chroma.

    Args:
        video_path: Path to video file
        sr: Sample rate
        duration: Duration in seconds to analyze

    Returns:
        Feature vector or None if failed
    """
    try:
        with tempfile.TemporaryDirectory() as td:
            wav = str(Path(td) / "audio.wav")
            extract_audio_wav(video_path, wav, sr=sr)

            y, _ = librosa.load(wav, sr=sr, mono=True, duration=duration)
            if y.size == 0:
                return None

            # Normalize
            y = librosa.util.normalize(y)

            # Extract multiple spectral features
            # 1. Mel-frequency spectrogram
            mel_spec = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128)
            mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max)

            # 2. MFCC (already have, but include for completeness)
            mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=20)

            # 3. Chroma (already have)
            chroma = librosa.feature.chroma_stft(y=y, sr=sr)

            # 4. Spectral centroid
            spectral_centroid = librosa.feature.spectral_centroid(y=y, sr=sr)

            # 5. Spectral rolloff
            spectral_rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr)

            # 6. Spectral contrast
            spectral_contrast = librosa.feature.spectral_contrast(y=y, sr=sr)

            # 7. Zero crossing rate
            zcr = librosa.feature.zero_crossing_rate(y)

            # Aggregate all features
            features = np.concatenate([
                mel_spec_db.mean(axis=1),
                mel_spec_db.std(axis=1),
                mfcc.mean(axis=1),
                mfcc.std(axis=1),
                chroma.mean(axis=1),
                chroma.std(axis=1),
                spectral_centroid.mean(axis=1),
                spectral_centroid.std(axis=1),
                spectral_rolloff.mean(axis=1),
                spectral_rolloff.std(axis=1),
                spectral_contrast.mean(axis=1),
                spectral_contrast.std(axis=1),
                zcr.mean(axis=1),
                zcr.std(axis=1),
            ], axis=0).astype(np.float32)

            # L2 normalize
            norm = np.linalg.norm(features) + 1e-9
            return features / norm

    except Exception as e:
        print(f"Audio spectrum feature extraction failed: {e}")
        return None

def audio_spectrum_similarity(v1: str, v2: str, sr: int = 22050, duration: float = 90.0) -> Tuple[float, Dict[str, Any]]:
    """
    Compare videos using enhanced audio spectrum analysis.
    More robust than basic MFCC+Chroma.

    Args:
        v1, v2: Video paths to compare
        sr: Sample rate
        duration: Duration in seconds to analyze

    Returns:
        Similarity score [0, 1] and details dict
    """
    feat1 = extract_audio_spectrum_features(v1, sr, duration)
    feat2 = extract_audio_spectrum_features(v2, sr, duration)

    if feat1 is None or feat2 is None:
        # Fallback to basic audio similarity
        return audio_similarity(v1, v2, sr, duration)

    # Cosine similarity
    cs = cosine_sim(feat1, feat2)
    cs = max(-1.0, min(1.0, cs))

    # Map to similarity score
    # Enhanced features are more discriminative
    if cs >= 0.92:
        sim = 1.0
    elif cs >= 0.85:
        sim = 0.9 + (cs - 0.85) * 1.43
    elif cs >= 0.70:
        sim = 0.6 + (cs - 0.70) * 2.0
    elif cs >= 0.60:
        sim = 0.3 + (cs - 0.60) * 3.0
    else:
        sim = cs * 0.5

    return round(clamp01(sim), 3), {
        "method": "enhanced_spectrum",
        "cosine": round(cs, 4),
        "feature_dim": len(feat1),
        "sr": sr,
        "duration": duration,
        "note": "Mel-spectrogram + MFCC + Chroma + Spectral features"
    }

# -----------------------------
# VMAF Analysis
# -----------------------------
def vmaf_similarity(v1: str, v2: str, duration_limit: float = 60.0) -> Tuple[float, Dict[str, Any]]:
    """
    Calculate VMAF (Video Multimethod Assessment Fusion) score between two videos.
    VMAF is Netflix's perceptual video quality metric (0-100).
    Higher score = more similar/better quality.

    Args:
        v1: Reference video path
        v2: Distorted/comparison video path
        duration_limit: Only process first N seconds (for speed)

    Returns:
        Similarity score [0, 1] and details dict
    """
    try:
        with tempfile.TemporaryDirectory() as td:
            # Check if videos have same resolution, if not, scale v2 to v1
            meta1 = ffprobe_json(v1)
            meta2 = ffprobe_json(v2)

            v1_stream = next((s for s in meta1.get("streams", []) if s.get("codec_type") == "video"), None)
            v2_stream = next((s for s in meta2.get("streams", []) if s.get("codec_type") == "video"), None)

            if not v1_stream or not v2_stream:
                return 0.0, {"note": "no video stream found"}

            w1, h1 = v1_stream.get("width"), v1_stream.get("height")
            w2, h2 = v2_stream.get("width"), v2_stream.get("height")

            # Prepare filter for VMAF
            # Scale v2 to match v1 if needed
            if w1 != w2 or h1 != h2:
                scale_filter = f"scale={w1}:{h1}"
            else:
                scale_filter = "null"

            # VMAF filter string
            # [0:v] = reference (v1), [1:v] = distorted (v2)
            log_path = str(Path(td) / "vmaf_log.json")
            vmaf_filter = (
                f"[1:v]{scale_filter}[scaled];"
                f"[0:v][scaled]libvmaf="
                f"log_fmt=json:"
                f"log_path={log_path}:"
                f"n_threads=4:"
                f"model=version=vmaf_v0.6.1"
            )

            # Run ffmpeg with VMAF
            cmd = [
                "ffmpeg", "-hide_banner", "-loglevel", "error",
                "-t", str(duration_limit),  # Limit duration for speed
                "-i", v1,  # Reference
                "-t", str(duration_limit),
                "-i", v2,  # Distorted
                "-filter_complex", vmaf_filter,
                "-f", "null", "-"
            ]

            result = subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                encoding='utf-8',
                errors='ignore',
                timeout=300  # 5 minute timeout
            )

            if result.returncode != 0:
                # VMAF might not be available or error occurred
                return 0.0, {"note": f"VMAF calculation failed: {result.stderr[:200]}"}

            # Read VMAF log
            if not Path(log_path).exists():
                return 0.0, {"note": "VMAF log file not created"}

            with open(log_path, 'r', encoding='utf-8') as f:
                vmaf_data = json.load(f)

            # Extract VMAF mean score
            if "pooled_metrics" in vmaf_data:
                vmaf_mean = vmaf_data["pooled_metrics"].get("vmaf", {}).get("mean", 0.0)
            elif "VMAF score" in vmaf_data:
                vmaf_mean = vmaf_data["VMAF score"]
            else:
                # Try to get from frames
                frames = vmaf_data.get("frames", [])
                if frames:
                    scores = [f.get("metrics", {}).get("vmaf", 0) for f in frames]
                    vmaf_mean = np.mean([s for s in scores if s > 0])
                else:
                    return 0.0, {"note": "Could not extract VMAF score from log"}

            # VMAF score is 0-100, convert to 0-1 similarity
            # VMAF > 95 = nearly identical
            # VMAF > 90 = very similar
            # VMAF > 80 = similar with some differences
            # VMAF < 70 = quite different
            vmaf_mean = float(vmaf_mean)

            if vmaf_mean >= 95:
                sim = 1.0
            elif vmaf_mean >= 85:
                sim = 0.8 + (vmaf_mean - 85) / (95 - 85) * 0.2
            elif vmaf_mean >= 70:
                sim = 0.5 + (vmaf_mean - 70) / (85 - 70) * 0.3
            elif vmaf_mean >= 50:
                sim = 0.2 + (vmaf_mean - 50) / (70 - 50) * 0.3
            else:
                sim = max(0.0, vmaf_mean / 50 * 0.2)

            return round(clamp01(sim), 2), {
                "vmaf_mean": round(vmaf_mean, 2),
                "duration_analyzed": round(duration_limit, 2),
                "resolution_matched": w1 == w2 and h1 == h2,
                "note": "VMAF perceptual quality metric"
            }

    except subprocess.TimeoutExpired:
        return 0.0, {"note": "VMAF calculation timeout (>5 min)"}
    except Exception as e:
        print(f"VMAF analysis error: {e}")
        return 0.0, {"note": f"VMAF error: {str(e)[:100]}"}

# -----------------------------
# Overall scoring with Rule-Based Decision System
# -----------------------------
@dataclass
class VideoComparison:
    """Structured comparison result with classification."""
    overall_score: float
    classification: str  # "identical", "same_content", "re-encoded", "cropped", "watermarked", "trimmed", "different"
    confidence: str  # "high", "medium", "low"
    explanation: str
    metrics: Dict[str, float]
    flags: List[str]  # Detected modifications

def classify_videos(
    meta_sim: float,
    vis_sim: float,
    aud_sim: float,
    m1: Optional[VideoMeta] = None,
    m2: Optional[VideoMeta] = None,
    color_sim: Optional[float] = None,
    scene_sim: Optional[float] = None,
    motion_sim: Optional[float] = None,
    vmaf_sim: Optional[float] = None,
    orb_sim: Optional[float] = None,
    clip_sim: Optional[float] = None,
    temporal_offset: Optional[int] = None,
) -> VideoComparison:
    """
    Advanced rule-based classification system.
    Analyzes multiple metrics to determine relationship between videos.
    """

    flags = []
    metrics = {
        "metadata": meta_sim,
        "visual_phash": vis_sim,
        "audio": aud_sim,
    }

    # Add optional metrics
    if color_sim is not None:
        metrics["color"] = color_sim
    if scene_sim is not None:
        metrics["scene"] = scene_sim
    if motion_sim is not None:
        metrics["motion"] = motion_sim
    if vmaf_sim is not None:
        metrics["vmaf"] = vmaf_sim
    if orb_sim is not None:
        metrics["orb_features"] = orb_sim
    if clip_sim is not None:
        metrics["clip_embedding"] = clip_sim

    # Detect specific modifications
    if temporal_offset and abs(temporal_offset) > 2:
        flags.append(f"trimmed_{abs(temporal_offset)}_frames")

    # Check for resolution change
    if m1 and m2 and m1.v_width and m2.v_width:
        if m1.v_width != m2.v_width or m1.v_height != m2.v_height:
            flags.append("resolution_changed")

    # Check for codec change
    if m1 and m2 and m1.v_codec != m2.v_codec:
        flags.append("codec_changed")

    # Check for bitrate change (>20% difference)
    if m1 and m2 and m1.overall_bitrate and m2.overall_bitrate:
        bitrate_ratio = abs(m1.overall_bitrate - m2.overall_bitrate) / max(m1.overall_bitrate, m2.overall_bitrate)
        if bitrate_ratio > 0.2:
            flags.append("bitrate_changed")

    # ===== RULE-BASED CLASSIFICATION =====

    # Priority 1: Use CLIP if available (most reliable)
    if clip_sim is not None and clip_sim > 0:
        if clip_sim >= 0.95:
            classification = "identical"
            confidence = "high"
            explanation = "CLIP deep embedding shows near-identical content"
            overall_score = 0.95
        elif clip_sim >= 0.88:
            # Check for modifications
            if meta_sim >= 0.90:
                classification = "same_content"
                confidence = "high"
                explanation = "Same content, possibly exact copy or minimal re-encode"
            elif "resolution_changed" in flags or (orb_sim and orb_sim < 0.7):
                classification = "cropped"
                confidence = "high"
                explanation = "Same content but cropped/resized"
                flags.append("likely_cropped")
            elif "codec_changed" in flags or "bitrate_changed" in flags:
                classification = "re-encoded"
                confidence = "high"
                explanation = "Same content but re-encoded with different settings"
            else:
                classification = "same_content"
                confidence = "high"
                explanation = "Same content with minor modifications"
            overall_score = clip_sim
        elif clip_sim >= 0.75:
            classification = "watermarked" if meta_sim < 0.6 else "same_content"
            confidence = "medium"
            explanation = "Similar content with noticeable modifications (possible watermark/overlay)"
            if orb_sim and orb_sim >= 0.6:
                flags.append("possible_watermark")
            overall_score = clip_sim * 0.85
        else:
            classification = "different"
            confidence = "high"
            explanation = "Different content (CLIP embedding shows low similarity)"
            overall_score = clip_sim * 0.5

    # Priority 2: Use VMAF + ORB + visual
    elif vmaf_sim is not None and vmaf_sim > 0:
        if vmaf_sim >= 0.90 and vis_sim >= 0.85:
            if meta_sim >= 0.90:
                classification = "identical"
                confidence = "high"
                explanation = "VMAF and visual analysis show identical/near-identical videos"
            elif meta_sim >= 0.70:
                classification = "same_content"
                confidence = "high"
                explanation = "Same content, minor encoding differences"
            else:
                classification = "re-encoded"
                confidence = "high"
                explanation = "Same content but significantly re-encoded"
            overall_score = 0.6 * vmaf_sim + 0.3 * vis_sim + 0.1 * meta_sim

        elif vmaf_sim >= 0.75 and (orb_sim and orb_sim >= 0.65):
            classification = "cropped" if "resolution_changed" in flags else "watermarked"
            confidence = "high"
            explanation = f"Same content but {classification}"
            flags.append(f"detected_{classification}")
            overall_score = 0.5 * vmaf_sim + 0.3 * orb_sim + 0.2 * vis_sim

        elif vmaf_sim >= 0.60 or (vis_sim >= 0.70 and orb_sim and orb_sim >= 0.60):
            classification = "same_content"
            confidence = "medium"
            explanation = "Similar content with modifications"
            overall_score = 0.4 * vmaf_sim + 0.35 * vis_sim + 0.25 * (orb_sim or vis_sim)

        else:
            classification = "different"
            confidence = "medium"
            explanation = "Low perceptual similarity suggests different content"
            overall_score = 0.5 * vmaf_sim + 0.3 * vis_sim + 0.2 * meta_sim

    # Priority 3: Use ORB + pHash + scene/motion
    elif orb_sim is not None and orb_sim > 0:
        if orb_sim >= 0.70 and vis_sim >= 0.80:
            if aud_sim >= 0.85:
                classification = "same_content"
                confidence = "high"
                explanation = "Feature matching and perceptual hash show same content"
            elif aud_sim >= 0.60:
                classification = "same_content"
                confidence = "medium"
                explanation = "Visual match strong, audio partially matches"
            else:
                classification = "same_content" if motion_sim and motion_sim >= 0.70 else "cropped"
                confidence = "medium"
                explanation = "Visual match strong but audio different (possible audio replacement)"
                flags.append("audio_replaced")
            overall_score = 0.4 * orb_sim + 0.35 * vis_sim + 0.15 * aud_sim + 0.1 * meta_sim

        elif orb_sim >= 0.50 and (motion_sim and motion_sim >= 0.65):
            classification = "cropped" if "resolution_changed" in flags else "watermarked"
            confidence = "medium"
            explanation = f"Motion and features suggest same content but {classification}"
            overall_score = 0.35 * orb_sim + 0.25 * vis_sim + 0.25 * motion_sim + 0.15 * aud_sim

        elif orb_sim >= 0.35:
            classification = "same_content"
            confidence = "low"
            explanation = "Some visual features match, but significant differences present"
            overall_score = 0.4 * orb_sim + 0.3 * vis_sim + 0.2 * aud_sim + 0.1 * meta_sim

        else:
            classification = "different"
            confidence = "medium"
            explanation = "Low feature matching suggests different content"
            overall_score = 0.35 * orb_sim + 0.35 * vis_sim + 0.2 * aud_sim + 0.1 * meta_sim

    # Priority 4: Fallback to basic metrics (pHash + audio + metadata)
    else:
        if vis_sim >= 0.90 and aud_sim >= 0.85 and meta_sim >= 0.85:
            classification = "identical"
            confidence = "high"
            explanation = "All basic metrics show near-identical videos"
            overall_score = 0.95

        elif vis_sim >= 0.85 and aud_sim >= 0.85:
            if meta_sim >= 0.70:
                classification = "same_content"
                confidence = "high"
                explanation = "Visual and audio match strongly"
            else:
                classification = "re-encoded"
                confidence = "medium"
                explanation = "Content matches but metadata differs (likely re-encoded)"
            overall_score = 0.5 * vis_sim + 0.35 * aud_sim + 0.15 * meta_sim

        elif vis_sim >= 0.70 and aud_sim >= 0.70:
            if scene_sim and scene_sim >= 0.70:
                classification = "same_content"
                confidence = "medium"
                explanation = "Visual, audio, and scene structure match"
            else:
                classification = "same_content"
                confidence = "medium"
                explanation = "Significant similarity but with some modifications"
            overall_score = 0.45 * vis_sim + 0.35 * aud_sim + 0.2 * meta_sim

        elif vis_sim >= 0.65 or aud_sim >= 0.80:
            classification = "same_content" if aud_sim >= 0.80 else "cropped"
            confidence = "low"
            explanation = "Partial match - either heavily edited or cropped"
            if vis_sim < 0.50 < aud_sim:
                flags.append("possible_slideshow")  # Same audio, different video
            overall_score = 0.5 * vis_sim + 0.35 * aud_sim + 0.15 * meta_sim

        elif vis_sim >= 0.50 and meta_sim >= 0.80:
            classification = "trimmed" if temporal_offset else "different"
            confidence = "low"
            explanation = "Some similarities but likely different content"
            overall_score = 0.4 * vis_sim + 0.3 * aud_sim + 0.3 * meta_sim

        else:
            classification = "different"
            confidence = "high" if vis_sim < 0.30 else "medium"
            explanation = "Videos appear to be different content"
            overall_score = 0.35 * vis_sim + 0.35 * aud_sim + 0.3 * meta_sim

    # Add trim detection to explanation
    if temporal_offset and abs(temporal_offset) > 2:
        explanation += f" (detected {abs(temporal_offset)} frame offset)"

    # Ensure score is in valid range
    overall_score = clamp01(overall_score)

    return VideoComparison(
        overall_score=round(overall_score, 3),
        classification=classification,
        confidence=confidence,
        explanation=explanation,
        metrics=metrics,
        flags=flags
    )

def overall_similarity(
    meta_sim: float,
    vis_sim: float,
    aud_sim: float,
    m1: Optional[VideoMeta] = None,
    m2: Optional[VideoMeta] = None,
    color_sim: Optional[float] = None,
    scene_sim: Optional[float] = None,
    motion_sim: Optional[float] = None,
    vmaf_sim: Optional[float] = None,
    orb_sim: Optional[float] = None,
    clip_sim: Optional[float] = None,
    temporal_offset: Optional[int] = None,
) -> float:
    """
    Backward compatible wrapper for classify_videos.
    Returns just the overall score.
    """
    result = classify_videos(
        meta_sim, vis_sim, aud_sim, m1, m2,
        color_sim, scene_sim, motion_sim, vmaf_sim,
        orb_sim, clip_sim, temporal_offset
    )
    return result.overall_score

def pct(x: float) -> float:
    """Convert 0..1 to percentage"""
    return round(100.0 * x, 2)


# ===========================
# Report Generation (PDF/HTML)
# ===========================

def create_comparison_charts(comparison_data: Dict[str, Any]) -> Dict[str, str]:
    """
    Create visualization charts for comparison data.

    Args:
        comparison_data: Dictionary with all comparison results

    Returns:
        Dictionary with chart names and base64-encoded PNG data
    """
    charts = {}

    try:
        # 1. Overall Similarity Radar Chart
        if 'scores' in comparison_data:
            scores = comparison_data['scores']

            categories = list(scores.keys())
            values = [scores[cat] * 100 for cat in categories]

            # Create radar chart
            fig = plt.figure(figsize=(8, 6))
            ax = fig.add_subplot(111, projection='polar')

            # Number of variables
            num_vars = len(categories)
            angles = np.linspace(0, 2 * np.pi, num_vars, endpoint=False).tolist()
            values += values[:1]  # Complete the circle
            angles += angles[:1]

            ax.plot(angles, values, 'o-', linewidth=2, color='#2E86DE')
            ax.fill(angles, values, alpha=0.25, color='#2E86DE')
            ax.set_xticks(angles[:-1])
            ax.set_xticklabels(categories, size=8)
            ax.set_ylim(0, 100)
            ax.set_title('Similarity Scores Comparison', size=14, weight='bold', pad=20)
            ax.grid(True)

            # Convert to base64
            buffer = BytesIO()
            plt.savefig(buffer, format='png', dpi=150, bbox_inches='tight')
            buffer.seek(0)
            charts['radar_chart'] = base64.b64encode(buffer.read()).decode()
            plt.close(fig)

        # 2. Score Breakdown Bar Chart
        if 'scores' in comparison_data:
            scores = comparison_data['scores']

            fig, ax = plt.subplots(figsize=(10, 6))
            categories = list(scores.keys())
            values = [scores[cat] * 100 for cat in categories]

            colors = ['#2E86DE' if v >= 70 else '#F39C12' if v >= 50 else '#E74C3C' for v in values]

            bars = ax.barh(categories, values, color=colors)
            ax.set_xlabel('Similarity Score (%)', fontsize=12, weight='bold')
            ax.set_title('Detailed Similarity Breakdown', fontsize=14, weight='bold')
            ax.set_xlim(0, 100)

            # Add value labels on bars
            for bar in bars:
                width = bar.get_width()
                ax.text(width + 2, bar.get_y() + bar.get_height()/2,
                       f'{width:.1f}%', ha='left', va='center', fontsize=10)

            ax.grid(axis='x', alpha=0.3)

            buffer = BytesIO()
            plt.savefig(buffer, format='png', dpi=150, bbox_inches='tight')
            buffer.seek(0)
            charts['bar_chart'] = base64.b64encode(buffer.read()).decode()
            plt.close(fig)

        # 3. Metadata Comparison Table Chart
        if 'metadata' in comparison_data:
            meta = comparison_data['metadata']

            fig, ax = plt.subplots(figsize=(10, 6))
            ax.axis('tight')
            ax.axis('off')

            # Prepare table data
            table_data = [['Property', 'Video 1', 'Video 2', 'Match']]

            for key in ['duration', 'resolution', 'fps', 'codec', 'bitrate']:
                if key in meta:
                    v1 = meta[key].get('v1', 'N/A')
                    v2 = meta[key].get('v2', 'N/A')
                    match = '✓' if meta[key].get('match', False) else '✗'
                    table_data.append([key.title(), str(v1), str(v2), match])

            table = ax.table(cellText=table_data, cellLoc='left', loc='center',
                           colWidths=[0.2, 0.3, 0.3, 0.2])
            table.auto_set_font_size(False)
            table.set_fontsize(10)
            table.scale(1, 2)

            # Style header row
            for i in range(4):
                table[(0, i)].set_facecolor('#2E86DE')
                table[(0, i)].set_text_props(weight='bold', color='white')

            ax.set_title('Metadata Comparison', fontsize=14, weight='bold', pad=20)

            buffer = BytesIO()
            plt.savefig(buffer, format='png', dpi=150, bbox_inches='tight')
            buffer.seek(0)
            charts['metadata_table'] = base64.b64encode(buffer.read()).decode()
            plt.close(fig)

    except Exception as e:
        print(f"Chart generation failed: {e}")

    return charts

def generate_html_report(comparison_result: 'VideoComparison',
                        v1_path: str, v2_path: str,
                        output_path: str) -> bool:
    """
    Generate comprehensive HTML report from comparison results.

    Args:
        comparison_result: VideoComparison object
        v1_path: Path to first video
        v2_path: Path to second video
        output_path: Path to save HTML report

    Returns:
        True if successful, False otherwise
    """
    if not JINJA2_AVAILABLE:
        print("Jinja2 not available. Install with: pip install jinja2")
        return False

    try:
        # Prepare data for charts
        comparison_data = {
            'scores': {
                'Metadata': comparison_result.scores.get('metadata', 0),
                'Visual': comparison_result.scores.get('visual', 0),
                'Audio': comparison_result.scores.get('audio', 0),
                'Color': comparison_result.scores.get('color', 0),
                'Motion': comparison_result.scores.get('motion', 0),
                'Scene': comparison_result.scores.get('scene', 0),
            }
        }

        # Generate charts
        charts = create_comparison_charts(comparison_data)

        # HTML template
        html_template = """
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Video Forensics Report</title>
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            max-width: 1200px;
            margin: 0 auto;
            padding: 20px;
            background: #f5f5f5;
        }
        .header {
            background: linear-gradient(135deg, #2E86DE 0%, #54A0FF 100%);
            color: white;
            padding: 30px;
            border-radius: 10px;
            margin-bottom: 30px;
            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
        }
        .header h1 {
            margin: 0;
            font-size: 32px;
        }
        .header p {
            margin: 10px 0 0 0;
            opacity: 0.9;
        }
        .section {
            background: white;
            padding: 25px;
            margin-bottom: 20px;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
        }
        .section h2 {
            color: #2E86DE;
            border-bottom: 2px solid #2E86DE;
            padding-bottom: 10px;
            margin-top: 0;
        }
        .classification {
            font-size: 24px;
            font-weight: bold;
            padding: 15px;
            border-radius: 5px;
            text-align: center;
            margin: 20px 0;
        }
        .classification.identical { background: #27AE60; color: white; }
        .classification.same_content { background: #2ECC71; color: white; }
        .classification.re-encoded { background: #3498DB; color: white; }
        .classification.cropped { background: #F39C12; color: white; }
        .classification.watermarked { background: #E67E22; color: white; }
        .classification.different { background: #E74C3C; color: white; }
        .score {
            font-size: 48px;
            font-weight: bold;
            text-align: center;
            margin: 20px 0;
        }
        .score.high { color: #27AE60; }
        .score.medium { color: #F39C12; }
        .score.low { color: #E74C3C; }
        .video-info {
            display: grid;
            grid-template-columns: 1fr 1fr;
            gap: 20px;
            margin: 20px 0;
        }
        .video-box {
            background: #f8f9fa;
            padding: 15px;
            border-radius: 5px;
            border-left: 4px solid #2E86DE;
        }
        .video-box h3 {
            margin-top: 0;
            color: #2E86DE;
        }
        .video-box p {
            margin: 5px 0;
            font-size: 14px;
        }
        .chart-container {
            text-align: center;
            margin: 20px 0;
        }
        .chart-container img {
            max-width: 100%;
            height: auto;
            border-radius: 5px;
        }
        .details-table {
            width: 100%;
            border-collapse: collapse;
            margin: 15px 0;
        }
        .details-table th {
            background: #2E86DE;
            color: white;
            padding: 12px;
            text-align: left;
        }
        .details-table td {
            padding: 10px 12px;
            border-bottom: 1px solid #ddd;
        }
        .details-table tr:hover {
            background: #f8f9fa;
        }
        .flag {
            display: inline-block;
            background: #3498DB;
            color: white;
            padding: 5px 10px;
            border-radius: 3px;
            font-size: 12px;
            margin: 2px;
        }
        .footer {
            text-align: center;
            padding: 20px;
            color: #7f8c8d;
            font-size: 14px;
        }
    </style>
</head>
<body>
    <div class="header">
        <h1>🎬 Video Forensics Analysis Report</h1>
        <p>Generated on {{ timestamp }}</p>
    </div>

    <div class="section">
        <h2>📊 Overall Result</h2>
        <div class="classification {{ classification }}">
            {{ classification_display }}
        </div>
        <div class="score {{ score_class }}">
            {{ overall_score }}%
        </div>
        <p style="text-align: center; color: #7f8c8d; font-size: 16px;">
            {{ explanation }}
        </p>
    </div>

    <div class="section">
        <h2>🎥 Video Information</h2>
        <div class="video-info">
            <div class="video-box">
                <h3>Video 1</h3>
                <p><strong>Path:</strong> {{ video1_path }}</p>
            </div>
            <div class="video-box">
                <h3>Video 2</h3>
                <p><strong>Path:</strong> {{ video2_path }}</p>
            </div>
        </div>
    </div>

    {% if charts %}
    <div class="section">
        <h2>📈 Visual Analysis</h2>
        {% for chart_name, chart_data in charts.items() %}
        <div class="chart-container">
            <img src="data:image/png;base64,{{ chart_data }}" alt="{{ chart_name }}">
        </div>
        {% endfor %}
    </div>
    {% endif %}

    <div class="section">
        <h2>📝 Detailed Scores</h2>
        <table class="details-table">
            <thead>
                <tr>
                    <th>Metric</th>
                    <th>Score</th>
                    <th>Status</th>
                </tr>
            </thead>
            <tbody>
                {% for metric, score in scores.items() %}
                <tr>
                    <td>{{ metric }}</td>
                    <td>{{ "%.1f"|format(score * 100) }}%</td>
                    <td>
                        {% if score >= 0.7 %}✅ High
                        {% elif score >= 0.5 %}⚠️ Medium
                        {% else %}❌ Low
                        {% endif %}
                    </td>
                </tr>
                {% endfor %}
            </tbody>
        </table>
    </div>

    {% if flags %}
    <div class="section">
        <h2>🏴 Detection Flags</h2>
        <p>
            {% for flag in flags %}
            <span class="flag">{{ flag }}</span>
            {% endfor %}
        </p>
    </div>
    {% endif %}

    <div class="footer">
        <p>Generated by Video Forensics Tool | © 2026</p>
        <p>This report contains automated analysis results and should be reviewed by a human expert.</p>
    </div>
</body>
</html>
        """

        template = Template(html_template)

        # Determine score class
        overall = comparison_result.overall_score * 100
        if overall >= 70:
            score_class = "high"
        elif overall >= 40:
            score_class = "medium"
        else:
            score_class = "low"

        # Prepare template variables
        html_content = template.render(
            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            classification=comparison_result.classification,
            classification_display=comparison_result.classification.replace('_', ' ').title(),
            overall_score=f"{overall:.1f}",
            score_class=score_class,
            explanation=comparison_result.explanation,
            video1_path=v1_path,
            video2_path=v2_path,
            charts=charts,
            scores=comparison_result.scores,
            flags=comparison_result.flags
        )

        # Write to file
        with open(output_path, 'w', encoding='utf-8') as f:
            f.write(html_content)

        print(f"HTML report generated: {output_path}")
        return True

    except Exception as e:
        print(f"HTML report generation failed: {e}")
        return False

def generate_pdf_report(comparison_result: 'VideoComparison',
                       v1_path: str, v2_path: str,
                       output_path: str) -> bool:
    """
    Generate comprehensive PDF report from comparison results.

    Args:
        comparison_result: VideoComparison object
        v1_path: Path to first video
        v2_path: Path to second video
        output_path: Path to save PDF report

    Returns:
        True if successful, False otherwise
    """
    if not REPORTLAB_AVAILABLE:
        print("ReportLab not available. Install with: pip install reportlab")
        return False

    try:
        doc = SimpleDocTemplate(output_path, pagesize=letter)
        story = []
        styles = getSampleStyleSheet()

        # Custom styles
        title_style = ParagraphStyle(
            'CustomTitle',
            parent=styles['Heading1'],
            fontSize=24,
            textColor=colors.HexColor('#2E86DE'),
            spaceAfter=30,
            alignment=TA_CENTER
        )

        heading_style = ParagraphStyle(
            'CustomHeading',
            parent=styles['Heading2'],
            fontSize=16,
            textColor=colors.HexColor('#2E86DE'),
            spaceAfter=12,
            spaceBefore=12
        )

        # Title
        story.append(Paragraph("🎬 Video Forensics Analysis Report", title_style))
        story.append(Spacer(1, 0.2 * inch))

        # Overall Result
        story.append(Paragraph("Overall Result", heading_style))

        overall_score = comparison_result.overall_score * 100
        classification_text = comparison_result.classification.replace('_', ' ').title()

        # Classification box
        class_data = [[f"Classification: {classification_text}"],
                     [f"Overall Similarity: {overall_score:.1f}%"],
                     [comparison_result.explanation]]

        class_table = Table(class_data, colWidths=[6 * inch])
        class_table.setStyle(TableStyle([
            ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#2E86DE')),
            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
            ('FONTSIZE', (0, 0), (-1, 0), 14),
            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
            ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
            ('GRID', (0, 0), (-1, -1), 1, colors.black)
        ]))

        story.append(class_table)
        story.append(Spacer(1, 0.3 * inch))

        # Video Information
        story.append(Paragraph("Video Information", heading_style))

        video_data = [
            ['Property', 'Video 1', 'Video 2'],
            ['Path', Path(v1_path).name, Path(v2_path).name]
        ]

        video_table = Table(video_data, colWidths=[2 * inch, 2 * inch, 2 * inch])
        video_table.setStyle(TableStyle([
            ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#2E86DE')),
            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
            ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
            ('FONTSIZE', (0, 0), (-1, -1), 10),
            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
            ('BACKGROUND', (0, 1), (-1, -1), colors.lightgrey),
            ('GRID', (0, 0), (-1, -1), 1, colors.black)
        ]))

        story.append(video_table)
        story.append(Spacer(1, 0.3 * inch))

        # Detailed Scores
        story.append(Paragraph("Detailed Similarity Scores", heading_style))

        score_data = [['Metric', 'Score', 'Status']]
        for metric, score in comparison_result.scores.items():
            score_pct = score * 100
            if score >= 0.7:
                status = '✓ High'
            elif score >= 0.5:
                status = '⚠ Medium'
            else:
                status = '✗ Low'
            score_data.append([metric.title(), f'{score_pct:.1f}%', status])

        score_table = Table(score_data, colWidths=[2 * inch, 2 * inch, 2 * inch])
        score_table.setStyle(TableStyle([
            ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#2E86DE')),
            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
            ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
            ('FONTSIZE', (0, 0), (-1, -1), 10),
            ('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.white, colors.lightgrey]),
            ('GRID', (0, 0), (-1, -1), 1, colors.black)
        ]))

        story.append(score_table)
        story.append(Spacer(1, 0.3 * inch))

        # Generate charts and add to PDF
        comparison_data = {
            'scores': comparison_result.scores
        }
        charts = create_comparison_charts(comparison_data)

        if charts:
            story.append(PageBreak())
            story.append(Paragraph("Visual Analysis", heading_style))

            for chart_name, chart_data in charts.items():
                # Decode base64 and create image
                img_data = base64.b64decode(chart_data)
                img_buffer = BytesIO(img_data)

                # Add image to PDF
                img = RLImage(img_buffer, width=5 * inch, height=3.5 * inch)
                story.append(img)
                story.append(Spacer(1, 0.2 * inch))

        # Flags
        if comparison_result.flags:
            story.append(Paragraph("Detection Flags", heading_style))
            flags_text = ', '.join(comparison_result.flags)
            story.append(Paragraph(flags_text, styles['Normal']))

        # Build PDF
        doc.build(story)

        print(f"PDF report generated: {output_path}")
        return True

    except Exception as e:
        print(f"PDF report generation failed: {e}")
        return False


# ===========================
# GUI Class
# ===========================

class CheckDiffTab:
    def __init__(self, parent, ffmpeg_location_var):
        self.parent = parent
        self.ffmpeg_location_var = ffmpeg_location_var
        self.video1_path = None
        self.video2_path = None

        self.parent.columnconfigure(0, weight=1)
        self.parent.columnconfigure(1, weight=2)  # Right side gets more space
        self.parent.rowconfigure(0, weight=1)

        self.setup_ui()

    def setup_ui(self):
        # Left side: Video selection
        left_frame = ttk.Frame(self.parent)
        left_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(0, 5))
        left_frame.columnconfigure(0, weight=1)
        left_frame.rowconfigure(0, weight=1)

        self.create_video_selection_section(left_frame)

        # Right side: Comparison results
        right_frame = ttk.Frame(self.parent)
        right_frame.grid(row=0, column=1, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(5, 0))
        right_frame.columnconfigure(0, weight=1)
        right_frame.rowconfigure(0, weight=1)
        right_frame.rowconfigure(1, weight=0)

        self.create_comparison_section(right_frame)
        self.create_result_section(right_frame)

    def create_video_selection_section(self, parent):
        """Left side: Video file selection"""
        selection_frame = ttk.LabelFrame(parent, text='Select Videos to Compare', padding='15')
        selection_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N), pady=(0, 10))
        selection_frame.columnconfigure(0, weight=1)

        # Video 1
        ttk.Label(selection_frame, text='Video 1:', font=('Segoe UI', 10, 'bold')).grid(
            row=1, column=0, sticky=tk.W, pady=(10, 5))

        video1_frame = ttk.Frame(selection_frame)
        video1_frame.grid(row=2, column=0, sticky=(tk.W, tk.E), pady=(0, 15))
        video1_frame.columnconfigure(0, weight=1)

        self.video1_var = tk.StringVar()
        ttk.Entry(video1_frame, textvariable=self.video1_var, state='readonly').grid(
            row=0, column=0, sticky=(tk.W, tk.E), padx=(0, 5))
        ttk.Button(video1_frame, text='Browse...', command=self.browse_video1, width=12).grid(
            row=0, column=1)

        # Video 2
        ttk.Label(selection_frame, text='Video 2:', font=('Segoe UI', 10, 'bold')).grid(
            row=3, column=0, sticky=tk.W, pady=(10, 5))

        video2_frame = ttk.Frame(selection_frame)
        video2_frame.grid(row=4, column=0, sticky=(tk.W, tk.E), pady=(0, 20))
        video2_frame.columnconfigure(0, weight=1)

        self.video2_var = tk.StringVar()
        ttk.Entry(video2_frame, textvariable=self.video2_var, state='readonly').grid(
            row=0, column=0, sticky=(tk.W, tk.E), padx=(0, 5))
        ttk.Button(video2_frame, text='Browse...', command=self.browse_video2, width=12).grid(
            row=0, column=1)

        # Compare button
        compare_btn = ttk.Button(selection_frame, text='Compare Videos',
                                command=self.compare_videos)
        compare_btn.grid(row=5, column=0, pady=(10, 0), ipadx=20, ipady=5)

    def create_comparison_section(self, parent):
        """Right side top: Metadata comparison table"""
        comp_frame = ttk.LabelFrame(parent, text='Metadata Comparison', padding='10')
        comp_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), pady=(0, 10))
        comp_frame.columnconfigure(0, weight=1)
        comp_frame.rowconfigure(0, weight=1)

        # Create treeview
        columns = ('property', 'video1', 'video2', 'similarity')
        self.comp_tree = ttk.Treeview(comp_frame, columns=columns, show='headings', height=18)

        self.comp_tree.heading('property', text='Property')
        self.comp_tree.heading('video1', text='Video 1')
        self.comp_tree.heading('video2', text='Video 2')
        self.comp_tree.heading('similarity', text='Similarity')

        self.comp_tree.column('property', width=150, anchor='w')
        self.comp_tree.column('video1', width=180, anchor='center')
        self.comp_tree.column('video2', width=180, anchor='center')
        self.comp_tree.column('similarity', width=100, anchor='center')

        # Scrollbar
        scrollbar = ttk.Scrollbar(comp_frame, orient=tk.VERTICAL, command=self.comp_tree.yview)
        self.comp_tree.configure(yscrollcommand=scrollbar.set)

        self.comp_tree.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        scrollbar.grid(row=0, column=1, sticky=(tk.N, tk.S))

    def create_result_section(self, parent):
        """Right side bottom: Overall similarity result"""
        result_frame = ttk.LabelFrame(parent, text='Overall Similarity', padding='15')
        result_frame.grid(row=1, column=0, sticky=(tk.W, tk.E))
        result_frame.columnconfigure(0, weight=1)

        self.result_label = ttk.Label(result_frame,
                                     text='Select two videos and click Compare to see results',
                                     font=('Segoe UI', 11),
                                     justify=tk.CENTER)
        self.result_label.grid(row=0, column=0, pady=5)

        # Export buttons frame
        export_frame = ttk.Frame(result_frame)
        export_frame.grid(row=1, column=0, pady=(10, 0))

        self.export_html_btn = ttk.Button(export_frame, text='📄 Export HTML Report',
                                          command=self.export_html_report, state='disabled')
        self.export_html_btn.grid(row=0, column=0, padx=5)

        self.export_pdf_btn = ttk.Button(export_frame, text='📑 Export PDF Report',
                                         command=self.export_pdf_report, state='disabled')
        self.export_pdf_btn.grid(row=0, column=1, padx=5)

        # Store comparison result for export
        self.last_comparison_result = None

    def browse_video1(self):
        filename = filedialog.askopenfilename(
            title='Select Video 1',
            filetypes=[('Video files', '*.mp4 *.avi *.mkv *.webm *.mov'), ('All files', '*.*')]
        )
        if filename:
            self.video1_path = filename
            self.video1_var.set(os.path.basename(filename))

    def browse_video2(self):
        filename = filedialog.askopenfilename(
            title='Select Video 2',
            filetypes=[('Video files', '*.mp4 *.avi *.mkv *.webm *.mov'), ('All files', '*.*')]
        )
        if filename:
            self.video2_path = filename
            self.video2_var.set(os.path.basename(filename))

    def compare_videos(self):
        if not self.video1_path or not self.video2_path:
            messagebox.showwarning('Warning', 'Please select both videos first!')
            return

        if not os.path.exists(self.video1_path):
            messagebox.showerror('Error', f'Video 1 does not exist:\n{self.video1_path}')
            return

        if not os.path.exists(self.video2_path):
            messagebox.showerror('Error', f'Video 2 does not exist:\n{self.video2_path}')
            return

        # Check if files are readable and not empty
        try:
            size1 = os.path.getsize(self.video1_path)
            size2 = os.path.getsize(self.video2_path)

            if size1 == 0:
                messagebox.showerror('Error', f'Video 1 is empty (0 bytes):\n{os.path.basename(self.video1_path)}')
                return

            if size2 == 0:
                messagebox.showerror('Error', f'Video 2 is empty (0 bytes):\n{os.path.basename(self.video2_path)}')
                return
        except Exception as e:
            messagebox.showerror('Error', f'Cannot access video files:\n{str(e)}')
            return

        # Clear previous results
        for item in self.comp_tree.get_children():
            self.comp_tree.delete(item)

        self.result_label.config(text='⏳ Analyzing videos, please wait...', foreground='black')

        # Run comparison in thread
        thread = threading.Thread(target=self.compare_videos_thread, daemon=True)
        thread.start()

    def compare_videos_thread(self):
        try:
            # Update status
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 1/11: Extracting metadata...'))

            # Get metadata using ffprobe
            meta1_raw = ffprobe_json(self.video1_path)
            meta2_raw = ffprobe_json(self.video2_path)

            # Parse metadata
            m1 = parse_metadata(meta1_raw)
            m2 = parse_metadata(meta2_raw)

            # Calculate metadata similarity
            meta_sim, meta_details = metadata_similarity(m1, m2)

            # Visual analysis - pHash
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 2/11: Extracting perceptual hashes...'))

            h1 = phash_frames(self.video1_path, every_sec=2.0, max_frames=80)
            h2 = phash_frames(self.video2_path, every_sec=2.0, max_frames=80)
            vis_sim, vis_details = visual_similarity(h1, h2)

            # Temporal alignment detection
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 3/11: Detecting temporal offset (trim detection)...'))

            temporal_offset, offset_sim, offset_details = detect_temporal_offset(h1, h2, max_offset=20)

            # ORB feature matching
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 4/11: ORB feature matching (crop/resize detection)...'))

            orb_sim, orb_details = orb_similarity(self.video1_path, self.video2_path, num_frames=20)

            # CLIP deep embedding (if available)
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 5/11: CLIP deep embedding (advanced content analysis)...'))

            clip_sim, clip_details = clip_similarity(self.video1_path, self.video2_path, num_frames=10)

            # Audio analysis
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 6/14: Analyzing audio (MFCC + Chroma)...'))

            aud_sim, aud_details = audio_similarity(self.video1_path, self.video2_path, seconds=90.0)

            # Enhanced audio spectrum analysis
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 7/14: Enhanced audio spectrum analysis...'))

            spectrum_sim, spectrum_details = audio_spectrum_similarity(self.video1_path, self.video2_path, duration=90.0)

            # Chromaprint audio fingerprint (if available)
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 8/14: Audio fingerprint (Chromaprint)...'))

            chromaprint_sim, chromaprint_details = chromaprint_similarity(self.video1_path, self.video2_path, duration=120)

            # Watermark detection
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 9/14: Detecting watermarks/logos...'))

            watermark_sim, watermark_details = watermark_similarity(self.video1_path, self.video2_path)

            # Text/subtitle detection (OCR)
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 10/14: Detecting text/subtitles (OCR)...'))

            text_sim, text_details = text_similarity(self.video1_path, self.video2_path)

            # Color analysis
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 11/14: Analyzing color distribution...'))

            color_sim, color_details = color_similarity(self.video1_path, self.video2_path, num_samples=20)

            # Scene structure analysis
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 12/14: Detecting scene changes...'))

            scene_sim, scene_details = scene_similarity(self.video1_path, self.video2_path)

            # Motion analysis
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 13/14: Analyzing motion patterns...'))

            motion_sim, motion_details = motion_similarity(self.video1_path, self.video2_path, num_samples=30)

            # VMAF analysis (perceptual quality metric)
            self.parent.after(0, lambda: self.result_label.config(
                text='Step 14/14: Computing VMAF (perceptual quality)...'))

            vmaf_sim, vmaf_details = vmaf_similarity(self.video1_path, self.video2_path, duration_limit=60.0)

            # Calculate overall similarity with all metrics
            self.parent.after(0, lambda: self.result_label.config(
                text='Computing overall similarity & classification...'))

            # Use best audio similarity (Chromaprint if available, else enhanced spectrum, else basic)
            # Priority: Chromaprint > Enhanced Spectrum > Basic MFCC+Chroma
            if CHROMAPRINT_AVAILABLE and chromaprint_sim > 0:
                best_audio_sim = chromaprint_sim
                audio_method = "chromaprint"
            elif spectrum_sim > 0:
                best_audio_sim = spectrum_sim
                audio_method = "enhanced_spectrum"
            else:
                best_audio_sim = aud_sim
                audio_method = "basic_mfcc_chroma"

            # Get full classification result
            comparison_result = classify_videos(
                meta_sim, vis_sim, best_audio_sim, m1, m2,
                color_sim=color_sim,
                scene_sim=scene_sim,
                motion_sim=motion_sim,
                vmaf_sim=vmaf_sim,
                orb_sim=orb_sim,
                clip_sim=clip_sim,
                temporal_offset=temporal_offset
            )

            # Update UI in main thread with all details
            self.parent.after(0, lambda: self.update_comparison_ui(
                m1, m2, meta_details, meta_sim, vis_sim, best_audio_sim,
                vis_details, aud_details, color_sim, color_details,
                scene_sim, scene_details, motion_sim, motion_details,
                vmaf_sim, vmaf_details, orb_sim, orb_details,
                clip_sim, clip_details, temporal_offset, offset_details,
                comparison_result,
                # New features
                spectrum_sim, spectrum_details,
                chromaprint_sim, chromaprint_details,
                watermark_sim, watermark_details,
                text_sim, text_details,
                audio_method))

        except Exception as e:
            import traceback
            error_tb = traceback.format_exc()

            # Create a more user-friendly error message
            error_title = "Analysis Failed"

            # Check for specific error types
            if isinstance(e, FileNotFoundError):
                error_msg = f"❌ File Not Found\n\n{str(e)}\n\nPlease make sure the video file exists."
            elif "moov atom not found" in str(e).lower() or "incomplete" in str(e).lower():
                error_msg = (
                    f"❌ Invalid or Incomplete Video File\n\n"
                    f"{str(e)}\n\n"
                    f"💡 Possible causes:\n"
                    f"• The file is still being created/encoded\n"
                    f"• The encoding process was interrupted\n"
                    f"• The file is corrupted\n\n"
                    f"Please wait for any active encoding to complete and try again."
                )
            elif "ffprobe" in str(e).lower() or "ffmpeg" in str(e).lower():
                error_msg = (
                    f"❌ FFmpeg/FFprobe Error\n\n"
                    f"{str(e)}\n\n"
                    f"💡 Make sure FFmpeg is properly installed and accessible."
                )
            else:
                error_msg = f"❌ Error\n\n{str(e)}\n\nFull traceback:\n{error_tb}"

            self.parent.after(0, lambda: messagebox.showerror(error_title, error_msg))
            self.parent.after(0, lambda: self.result_label.config(
                text='❌ Analysis failed. See error dialog for details.',
                foreground='red'))

    def update_comparison_ui(self, m1, m2, meta_details, meta_sim, vis_sim, aud_sim,
                            vis_details, aud_details, color_sim, color_details,
                            scene_sim, scene_details, motion_sim, motion_details,
                            vmaf_sim, vmaf_details, orb_sim, orb_details,
                            clip_sim, clip_details, temporal_offset, offset_details,
                            comparison_result: VideoComparison,
                            spectrum_sim=0, spectrum_details=None,
                            chromaprint_sim=0, chromaprint_details=None,
                            watermark_sim=0, watermark_details=None,
                            text_sim=0, text_details=None,
                            audio_method="basic_mfcc_chroma"):
        # Clear tree
        for item in self.comp_tree.get_children():
            self.comp_tree.delete(item)

        # Build properties list
        properties = [
            ('Duration', self.format_duration(m1.duration),
             self.format_duration(m2.duration), f"{pct(meta_details.get('duration', 0))}%"),
            ('File Size', self.format_size(m1.size),
             self.format_size(m2.size), f"{pct(meta_details.get('size_bytes', 0))}%"),
            ('Format', m1.format_name or 'N/A',
             m2.format_name or 'N/A', f"{pct(meta_details.get('format_name', 0))}%"),
            ('Overall Bitrate', f"{m1.overall_bitrate or 0} bps",
             f"{m2.overall_bitrate or 0} bps", f"{pct(meta_details.get('overall_bitrate', 0))}%"),
            ('Resolution', f"{m1.v_width or 0}x{m1.v_height or 0}",
             f"{m2.v_width or 0}x{m2.v_height or 0}", f"{pct(meta_details.get('resolution', 0))}%"),
            ('FPS', f"{m1.v_fps:.2f}" if m1.v_fps else 'N/A',
             f"{m2.v_fps:.2f}" if m2.v_fps else 'N/A', f"{pct(meta_details.get('fps', 0))}%"),
            ('Frame Count', str(m1.v_frame_count or 'N/A'),
             str(m2.v_frame_count or 'N/A'), f"{pct(meta_details.get('frame_count', 0))}%"),
            ('Video Codec', m1.v_codec or 'N/A',
             m2.v_codec or 'N/A', f"{pct(meta_details.get('v_codec', 0))}%"),
            ('Video Bitrate', f"{m1.v_bitrate or 0} bps",
             f"{m2.v_bitrate or 0} bps", f"{pct(meta_details.get('v_bitrate', 0))}%"),
            ('Pixel Format', m1.v_pix_fmt or 'N/A',
             m2.v_pix_fmt or 'N/A', f"{pct(meta_details.get('pix_fmt', 0))}%"),
            ('Audio Codec', m1.a_codec or 'N/A',
             m2.a_codec or 'N/A', f"{pct(meta_details.get('a_codec', 0))}%"),
            ('Sample Rate', f"{m1.a_sample_rate or 0} Hz",
             f"{m2.a_sample_rate or 0} Hz", f"{pct(meta_details.get('sample_rate', 0))}%"),
            ('Channels', str(m1.a_channels or 0),
             str(m2.a_channels or 0), f"{pct(meta_details.get('channels', 0))}%"),
            ('Audio Bitrate', f"{m1.a_bitrate or 0} bps",
             f"{m2.a_bitrate or 0} bps", f"{pct(meta_details.get('a_bitrate', 0))}%"),
            ('Tags Match', '-', '-', f"{pct(meta_details.get('tags_subset', 0))}%"),
        ]

        # Insert into tree
        for prop, val1, val2, sim in properties:
            self.comp_tree.insert('', tk.END, values=(prop, val1, val2, sim))

        # Add separator and breakdown
        self.comp_tree.insert('', tk.END, values=('=' * 20, '=' * 20, '=' * 20, '=' * 20))
        self.comp_tree.insert('', tk.END, values=('BASIC METRICS', '', '', ''))
        self.comp_tree.insert('', tk.END, values=('─' * 20, '─' * 20, '─' * 20, '─' * 20))

        # Basic metrics
        self.comp_tree.insert('', tk.END, values=('Metadata Similarity', '', '', f"{pct(meta_sim)}%"))
        self.comp_tree.insert('', tk.END, values=(
            'Visual (pHash)',
            f"{vis_details.get('frames_a', 0)} frames",
            f"{vis_details.get('frames_b', 0)} frames",
            f"{pct(vis_sim)}%"
        ))
        self.comp_tree.insert('', tk.END, values=(
            f'Audio ({audio_method})',
            f"cosine: {aud_details.get('cosine', 0):.2f}" if 'cosine' in aud_details else aud_details.get('method', 'N/A'),
            f"method: {audio_method}",
            f"{pct(aud_sim)}%"
        ))

        # Advanced audio analysis
        if spectrum_details and spectrum_sim > 0:
            self.comp_tree.insert('', tk.END, values=(
                '  ↳ Enhanced Spectrum',
                f"cosine: {spectrum_details.get('cosine', 0):.4f}",
                f"{spectrum_details.get('feature_dim', 0)}D features",
                f"{pct(spectrum_sim)}%"
            ))

        if chromaprint_details and chromaprint_sim > 0:
            if chromaprint_details.get('method') == 'chromaprint':
                self.comp_tree.insert('', tk.END, values=(
                    '  ↳ Chromaprint ★',
                    f"bit_match: {chromaprint_details.get('bit_match_rate', 0):.4f}",
                    f"length: {chromaprint_details.get('fingerprint_length', 0)}",
                    f"{pct(chromaprint_sim)}%"
                ))
            else:
                self.comp_tree.insert('', tk.END, values=(
                    '  ↳ Chromaprint',
                    'Not available',
                    'Install: pip install pyacoustid',
                    'N/A'
                ))

        # Advanced forensics metrics
        self.comp_tree.insert('', tk.END, values=('=' * 20, '=' * 20, '=' * 20, '=' * 20))
        self.comp_tree.insert('', tk.END, values=('FORENSICS ANALYSIS', '', '', ''))
        self.comp_tree.insert('', tk.END, values=('─' * 20, '─' * 20, '─' * 20, '─' * 20))

        # Temporal alignment
        self.comp_tree.insert('', tk.END, values=(
            'Temporal Offset',
            f"offset: {temporal_offset} frames",
            offset_details.get('note', 'N/A'),
            f"{pct(offset_details.get('similarity_at_best', 0))}%"
        ))

        # ORB features
        self.comp_tree.insert('', tk.END, values=(
            'ORB Features',
            f"ratio: {orb_details.get('avg_match_ratio', 0):.3f}",
            f"{orb_details.get('frames_compared', 0)} frames",
            f"{pct(orb_sim)}%"
        ))

        # CLIP embedding
        if clip_sim > 0:
            self.comp_tree.insert('', tk.END, values=(
                'CLIP Embedding ★',
                f"cosine: {clip_details.get('cosine_similarity', 0):.4f}",
                clip_details.get('method', 'N/A'),
                f"{pct(clip_sim)}%"
            ))
        else:
            self.comp_tree.insert('', tk.END, values=(
                'CLIP Embedding',
                'Not available',
                'Install: pip install torch clip',
                'N/A'
            ))

        # Watermark detection
        if watermark_details:
            wm1 = '✓ detected' if watermark_details.get('v1_watermark') else '✗ clean'
            wm2 = '✓ detected' if watermark_details.get('v2_watermark') else '✗ clean'
            self.comp_tree.insert('', tk.END, values=(
                'Watermark/Logo',
                f"{wm1} ({watermark_details.get('v1_regions', 0)} regions)",
                f"{wm2} ({watermark_details.get('v2_regions', 0)} regions)",
                f"{pct(watermark_sim)}%"
            ))

        # Text/subtitle detection
        if text_details:
            txt1 = '✓ detected' if text_details.get('v1_text') else '✗ no text'
            txt2 = '✓ detected' if text_details.get('v2_text') else '✗ no text'
            self.comp_tree.insert('', tk.END, values=(
                'Text/Subtitles (OCR)',
                f"{txt1} ({text_details.get('v1_text_ratio', 0):.1%})",
                f"{txt2} ({text_details.get('v2_text_ratio', 0):.1%})",
                f"{pct(text_sim)}%"
            ))

        self.comp_tree.insert('', tk.END, values=('─' * 20, '─' * 20, '─' * 20, '─' * 20))

        self.comp_tree.insert('', tk.END, values=(
            'Color Distribution',
            f"corr: {color_details.get('correlation', 0):.2f}",
            f"{color_details.get('samples', 0)} samples",
            f"{pct(color_sim)}%"
        ))

        self.comp_tree.insert('', tk.END, values=(
            'Scene Structure',
            f"{scene_details.get('scenes_v1', 0)} cuts",
            f"{scene_details.get('scenes_v2', 0)} cuts",
            f"{pct(scene_sim)}%"
        ))

        self.comp_tree.insert('', tk.END, values=(
            'Motion Patterns',
            f"dist: {motion_details.get('distance', 0):.2f}",
            f"{motion_details.get('samples', 0)} samples",
            f"{pct(motion_sim)}%"
        ))

        self.comp_tree.insert('', tk.END, values=(
            'VMAF (Perceptual) ★',
            f"score: {vmaf_details.get('vmaf_mean', 0):.2f}/100",
            f"{vmaf_details.get('duration_analyzed', 0):.0f}s analyzed",
            f"{pct(vmaf_sim)}%"
        ))

        # Classification result
        self.comp_tree.insert('', tk.END, values=('=' * 20, '=' * 20, '=' * 20, '=' * 20))
        self.comp_tree.insert('', tk.END, values=('CLASSIFICATION', '', '', ''))
        self.comp_tree.insert('', tk.END, values=('─' * 20, '─' * 20, '─' * 20, '─' * 20))

        self.comp_tree.insert('', tk.END, values=(
            'Classification',
            comparison_result.classification.upper(),
            f"Confidence: {comparison_result.confidence}",
            ''
        ))

        if comparison_result.flags:
            flags_str = ', '.join(comparison_result.flags)
            self.comp_tree.insert('', tk.END, values=(
                'Detected Changes',
                flags_str[:40],
                flags_str[40:] if len(flags_str) > 40 else '',
                ''
            ))

        # Update overall result
        total_sim = comparison_result.overall_score
        percentage = pct(total_sim)

        # Color coding based on classification
        if comparison_result.classification in ["identical", "same_content"]:
            color = 'green'
        elif comparison_result.classification in ["re-encoded", "trimmed"]:
            color = 'blue'
        elif comparison_result.classification in ["cropped", "watermarked"]:
            color = 'orange'
        else:
            color = 'red'

        self.result_label.config(
            text=f'Overall Similarity: {percentage}%\n\n'
                 f'Classification: {comparison_result.classification.upper()} '
                 f'(Confidence: {comparison_result.confidence})\n\n'
                 f'{comparison_result.explanation}\n\n'
                 f'Key Metrics:\n'
                 f'Metadata: {pct(meta_sim)}% | Visual: {pct(vis_sim)}% | Audio: {pct(aud_sim)}%\n'
                 f'ORB: {pct(orb_sim)}% | CLIP: {pct(clip_sim)}% | VMAF: {pct(vmaf_sim)}%',
            foreground=color)

        # Store comparison result for export
        self.last_comparison_result = comparison_result

        # Enable export buttons
        self.export_html_btn.config(state='normal')
        self.export_pdf_btn.config(state='normal')

    def export_html_report(self):
        """Export comparison results as HTML report"""
        if not self.last_comparison_result:
            messagebox.showwarning('Warning', 'No comparison results available!')
            return

        # Ask for save location
        output_path = filedialog.asksaveasfilename(
            title='Save HTML Report',
            defaultextension='.html',
            filetypes=[('HTML files', '*.html'), ('All files', '*.*')]
        )

        if output_path:
            try:
                success = generate_html_report(
                    self.last_comparison_result,
                    self.video1_path,
                    self.video2_path,
                    output_path
                )

                if success:
                    messagebox.showinfo('Success', f'HTML report saved to:\n{output_path}')
                else:
                    messagebox.showerror('Error', 'Failed to generate HTML report')
            except Exception as e:
                messagebox.showerror('Error', f'Failed to export HTML report:\n{str(e)}')

    def export_pdf_report(self):
        """Export comparison results as PDF report"""
        if not self.last_comparison_result:
            messagebox.showwarning('Warning', 'No comparison results available!')
            return

        # Ask for save location
        output_path = filedialog.asksaveasfilename(
            title='Save PDF Report',
            defaultextension='.pdf',
            filetypes=[('PDF files', '*.pdf'), ('All files', '*.*')]
        )

        if output_path:
            try:
                success = generate_pdf_report(
                    self.last_comparison_result,
                    self.video1_path,
                    self.video2_path,
                    output_path
                )

                if success:
                    messagebox.showinfo('Success', f'PDF report saved to:\n{output_path}')
                else:
                    messagebox.showerror('Error', 'Failed to generate PDF report')
            except Exception as e:
                messagebox.showerror('Error', f'Failed to export PDF report:\n{str(e)}')

    def format_duration(self, duration):
        if duration is None:
            return 'N/A'
        mins, secs = divmod(int(duration), 60)
        hours, mins = divmod(mins, 60)
        if hours:
            return f'{hours}:{mins:02d}:{secs:02d}'
        else:
            return f'{mins}:{secs:02d}'

    def format_size(self, size):
        if size is None:
            return 'N/A'
        if size < 1024 * 1024:
            return f'{size / 1024:.1f} KB'
        elif size < 1024 * 1024 * 1024:
            return f'{size / (1024 * 1024):.1f} MB'
        else:
            return f'{size / (1024 * 1024 * 1024):.2f} GB'