/* Copyright (C) 2023 Purism SPC
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

/*! General V4L2 handling */

mod uvc;

use crate::actors::camera_list::CreationKit;
use crate::actors::watcher_udev as udev;
use std::error;
use std::fmt;
use std::io;
use std::ops::{Deref, DerefMut};
use std::sync::Arc;
use thiserror;
use tracing::warn;
use v4l::{FrameInterval, Format, FourCC};
use v4l::buffer;
use v4l::framesize;
use v4l::io::dmabuf;
use v4l::video::Capture;

pub type Error = Box<dyn error::Error>;

pub type CameraId = String;

pub struct Config {
    pub fourcc: v4l::FourCC,
    pub width: u32,
    pub height: u32,
}

/// Information about present camera
#[derive(Clone, Debug)]
pub struct CameraInfo {
    /// Information about the device
    pub device: udev::Device,
    /// ID assigned by this library (and the relevant backend)
    pub id: CameraId,
}

impl CameraInfo {
    pub fn is_for_device(&self, d: &udev::Device) -> bool {
        self.device == *d
    }
}

#[derive(thiserror::Error, Debug)]
pub enum AcquireError {
    #[error("Camera already acquired elsewhere")]
    AlreadyAcquired,
    #[error("Other error")]
    Other(())
}

pub type StreamBorrowing = Stream<dmabuf::Stream>;
pub type StreamManual = Stream<dmabuf::StreamManual>;

/// A way to stream buffers
pub struct Stream<T> {
    /// Makes sure that the lock on the camera is being held for the lifetime of the stream,
    /// despite that the dmabuf streaming mechanism doesn't really need anything but the fd.
    /// Without this, it would be possible to acquire the same camera again even as the stream exists, as soon as the original camera goes out of scope.
    // TODO: make it clear that this impl always takes a system-wide exclusive lock over the device.
    camera: Arc<dyn CameraImpl>,
    stream: T,
}

impl StreamManual {
    pub fn finish(self, buf: dmabuf::DmaBufProtected)
        -> Result<(), (io::Error, dmabuf::DmaBufProtected, Self)>
    {
        let camera = self.camera;
        self.stream.finish(buf)
            .map_err(|(e, buf, stream)| (e, buf, Self { camera, stream}))
    }
}

impl<T> fmt::Debug for Stream<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Stream for {:?}", Arc::as_ptr(&self.camera))
    }
}

impl<T> Deref for Stream<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.stream
    }
}
impl<T> DerefMut for Stream<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.stream
    }
}

pub struct AcquiredCamera(CameraId, Arc<dyn CameraImpl>);

impl AcquiredCamera {
    /// Returns globally unique, camera ID, stable for this device and for this software version (ideally for all software versions).
    pub fn get_id(&self) -> &str {
        &self.0
    }
    
    /// Starts recording from the camera
    pub fn start<'b>(&'b mut self, config: Config, buffer_count: usize)
        -> Result<Stream<dmabuf::Stream>, io::Error>
    {
        let camera = &self.1;
        camera.configure(config)?;
        Ok(Stream {
            camera: camera.clone(),
            stream: camera.start(buffer_count)?,
        })
    }
    
    /// Starts recording from the camera with manual buffer management
    pub fn start_manual(&mut self, config: Config, buffer_count: usize)
        -> Result<Stream<dmabuf::StreamManual>, io::Error>
    {
        let camera = &self.1;
        camera.configure(config)?;
        Ok(Stream {
            camera: camera.clone(),
            stream: camera.stream_manual(buffer_count)?,
        })
    }

    /// Returns a database of supported configs.
    ///
    /// Ignores all errors in intermediate calls, except when no valid config is found. Then the last error is returned.
    pub fn get_supported_configs(&self) -> io::Result<Vec<FrameInterval>> {
        let mut intervals = Vec::new();
        let d = self.1.video_capture_device();
        let formats = match d.enum_formats() {
            (list, Ok(_)) => list,
            (list, Err(e)) => if list.is_empty() {
                return Err(e);
            } else {
                list
            }
        };
        
        let mut last_error: Option<io::Error> = None;
        
        for f in formats {
            let (dims, res) = d.enum_framesizes(f.fourcc);
            if let Err(e) = res {
                warn!("Problem enumerating {:?}", f.fourcc);
                last_error = Some(e);
            }
            for dim in dims {
                for framesize::Discrete{width, height} in dim.size.to_discrete() {
                    let (mut ivals, res) = d.enum_frameintervals(f.fourcc, width, height);
                    if let Err(e) = res {
                        warn!("Problem enumerating {:?} {}×{}", f.fourcc, width, height); 
                        last_error = Some(e);
                    }
                    intervals.append(&mut ivals);
                }
            }
        }

        // extracts relevant fields from format
        fn ei(Format { width, height, fourcc, .. }: &Format) -> (u32, u32, FourCC) {
            (*width, *height, *fourcc)
        }

        let mut configs = Vec::with_capacity(intervals.len());

        for interval in intervals {
            let FrameInterval { fourcc, width, height, .. } = &interval;
            let format = Format::new(*width, *height, *fourcc);
            match d.set_format(&format) {
                Err(e) => {
                    warn!("Problem setting advertised format {:?}", format); 
                    last_error = Some(e);
                },
                Ok(_) => {
                    match d.format() {
                        Err(e) => {
                            warn!("Problem getting current format after setting {:?}", format); 
                            last_error = Some(e);
                        },
                        Ok(adjusted) => if ei(&adjusted) == ei(&format) {
                            configs.push(interval);
                        } else {
                            warn!("Advertised format got adjusted from {:?} to {:?}", format, adjusted); 
                            // Not adding this config here because we don't have enough data to determine the interval (could we query for it?)
                        },
                    }
                }
            }
        }
        
        match (last_error, configs.is_empty()) {
            (Some(e), true) => Err(e),
            _ => Ok(configs),
        }
    }
}

/// A detected camera device
pub struct UnacquiredCamera {
    id: String,
    device: Box<dyn UnacquiredCameraImpl>,
}

impl UnacquiredCamera {
    /// Returns globally unique, camera ID, stable for this device and for this software version (ideally for all software versions).
    pub fn get_id(&self) -> &str {
        &self.id
    }

    // This fn is not &mut because we want to allow the user to query ID regardless of camera state.
    pub fn acquire(self) -> Result<AcquiredCamera, Error> {
        let device = self.device.acquire()?;
        Ok(AcquiredCamera(self.id, device))
    }
}

/// A camera which has been detected, but not yet exclusively acquired for changing.
pub trait UnacquiredCameraImpl {
    /// Locks the camera for exlusive use, including the modification of its state.
    fn acquire(self: Box<Self>) -> Result<Arc<dyn CameraImpl>,  Error>;
}

/// An exclusive handle to a mutable camera resource.
///
/// This is the main trait to fill in by camera vendors, defining all the low-level operations on the camera apart from acquiring.
///
/// Types implementing this impl are required to hold a system-wide exclusive lock over the hardware resource for as long as the instance exists. See `::util::flock::Locked`.
/// TODO: stop streaming when dropped? This is internal API, so maybe the owner type already takes care of stopping.
pub trait CameraImpl: Send + Sync {
    /// Set configuration (TODO: the Config is nearly useless now)
    fn configure(&self, config: Config) -> Result<(), io::Error>;
    
    /// Start streaming
    fn start(&self, buffer_count: usize) -> Result<dmabuf::Stream, io::Error> {
        dmabuf::Stream::with_buffers(
            self.video_capture_device(),
            buffer::Type::VideoCapture,
            buffer_count as u32,
        )
    }
    /// Create a stream with manual buffer control.
    fn stream_manual(&self, buffer_count: usize) -> Result<dmabuf::StreamManual, io::Error> {
        dmabuf::StreamManual::new(
            self.video_capture_device(),
            buffer::Type::VideoCapture,
            buffer_count as u32,
        )
    }

    /// Return the video capture device. Private interface
    fn video_capture_device(&self) -> &v4l::Device;
}

/// This trait is only responsible for releasing the lock when dropped
pub trait Lock {}

pub type Builder = fn(camera: CameraInfo)
    -> Result<UnacquiredCamera, Error>;

pub type CheckFn = for<'a> fn(&'a udev::Device)
    -> Option<CreationKit>;

/// Put the entry function to every supported kind of camera here.
pub const PIPELINES: &'static [CheckFn] = &[
    uvc::Checker::check_match,
];