"""
Vehicle Speed Estimation and Counting - Gradio Interface
=========================================================

A real-time vehicle detection, tracking, counting, and speed estimation system
using YOLO object detection and perspective transformation techniques.

Authors:
    - Abhay Gupta (0205CC221005)
    - Aditi Lakhera (0205CC221011)
    - Balraj Patel (0205CC221049)
    - Bhumika Patel (0205CC221050)

This application provides an interactive web interface for analyzing traffic videos
and estimating vehicle speeds using computer vision techniques.
"""

import os
import sys
import tempfile
import logging
from pathlib import Path
from typing import Optional, Tuple

import gradio as gr
import cv2
import numpy as np

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# Try to import spaces for ZeroGPU support (with automatic CPU fallback)
try:
    import spaces
    ZEROGPU_AVAILABLE = True
    logger.info("✅ ZeroGPU support enabled - GPU acceleration available")
except ImportError:
    ZEROGPU_AVAILABLE = False
    logger.info("ℹ️ ZeroGPU not available - will use CPU (slower but functional)")
    # Create a dummy decorator for compatibility
    class spaces:
        @staticmethod
        def GPU(func):
            """Dummy decorator when ZeroGPU is not available"""
            return func

# Import application modules
try:
    from main import process_video
    from config import VehicleDetectionConfig
except ImportError as e:
    logger.error(f"Failed to import required modules: {e}")
    raise


def validate_video_file(video_path: str) -> Tuple[bool, str]:
    """
    Validate uploaded video file.
    
    Args:
        video_path: Path to video file
        
    Returns:
        Tuple of (is_valid, error_message)
    """
    if not video_path:
        return False, "No video file provided"
    
    if not os.path.exists(video_path):
        return False, f"Video file not found: {video_path}"
    
    # Check file size (limit to 100MB for HF Spaces)
    file_size_mb = os.path.getsize(video_path) / (1024 * 1024)
    if file_size_mb > 100:
        return False, f"Video file too large ({file_size_mb:.1f}MB). Maximum size is 100MB"
    
    # Validate video can be opened
    try:
        cap = cv2.VideoCapture(video_path)
        if not cap.isOpened():
            return False, "Unable to open video file. Please ensure it's a valid video format"
        
        # Check if video has frames
        ret, _ = cap.read()
        cap.release()
        
        if not ret:
            return False, "Video file appears to be empty or corrupted"
            
        return True, ""
    except Exception as e:
        return False, f"Error validating video: {str(e)}"


@spaces.GPU  # Enable ZeroGPU acceleration (automatic CPU fallback if unavailable)
def estimate_vehicle_speed(
    video_file: str,
    model_choice: str,
    line_position: int,
    confidence_threshold: float,
    progress=gr.Progress()
) -> Tuple[Optional[str], str]:
    """
    Process video and estimate vehicle speeds.
    
    This function is decorated with @spaces.GPU to enable automatic GPU
    acceleration when running on ZeroGPU Spaces. If GPU is not available,
    it automatically falls back to CPU processing.
    
    Args:
        video_file: Path to uploaded video
        model_choice: YOLO model selection
        line_position: Y-coordinate for counting line
        confidence_threshold: Detection confidence threshold
        progress: Gradio progress tracker
        
    Returns:
        Tuple of (output_video_path, statistics_text)
    """
    try:
        # Validate input
        progress(0, desc="Validating video file...")
        is_valid, error_msg = validate_video_file(video_file)
        if not is_valid:
            logger.error(f"Video validation failed: {error_msg}")
            return None, f"❌ Error: {error_msg}"
        
        # Create temporary output file
        output_path = tempfile.mktemp(suffix='.mp4')
        
        # Configure processing
        progress(0.1, desc="Configuring detection parameters...")
        config = VehicleDetectionConfig(
            input_video=video_file,
            output_video=output_path,
            model_name=model_choice,
            line_y=line_position,
            confidence_threshold=confidence_threshold
        )
        
        # Process video
        progress(0.2, desc="Processing video (this may take a few minutes)...")
        logger.info(f"Starting video processing: {video_file}")
        
        try:
            stats = process_video(
                config=config,
                progress_callback=lambda p: progress(0.2 + p * 0.7, desc=f"Processing... {int(p*100)}%")
            )
            
            progress(0.95, desc="Finalizing output...")
            
            # Format statistics
            stats_text = f"""
## 📊 Processing Results

### Vehicle Count Statistics
- **Total Vehicles Detected:** {stats['total_count']}
- **Vehicles Entering (In):** {stats['in_count']}
- **Vehicles Exiting (Out):** {stats['out_count']}

### Speed Analysis
- **Average Speed:** {stats['avg_speed']:.1f} km/h
- **Maximum Speed:** {stats['max_speed']:.1f} km/h
- **Minimum Speed:** {stats['min_speed']:.1f} km/h

### Processing Information
- **Frames Processed:** {stats['frames_processed']}
- **Processing Time:** {stats['processing_time']:.2f} seconds
- **Model Used:** {model_choice}
- **Detection Confidence:** {confidence_threshold:.2f}

✅ **Processing completed successfully!**
"""
            
            progress(1.0, desc="Complete!")
            logger.info("Video processing completed successfully")
            return output_path, stats_text
            
        except Exception as e:
            logger.error(f"Error during video processing: {e}", exc_info=True)
            return None, f"❌ **Processing Error:** {str(e)}\n\nPlease try with different settings or a different video."
    
    except Exception as e:
        logger.error(f"Unexpected error in estimate_vehicle_speed: {e}", exc_info=True)
        return None, f"❌ **Unexpected Error:** {str(e)}"


def create_demo_interface() -> gr.Blocks:
    """
    Create Gradio interface for vehicle speed estimation.
    
    Returns:
        Gradio Blocks interface
    """
    with gr.Blocks(
        title="Vehicle Speed Estimation & Counting"
    ) as demo:
        
        gr.Markdown("""
# 🚗 Vehicle Speed Estimation & Counting System

An intelligent traffic analysis system that detects, tracks, counts, and estimates the speed of vehicles in video footage using advanced computer vision techniques.

### 🎯 Features
- **Real-time Vehicle Detection** using YOLO
- **Multi-Object Tracking** with ByteTrack
- **Accurate Speed Estimation** via perspective transformation
- **Vehicle Counting** with configurable detection zones

### 👥 Developed By
- **Abhay Gupta** (0205CC221005)
- **Aditi Lakhera** (0205CC221011)
- **Balraj Patel** (0205CC221049)
- **Bhumika Patel** (0205CC221050)

---
""")
        
        with gr.Row():
            with gr.Column(scale=1):
                gr.Markdown("### 📤 Input Configuration")
                
                video_input = gr.Video(
                    label="Upload Traffic Video",
                    format="mp4"
                )
                
                with gr.Accordion("⚙️ Advanced Settings", open=False):
                    model_choice = gr.Dropdown(
                        choices=["yolov8n", "yolov8s", "yolov8m", "yolov8l"],
                        value="yolov8n",
                        label="YOLO Model",
                        info="Larger models are more accurate but slower"
                    )
                    
                    line_position = gr.Slider(
                        minimum=100,
                        maximum=1000,
                        value=480,
                        step=10,
                        label="Counting Line Position (Y-coordinate)",
                        info="Vertical position of the vehicle counting line"
                    )
                    
                    confidence_threshold = gr.Slider(
                        minimum=0.1,
                        maximum=0.9,
                        value=0.3,
                        step=0.05,
                        label="Detection Confidence Threshold",
                        info="Higher values reduce false positives"
                    )
                
                process_btn = gr.Button(
                    "🚀 Process Video",
                    variant="primary",
                    size="lg"
                )
                
                gr.Markdown("""
### 📋 Instructions
1. Upload a traffic video (MP4 format, max 100MB)
2. Adjust settings if needed (optional)
3. Click "Process Video" and wait for results
4. Download the annotated video with speed estimates

### 💡 Tips
- Use videos with clear vehicle visibility
- Ensure consistent camera angle
- Better lighting improves detection accuracy
""")
            
            with gr.Column(scale=1):
                gr.Markdown("### 📥 Output Results")
                
                video_output = gr.Video(
                    label="Processed Video with Annotations"
                )
                
                stats_output = gr.Markdown(
                    label="Statistics",
                    value="*Processing results will appear here...*"
                )
        
        # Example videos section
        gr.Markdown("""
---
### 🎬 Example Videos
Upload your own traffic video or use sample footage to test the system.
""")
        
        gr.Examples(
            examples=[
                ["./data/vehicles.mp4", "yolov8n", 480, 0.3],
            ],
            inputs=[video_input, model_choice, line_position, confidence_threshold],
            outputs=[video_output, stats_output],
            fn=estimate_vehicle_speed,
            cache_examples=False,
            label="Sample Videos"
        )
        
        # Connect processing function
        process_btn.click(
            fn=estimate_vehicle_speed,
            inputs=[video_input, model_choice, line_position, confidence_threshold],
            outputs=[video_output, stats_output]
        )
        
        gr.Markdown("""
---
### 🔬 Technical Details

This system uses:
- **YOLO (You Only Look Once)** for real-time object detection
- **ByteTrack** for multi-object tracking across frames
- **Perspective Transformation** for accurate speed calculation
- **OpenCV** for video processing and computer vision operations

### 📚 References
- [Ultralytics YOLO](https://github.com/ultralytics/ultralytics)
- [Supervision Library](https://github.com/roboflow/supervision)
- [OpenCV](https://opencv.org/)

### 📄 License
MIT License - See LICENSE file for details
""")
    
    return demo


if __name__ == "__main__":
    try:
        logger.info("Starting Vehicle Speed Estimation application...")
        demo = create_demo_interface()
        demo.launch(
            server_name="0.0.0.0",
            server_port=7860,
            share=False
        )
    except Exception as e:
        logger.error(f"Failed to launch application: {e}", exc_info=True)
        sys.exit(1)