import gradio as gr
import tempfile
import os
from lane_detection import process_video as process_video_file


def process_video(video_path, method, use_enhanced, use_segmented, progress=gr.Progress()):
    """
    Process the uploaded video and return side-by-side comparison.
    Wrapper function for Gradio interface with progress tracking.
    """
    if video_path is None:
        return None

    # Create temporary output file with explicit .mp4 extension
    temp_dir = tempfile.gettempdir()
    temp_filename = f"lane_detection_{os.urandom(8).hex()}.mp4"
    output_path = os.path.join(temp_dir, temp_filename)
    
    try:
        # Progress callback function
        def update_progress(value, desc):
            progress(value, desc=desc)

        # Process the video with selected method and progress callback
        success = process_video_file(video_path, output_path, method, use_enhanced, use_segmented, progress_callback=update_progress)

        if success and os.path.exists(output_path):
            return output_path
        else:
            return None
    except Exception as e:
        print(f"Error processing video: {e}")
        import traceback
        traceback.print_exc()
        return None
    finally:
        # Clean up input if it was a temporary file
        if video_path and video_path.startswith(temp_dir):
            try:
                if os.path.exists(video_path):
                    os.remove(video_path)
            except:
                pass


# Create Gradio interface
with gr.Blocks(title="Lane Detection Demo") as demo:
    gr.Markdown("# 🚗 OpenCV Lane Detection Demo")
    gr.Markdown("Upload a video to detect lane lines. Choose between multiple advanced methods.")

    with gr.Row():
        with gr.Column():
            video_input = gr.Video(label="Upload Video")

            with gr.Row():
                method_selector = gr.Radio(
                    choices=[
                        "basic_standard",
                        "basic_segmented", 
                        "advanced",
                        "yolop",
                        "ufld",
                        "scnn"
                    ],
                    value="yolop",
                    label="Detection Method",
                    info="Select lane detection algorithm"
                )

            enhanced_checkbox = gr.Checkbox(
                value=True,
                label="Enhanced Thresholding",
                info="Better accuracy but slightly slower (Advanced method only)",
                visible=True
            )

            segmented_checkbox = gr.Checkbox(
                value=False,
                label="Segmented Lines",
                info="Multiple segments for better curve representation (Basic method only)",
                visible=False
            )

            process_btn = gr.Button("Process Video", variant="primary")

        with gr.Column():
            video_output = gr.Video(
                label="Result (Original | Lane Detection)",
                format="mp4"  # Explicitly set format for better browser compatibility
            )

    # Update checkbox visibility based on method
    def update_checkboxes(method):
        enhanced_visible = (method == "advanced")
        segmented_visible = (method in ["basic_standard", "basic_segmented"])
        return gr.Checkbox(visible=enhanced_visible), gr.Checkbox(visible=segmented_visible)

    method_selector.change(
        fn=update_checkboxes,
        inputs=method_selector,
        outputs=[enhanced_checkbox, segmented_checkbox]
    )

    process_btn.click(
        fn=process_video,
        inputs=[video_input, method_selector, enhanced_checkbox, segmented_checkbox],
        outputs=video_output
    )

    gr.Markdown("""
    ### Detection Methods:

    **🔹 Basic Standard (Hough Transform):**
    - Fast and lightweight
    - Good for straight lanes
    - Uses single averaged line per lane
    - Fastest processing speed

    **🔹 Basic Segmented (Hough Transform):**
    - Fast processing
    - Multiple line segments for better curve representation
    - Good for moderately curved lanes
    - Better than basic for curves

    **🔹 Advanced (Perspective Transform + Polynomial):**
    - Perspective transform to bird's eye view
    - Polynomial fitting with sliding windows
    - Excellent for curved and dashed lanes
    - Enhanced mode uses CLAHE and gradient filtering
    - Best accuracy but slower

    **🔹 YOLOP (Multi-task Learning):**
    - Inspired by YOLOP (You Only Look Once for Panoptic Driving)
    - Multi-color lane detection (white and yellow)
    - Contour-based segmentation
    - Good for various lane colors
    - Fast with good accuracy

    **🔹 UFLD (Ultra Fast Lane Detection):**
    - Inspired by Ultra Fast Structure-aware Deep Lane Detection
    - Row-wise classification approach
    - Adaptive thresholding with CLAHE
    - Excellent balance of speed and accuracy
    - Real-time capable

    **🔹 SCNN (Spatial CNN):**
    - Inspired by Spatial CNN for traffic lane detection
    - Spatial message passing in four directions
    - Multi-scale edge detection
    - Best for complex scenarios
    - High accuracy for challenging conditions

    ### How it works:
    1. Upload a video file containing road scenes
    2. Select detection method:
       - For fastest: Use **Basic Standard**
       - For curves: Use **Basic Segmented**, **UFLD**, or **Advanced**
       - For best accuracy: Use **SCNN** or **Advanced + Enhanced**
       - For multi-color lanes: Use **YOLOP**
    3. Click "Process Video" button and monitor the progress bar
    4. The system will process each frame and create a side-by-side comparison
    5. Download the result video showing original and detected lanes

    ### Tips:
    - **Basic Standard/Segmented**: Fastest, good for straight or gentle curves
    - **YOLOP**: Best for detecting both white and yellow lanes
    - **UFLD**: Excellent balance of speed and accuracy
    - **Advanced + Enhanced**: Best for dashed and curved lanes
    - **SCNN**: Best overall accuracy for complex road conditions
    """)


if __name__ == "__main__":
    demo.launch()