use anyhow::{anyhow, Context, Result};
use log::{debug, error, info, warn};
use std::path::Path;
use v4l::buffer::Type;
use v4l::io::traits::CaptureStream;
use v4l::prelude::*;
use v4l::video::Capture;
use v4l::{Format, FourCC};

use opencv::{core, imgproc, prelude::*};

use crate::camera::{ExposureMode, Resolution};

/// V4L2 camera driver for star-light cameras
pub struct V4l2Camera {
    /// The open device handle
    device: Device,
    /// The current camera format
    format: Format,
    /// Whether the camera is currently streaming
    is_streaming: bool,
}

impl V4l2Camera {
    /// Open a camera device by path
    pub fn open<P: AsRef<Path>>(path: P) -> Result<Self> {
        let device = Device::with_path(path.as_ref())
            .context("Failed to open camera device")?;
        
        info!(
            "Opened camera: {} ({})",
            device.info().card,
            device.info().driver
        );
        
        // Get the current format
        let format = device
            .format()
            .context("Failed to get camera format")?;
            
        debug!("Initial camera format: {:?}", format);
        
        Ok(Self {
            device,
            format,
            is_streaming: false,
        })
    }
    
    /// Set the camera resolution and pixel format
    pub fn set_format(&mut self, resolution: Resolution) -> Result<()> {
        let (width, height) = resolution.dimensions();
        
        // Try to set format to MJPEG or YUYV first, then fall back to others
        let formats = [FourCC::new(b"MJPG"), FourCC::new(b"YUYV")];
        
        let mut success = false;
        let mut last_error = None;
        
        for &fourcc in &formats {
            let mut format = Format::new(width, height, fourcc);
            
            match self.device.set_format(&mut format) {
                Ok(_) => {
                    self.format = format;
                    success = true;
                    break;
                }
                Err(e) => {
                    last_error = Some(e);
                    warn!("Failed to set format {:?}: {}", fourcc, last_error.as_ref().unwrap());
                }
            }
        }
        
        if !success {
            return Err(anyhow!(
                "Failed to set any supported format: {:?}",
                last_error.unwrap()
            ));
        }
        
        info!(
            "Set camera format: {}×{} {}",
            self.format.width, self.format.height, 
            String::from_utf8_lossy(&self.format.fourcc.repr)
        );
        
        Ok(())
    }
    
    /// Set the camera frame rate
    pub fn set_fps(&mut self, fps: u32) -> Result<()> {
        if let Some(params) = self.device.params() {
            let mut params = params.context("Failed to get camera parameters")?;
            params.set_frames_per_second(fps, 1);
            
            self.device
                .set_params(&params)
                .context("Failed to set frame rate")?;
                
            info!("Set camera frame rate: {} fps", fps);
        } else {
            warn!("Camera does not support frame rate adjustment");
        }
        
        Ok(())
    }
    
    /// Set camera exposure mode and value
    pub fn set_exposure(&mut self, mode: ExposureMode) -> Result<()> {
        // First, set auto/manual mode
        let ctrl_id = v4l::control::id::EXPOSURE_AUTO;
        let auto_value = match mode {
            ExposureMode::Auto => 3, // V4L2_EXPOSURE_AUTO
            ExposureMode::Manual(_) => 1, // V4L2_EXPOSURE_MANUAL
        };
        
        self.device
            .set_control(ctrl_id, auto_value)
            .context("Failed to set exposure mode")?;
            
        // If manual, set the exposure value
        if let ExposureMode::Manual(exposure_time) = mode {
            // Exposure time in microseconds
            let ctrl_id = v4l::control::id::EXPOSURE_ABSOLUTE;
            self.device
                .set_control(ctrl_id, exposure_time as i64)
                .context("Failed to set exposure time")?;
        }
        
        info!("Set camera exposure: {:?}", mode);
        Ok(())
    }
    
    /// Set camera gain (ISO)
    pub fn set_gain(&mut self, gain: u8) -> Result<()> {
        let ctrl_id = v4l::control::id::GAIN;
        
        self.device
            .set_control(ctrl_id, gain as i64)
            .context("Failed to set gain")?;
            
        info!("Set camera gain: {}", gain);
        Ok(())
    }
    
    /// Lock focus at infinity (if supported)
    pub fn lock_focus_at_infinity(&mut self) -> Result<()> {
        // First, set focus mode to manual
        let auto_focus_id = v4l::control::id::FOCUS_AUTO;
        if let Ok(_) = self.device.set_control(auto_focus_id, 0) {
            // Then set focus to infinity (typically maximum value)
            let focus_id = v4l::control::id::FOCUS_ABSOLUTE;
            
            // Get the range of the control
            if let Ok(control) = self.device.control(focus_id) {
                let max_focus = control.maximum();
                
                if let Ok(_) = self.device.set_control(focus_id, max_focus) {
                    info!("Locked focus at infinity (value: {})", max_focus);
                    return Ok(());
                }
            }
            
            warn!("Failed to set focus to infinity");
        } else {
            warn!("Camera does not support focus control");
        }
        
        Ok(())
    }
    
    /// Start streaming from the camera
    pub fn start_streaming(&mut self) -> Result<V4l2CaptureStream> {
        let queue = MmapStream::with_buffers(&self.device, Type::VideoCapture, 4)
            .context("Failed to create capture stream")?;
            
        self.is_streaming = true;
        info!("Started camera streaming");
        
        Ok(V4l2CaptureStream {
            stream: queue,
            format: self.format.clone(),
        })
    }
    
    /// Stop streaming from the camera
    pub fn stop_streaming(&mut self) -> Result<()> {
        // The streaming will be stopped when the CaptureStream is dropped
        self.is_streaming = false;
        info!("Stopped camera streaming");
        Ok(())
    }
    
    /// Check if the camera is currently streaming
    pub fn is_streaming(&self) -> bool {
        self.is_streaming
    }
    
    /// Get current format width
    pub fn width(&self) -> u32 {
        self.format.width
    }
    
    /// Get current format height
    pub fn height(&self) -> u32 {
        self.format.height
    }
    
    /// Get current format pixel format
    pub fn pixel_format(&self) -> FourCC {
        self.format.fourcc
    }
}

/// Wrapper around V4L2 capture stream
pub struct V4l2CaptureStream {
    stream: MmapStream,
    format: Format,
}

impl V4l2CaptureStream {
    /// Capture a single frame from the camera
    pub fn capture_frame(&mut self) -> Result<core::Mat> {
        let buffer = self.stream.next()
            .context("Failed to capture frame")?;
        
        let width = self.format.width as i32;
        let height = self.format.height as i32;
        
        // Convert the buffer to an OpenCV Mat based on the pixel format
        let mat = match self.format.fourcc {
            // MJPEG format
            f if f == FourCC::new(b"MJPG") => {
                // Decode JPEG data
                let data = buffer.data();
                let vec_data = unsafe {
                    std::slice::from_raw_parts(data.as_ptr(), data.len())
                }.to_vec();
                
                let buf = core::Vector::from_slice(&vec_data);
                let img = opencv::imgcodecs::imdecode(&buf, opencv::imgcodecs::IMREAD_COLOR)?;
                img
            },
            
            // YUYV format
            f if f == FourCC::new(b"YUYV") => {
                let data = buffer.data();
                
                // Create a Mat from the YUYV data
                let mut yuyv = unsafe {
                    let bytes_per_pixel = 2; // YUYV is 2 bytes per pixel
                    let step = width as usize * bytes_per_pixel;
                    core::Mat::new_rows_cols_with_data(
                        height,
                        width,
                        core::CV_8UC2,
                        data.as_ptr() as *mut _,
                        step,
                    )?
                };
                
                // Convert YUYV to BGR
                let mut bgr = core::Mat::default()?;
                imgproc::cvt_color(&yuyv, &mut bgr, imgproc::COLOR_YUV2BGR_YUYV, 0)?;
                bgr
            },
            
            // Unsupported format
            _ => {
                return Err(anyhow!(
                    "Unsupported pixel format: {}",
                    String::from_utf8_lossy(&self.format.fourcc.repr)
                ));
            }
        };
        
        Ok(mat)
    }
}

impl Drop for V4l2CaptureStream {
    fn drop(&mut self) {
        debug!("V4L2 capture stream dropped");
    }
}