#[allow(dead_code)]
pub mod dpms;
pub mod xrandr;

use std::ffi::CStr;
use std::os::raw::{c_int, c_ulong};

use x11::xlib::{
    XCloseDisplay, XDefaultScreen, XDisplayName, XOpenDisplay, XRootWindow,
    _XDisplay,
};

/// Error returned if connecting to the X server fails
#[derive(Debug)]
pub struct OpenDisplayError;

/// Wrapper for an X display pointer
#[derive(Debug)]
pub struct Display {
    display: *mut _XDisplay,
}

#[allow(dead_code)]
impl Display {
    /// Open a connection to the X server
    ///
    /// If the connection succeeds, a [`Display`] is returned.  Otherwise, an
    /// [`OpenDisplayError`] is returned.
    pub fn open() -> Result<Self, OpenDisplayError> {
        let display = unsafe { XOpenDisplay(std::ptr::null()) };
        if display.is_null() {
            Err(OpenDisplayError)
        } else {
            Ok(Self { display })
        }
    }

    /// Return the name of the X server display
    ///
    /// If the display name cannot be determined, an empty string is returned.
    pub fn name() -> String {
        let name = unsafe { CStr::from_ptr(XDisplayName(std::ptr::null())) };
        let name = name.to_str().unwrap_or("");
        String::from(name)
    }

    /// Return the default screen number of the display
    pub fn default_screen(&self) -> c_int {
        unsafe { XDefaultScreen(self.display) }
    }

    /// Return the ID of the root window
    pub fn root_window(&self) -> c_ulong {
        let screen = self.default_screen();
        unsafe { XRootWindow(self.display, screen) }
    }
}

impl Drop for Display {
    fn drop(&mut self) {
        unsafe { XCloseDisplay(self.display) };
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_display_open() {
        let _dpy = Display::open().unwrap();
    }

    #[test]
    fn test_display_name() {
        assert!(!Display::name().is_empty());
    }

    #[test]
    fn test_default_screen() {
        let dpy = Display::open().unwrap();
        assert!(dpy.default_screen() > -1);
    }

    #[test]
    fn test_root_window() {
        let dpy = Display::open().unwrap();
        assert!(dpy.root_window() > 0);
    }
}