"""
YOLOv8 Video Processing Script
Process videos with object detection and save annotated results
"""

import cv2
import time
from ultralytics import YOLO


def process_video(model, video_path, output_path):
    """
    Process video with YOLOv8 detection and save annotated results
    
    Args:
        model (YOLO): YOLO model instance
        video_path (str): Path to input video
        output_path (str): Path to save output video
    """
    # Open video capture
    cap = cv2.VideoCapture(video_path)
    
    # Get video properties
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    fps = int(cap.get(cv2.CAP_PROP_FPS))
    
    print(f"📹 Video: {video_path}")
    print(f"   Resolution: {width}x{height}")
    print(f"   FPS: {fps}")

    # Create VideoWriter object to save annotated video
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))

    frame_count = 0
    total_processing_time = 0

    while cap.isOpened():
        success, frame = cap.read()

        if success:
            # Measure processing time
            start_time = time.time()
            results = model(frame)
            end_time = time.time()
            
            processing_time = end_time - start_time
            fps_realtime = 1 / processing_time
            
            # Accumulate statistics
            frame_count += 1
            total_processing_time += processing_time
            
            # Visualize results on frame
            annotated_frame = results[0].plot()
            
            # Display metrics on frame
            text = f"Time: {processing_time:.3f}s | FPS: {fps_realtime:.1f}"
            cv2.putText(
                annotated_frame, 
                text,
                (10, 30), 
                cv2.FONT_HERSHEY_SIMPLEX, 
                0.8, 
                (0, 255, 0), 
                2,
                cv2.LINE_AA
            )

            # Write annotated frame to output
            out.write(annotated_frame)

            # Optional: Display real-time preview
            # cv2.imshow("YOLOv8 Detection", annotated_frame)
            # if cv2.waitKey(1) & 0xFF == ord("q"):
            #     break
        else:
            break

    # Cleanup
    cap.release()
    out.release()
    
    # Print summary statistics
    avg_fps = frame_count / total_processing_time if total_processing_time > 0 else 0
    print(f"✅ Processed {frame_count} frames")
    print(f"   Average FPS: {avg_fps:.2f}")
    print(f"   Saved to: {output_path}\n")


def main():
    """Main function to process multiple videos"""
    
    print("=" * 60)
    print("🚀 YOLOv8 Video Processing Pipeline")
    print("=" * 60 + "\n")
    
    # Load YOLOv8 model
    print("📦 Loading YOLOv8 model...")
    model = YOLO('yolov8x.pt')
    print("✅ Model loaded successfully!\n")

    # List of video files to process
    video_paths = [
        "../video/videoplayback-1.mp4",
        "../video/videoplayback-2.mp4",
        "../video/videoplayback-3.mp4",
        "../video/videoplayback-4.mp4",
    ]

    # Process each video
    total_videos = len(video_paths)
    for i, video_path in enumerate(video_paths, 1):
        output_path = f"../video/yolo_v8_output_{i}.mp4"
        
        print(f"[{i}/{total_videos}] Processing video...")
        process_video(model, video_path, output_path)

    cv2.destroyAllWindows()
    
    print("=" * 60)
    print("🎉 All videos processed successfully!")
    print("=" * 60)


if __name__ == '__main__':
    main()

"""
Side-by-Side Video Comparison Tool
Combine YOLOv7 and YOLOv8 results for visual comparison
"""

import cv2
import numpy as np


def combine_videos_side_by_side(video1_path, video2_path, output_path, 
                                 label1="YOLOv7", label2="YOLOv8"):
    """
    Combine two videos side by side for comparison
    
    Args:
        video1_path (str): Path to first video (e.g., YOLOv7 results)
        video2_path (str): Path to second video (e.g., YOLOv8 results)
        output_path (str): Path to save combined video
        label1 (str): Label for first video
        label2 (str): Label for second video
    """
    # Open video captures
    cap1 = cv2.VideoCapture(video1_path)
    cap2 = cv2.VideoCapture(video2_path)
    
    # Get video properties
    width = int(cap1.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap1.get(cv2.CAP_PROP_FRAME_HEIGHT))
    fps = int(cap1.get(cv2.CAP_PROP_FPS))
    
    print(f"📹 Combining videos:")
    print(f"   Video 1: {video1_path}")
    print(f"   Video 2: {video2_path}")
    print(f"   Output size: {width * 2}x{height}")
    
    # Create VideoWriter for combined output (double width)
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_path, fourcc, fps, (width * 2, height))
    
    frame_count = 0
    
    while True:
        ret1, frame1 = cap1.read()
        ret2, frame2 = cap2.read()
        
        if not ret1 or not ret2:
            break
        
        # Combine frames horizontally
        combined_frame = np.hstack((frame1, frame2))
        
        # Add labels with background for better visibility
        # Label 1 (left side)
        cv2.rectangle(combined_frame, (5, 5), (200, 45), (0, 0, 0), -1)
        cv2.putText(
            combined_frame, 
            label1, 
            (10, 35), 
            cv2.FONT_HERSHEY_SIMPLEX, 
            1.2, 
            (0, 255, 0), 
            2,
            cv2.LINE_AA
        )
        
        # Label 2 (right side)
        cv2.rectangle(combined_frame, (width + 5, 5), (width + 200, 45), (0, 0, 0), -1)
        cv2.putText(
            combined_frame, 
            label2, 
            (width + 10, 35), 
            cv2.FONT_HERSHEY_SIMPLEX, 
            1.2, 
            (255, 0, 0), 
            2,
            cv2.LINE_AA
        )
        
        # Add divider line
        cv2.line(
            combined_frame, 
            (width, 0), 
            (width, height), 
            (255, 255, 255), 
            2
        )
        
        out.write(combined_frame)
        frame_count += 1
        
        # Optional: show progress every 100 frames
        if frame_count % 100 == 0:
            print(f"   Processed {frame_count} frames...")
    
    # Cleanup
    cap1.release()
    cap2.release()
    out.release()
    
    print(f"✅ Combined {frame_count} frames")
    print(f"   Saved to: {output_path}\n")


def main():
    """Main function to create comparison videos"""
    
    print("=" * 60)
    print("🎬 Video Comparison Tool - YOLOv7 vs YOLOv8")
    print("=" * 60 + "\n")
    
    # Define video pairs to compare
    comparisons = [
        {
            'v7': "../video/yolo_v7_output_1.mp4",
            'v8': "../video/yolo_v8_output_1.mp4",
            'output': "../video/comparison_v7_vs_v8_test1.mp4"
        },
        {
            'v7': "../video/yolo_v7_output_2.mp4",
            'v8': "../video/yolo_v8_output_2.mp4",
            'output': "../video/comparison_v7_vs_v8_test2.mp4"
        },
    ]
    
    # Process each comparison
    for i, comp in enumerate(comparisons, 1):
        print(f"[{i}/{len(comparisons)}] Creating comparison video...")
        combine_videos_side_by_side(
            comp['v7'],
            comp['v8'],
            comp['output'],
            label1="YOLOv7",
            label2="YOLOv8"
        )
    
    print("=" * 60)
    print("🎉 All comparison videos created successfully!")
    print("=" * 60)


if __name__ == '__main__':
    main()