use anyhow::{Context, Result};
use chrono::Utc;
use clap::Parser;
use log::{debug, error, info, warn};
use opencv::{core, highgui, imgcodecs, imgproc, prelude::*, videoio};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use tokio::runtime::Runtime;

use meteor_detect::camera::frame_buffer::Frame;
use meteor_detect::detection::{
    AggregationStrategy, BrightnessDetector, BrightnessDetectorParams,
    CamsDetector, CamsDetectorParams, DetectionResult, DetectorConfig,
    DetectorFactory, MeteorDetector, PipelineConfig
};

/// Command line arguments for detector demo
#[derive(Parser, Debug)]
#[clap(author, version, about = "Meteor detection demo")]
struct Args {
    /// Input video file path or camera device number
    #[clap(short, long)]
    input: String,

    /// Output directory for feature images
    #[clap(short, long, default_value = "output")]
    output_dir: PathBuf,

    /// Brightness threshold for meteor detection
    #[clap(long, default_value = "30")]
    brightness_threshold: u8,

    /// Std-to-avg ratio threshold for meteor detection
    #[clap(long, default_value = "1.5")]
    std_ratio_threshold: f32,

    /// Minimum pixel count to trigger detection
    #[clap(long, default_value = "10")]
    min_pixel_count: u32,

    /// Minimum trajectory length
    #[clap(long, default_value = "5")]
    min_trajectory_length: u32,

    /// Save all feature images, not just detections
    #[clap(long)]
    save_all: bool,

    /// Display frames in real-time
    #[clap(short, long)]
    display: bool,

    /// Batch size (number of frames to process)
    #[clap(short, long, default_value = "256")]
    batch_size: usize,
    
    /// Detector type (cams, brightness, both)
    #[clap(short, long, default_value = "cams")]
    detector: String,
    
    /// Minimum brightness delta for brightness detector
    #[clap(long, default_value = "30.0")]
    min_brightness_delta: f32,
    
    /// Minimum pixel change for brightness detector
    #[clap(long, default_value = "10")]
    min_pixel_change: u32,
    
    /// Minimum consecutive frames for brightness detector
    #[clap(long, default_value = "3")]
    min_frames: u32,
    
    /// Sensitivity for brightness detector
    #[clap(long, default_value = "0.7")]
    sensitivity: f32,
    
    /// Run detection in parallel
    #[clap(long)]
    parallel: bool,
    
    /// Result aggregation strategy (any, all, majority)
    #[clap(long, default_value = "any")]
    aggregation: String,
}

fn main() -> Result<()> {
    // Set up logging
    env_logger::init();

    // Parse command line arguments
    let args = Args::parse();

    // Create output directory if it doesn't exist
    std::fs::create_dir_all(&args.output_dir)?;

    // Set up detector parameters
    let cams_params = CamsDetectorParams {
        brightness_threshold: args.brightness_threshold,
        std_to_avg_ratio_threshold: args.std_ratio_threshold,
        min_pixel_count: args.min_pixel_count,
        min_trajectory_length: args.min_trajectory_length,
        save_all_feature_images: args.save_all,
        output_dir: args.output_dir.clone(),
        file_prefix: "meteor".to_string(),
        id: "cams-demo".to_string(),
    };
    
    let brightness_params = BrightnessDetectorParams {
        min_brightness_delta: args.min_brightness_delta,
        min_pixel_change: args.min_pixel_change,
        min_frames: args.min_frames,
        sensitivity: args.sensitivity,
        id: "brightness-demo".to_string(),
    };

    // Create detectors based on command line argument
    let mut detectors: Vec<Box<dyn MeteorDetector>> = Vec::new();
    
    match args.detector.as_str() {
        "cams" => {
            detectors.push(Box::new(CamsDetector::with_params(cams_params)));
            info!("Using CAMS detector");
        },
        "brightness" => {
            detectors.push(Box::new(BrightnessDetector::with_params(brightness_params)));
            info!("Using brightness detector");
        },
        "both" => {
            detectors.push(Box::new(CamsDetector::with_params(cams_params)));
            detectors.push(Box::new(BrightnessDetector::with_params(brightness_params)));
            info!("Using both CAMS and brightness detectors");
        },
        _ => {
            return Err(anyhow::anyhow!("Unknown detector type: {}", args.detector));
        }
    }
    
    // Set up detection pipeline config if running in parallel
    let aggregation_strategy = match args.aggregation.as_str() {
        "any" => AggregationStrategy::Any,
        "all" => AggregationStrategy::All,
        "majority" => AggregationStrategy::Majority,
        _ => AggregationStrategy::Any,
    };

    // Open video source
    let mut cap = if args.input.chars().all(char::is_numeric) {
        // Input is a camera device number
        let device_id = args.input.parse::<i32>().unwrap_or(0);
        videoio::VideoCapture::new(device_id, videoio::CAP_ANY)?
    } else {
        // Input is a video file
        videoio::VideoCapture::from_file(&args.input, videoio::CAP_ANY)?
    };

    // Check if video source is opened
    if !cap.is_opened()? {
        return Err(anyhow::anyhow!("Failed to open video source: {}", args.input));
    }

    // Get video properties
    let fps = cap.get(videoio::CAP_PROP_FPS)?;
    let frame_width = cap.get(videoio::CAP_PROP_FRAME_WIDTH)? as i32;
    let frame_height = cap.get(videoio::CAP_PROP_FRAME_HEIGHT)? as i32;
    let frame_count = cap.get(videoio::CAP_PROP_FRAME_COUNT)? as i64;

    info!(
        "Video source: {}x{}, {:.2} fps, {} frames",
        frame_width, frame_height, fps, frame_count
    );

    // Create window if display is enabled
    if args.display {
        highgui::named_window("Video", highgui::WINDOW_NORMAL)?;
        highgui::resize_window("Video", 800, 600)?;
    }

    // Initialize frame counter and runtime
    let mut frame_idx: u64 = 0;
    let mut runtime = if args.parallel {
        Some(Runtime::new()?)
    } else {
        None
    };

    // Start time
    let start_time = Instant::now();

    // Process frames
    let mut frame = core::Mat::default();
    let mut detections = 0;
    
    // Convert detectors to thread-safe Arc<Mutex<Box<dyn MeteorDetector>>> for parallel mode
    let shared_detectors: Vec<Arc<Mutex<Box<dyn MeteorDetector>>>> = detectors
        .into_iter()
        .map(|d| Arc::new(Mutex::new(d)))
        .collect();

    while cap.read(&mut frame)? {
        // Skip empty frames
        if frame.empty() {
            warn!("Empty frame received, skipping");
            continue;
        }

        // Process frame with detector(s)
        let results = if args.parallel && runtime.is_some() {
            // Process in parallel using tokio runtime
            let runtime = runtime.as_ref().unwrap();
            runtime.block_on(async {
                // Create a future for each detector
                let mut handles = Vec::with_capacity(shared_detectors.len());
                
                for detector in &shared_detectors {
                    let frame = frame.clone();
                    let detector = detector.clone();
                    
                    let handle = tokio::spawn(async move {
                        let mut detector = detector.lock().unwrap();
                        match detector.process_frame(&frame, frame_idx) {
                            Ok(result) => Some(result),
                            Err(e) => {
                                error!("Error processing frame with detector {}: {}", 
                                       detector.get_id(), e);
                                None
                            }
                        }
                    });
                    
                    handles.push(handle);
                }
                
                // Wait for all detectors to complete
                let results = futures::future::join_all(handles).await;
                
                // Collect results
                results.into_iter()
                    .filter_map(|r| r.ok().flatten())
                    .collect::<Vec<_>>()
            })
        } else {
            // Process sequentially
            let mut results = Vec::new();
            
            for detector in &shared_detectors {
                let mut detector = detector.lock().unwrap();
                match detector.process_frame(&frame, frame_idx) {
                    Ok(result) => {
                        results.push(result);
                    }
                    Err(e) => {
                        error!("Error processing frame with detector {}: {}", 
                               detector.get_id(), e);
                    }
                }
            }
            
            results
        };
        
        // Aggregate results based on strategy
        let detected = match aggregation_strategy {
            AggregationStrategy::Any => results.iter().any(|r| r.detected),
            AggregationStrategy::All => results.iter().all(|r| r.detected) && !results.is_empty(),
            AggregationStrategy::Majority => {
                let count = results.iter().filter(|r| r.detected).count();
                count > results.len() / 2 && !results.is_empty()
            },
            _ => results.iter().any(|r| r.detected),
        };
        
        // Find result with highest confidence
        let result = if detected {
            results.iter()
                .filter(|r| r.detected)
                .max_by(|a, b| a.confidence.partial_cmp(&b.confidence).unwrap())
                .cloned()
        } else {
            results.first().cloned()
        };
        
        if let Some(result) = result {
            if result.detected {
                detections += 1;
                info!(
                    "Meteor detected at frame {}: confidence={:.2}, pixels={}, detector={}",
                    frame_idx, result.confidence, result.pixel_change, 
                    result.detector_id.as_deref().unwrap_or("unknown")
                );

                // Draw bounding box if we have one
                if let Some(bbox) = result.bounding_box {
                    let rect = core::Rect::new(
                        bbox.0 as i32,
                        bbox.1 as i32,
                        bbox.2 as i32,
                        bbox.3 as i32,
                    );
                    let mut display_frame = frame.clone();
                    imgproc::rectangle(
                        &mut display_frame,
                        rect,
                        core::Scalar::new(0.0, 255.0, 0.0, 0.0),
                        2,
                        imgproc::LINE_8,
                        0,
                    )?;

                    // Save detection frame
                    let detection_path = args
                        .output_dir
                        .join(format!("detection_{}_frame.jpg", frame_idx));
                    imgcodecs::imwrite(
                        detection_path.to_str().unwrap(),
                        &display_frame,
                        &core::Vector::new(),
                    )?;
                }
            }

            // Display progress
            if frame_idx % 100 == 0 {
                let elapsed = start_time.elapsed();
                let fps = frame_idx as f64 / elapsed.as_secs_f64();
                debug!(
                    "Processed {} frames ({:.2} fps), {} detections",
                    frame_idx,
                    fps,
                    detections,
                );
            }

            // Display frame if enabled
            if args.display {
                // Draw text with frame information
                let mut display_frame = frame.clone();
                let text = format!(
                    "Frame: {} | Detections: {} | {}",
                    frame_idx,
                    detections,
                    if detected {
                        format!("METEOR DETECTED - Confidence: {:.2}", result.confidence)
                    } else {
                        "No detection".to_string()
                    }
                );
                imgproc::put_text(
                    &mut display_frame,
                    &text,
                    core::Point::new(20, 40),
                    imgproc::FONT_HERSHEY_SIMPLEX,
                    0.7,
                    core::Scalar::new(0.0, 255.0, 0.0, 0.0),
                    2,
                    imgproc::LINE_8,
                    false,
                )?;

                // Show frame
                highgui::imshow("Video", &display_frame)?;

                // Wait for key press (30ms delay for video playback)
                let key = highgui::wait_key(30)?;
                if key > 0 && key != 255 {
                    // 'q' or ESC key pressed
                    if key == 113 || key == 27 {
                        info!("User requested exit");
                        break;
                    }
                }
            }
        }

        frame_idx += 1;
    }

    // Close video display window if enabled
    if args.display {
        highgui::destroy_all_windows()?;
    }

    // Calculate overall statistics
    let elapsed = start_time.elapsed();
    let overall_fps = frame_idx as f64 / elapsed.as_secs_f64();

    info!(
        "Processing complete: {} frames, {} detections, {:.2} fps average",
        frame_idx, detections, overall_fps
    );
    
    // Display detection mode info
    info!(
        "Detection mode: {}, {}",
        if args.parallel { "parallel" } else { "sequential" },
        match aggregation_strategy {
            AggregationStrategy::Any => "any detector",
            AggregationStrategy::All => "all detectors",
            AggregationStrategy::Majority => "majority of detectors",
            _ => "custom strategy",
        }
    );

    Ok(())
}