#![allow(non_snake_case)]
use x11_dl::xlib::{Display, Window};
x11_link! { XFixes, ["libXfixes.so", "libXfixes.so.3"],
    pub fn XFixesHideCursor (dpy: *mut Display, win: Window) -> (),
    pub fn XFixesShowCursor (dpy: *mut Display, win: Window) -> (),
variadic:
globals:
}

use std::{ptr, mem};
use xfixes;
use x11_dl::xlib;
pub use x11_dl::xlib::{
    // Structs
    Cursor,
    Screen,
    Time,
    Window,
    XColor,
    // Masks
    NoEventMask,
    KeyPressMask,
    KeyReleaseMask,
    ButtonPressMask,
    ButtonReleaseMask,
    EnterWindowMask,
    LeaveWindowMask,
    PointerMotionMask,
    PointerMotionHintMask,
    Button1MotionMask,
    Button2MotionMask,
    Button3MotionMask,
    Button4MotionMask,
    Button5MotionMask,
    ButtonMotionMask,
    KeymapStateMask,
    ExposureMask,
    VisibilityChangeMask,
    StructureNotifyMask,
    ResizeRedirectMask,
    SubstructureNotifyMask,
    SubstructureRedirectMask,
    FocusChangeMask,
    PropertyChangeMask,
    ColormapChangeMask,
    OwnerGrabButtonMask,
    // Other
    GrabModeAsync,
    CurrentTime,
};
use x11_dl::xinput2;
pub use x11_dl::xinput2::{
    // Macros
    XISetMask,
    XIClearMask,
    XIMaskIsSet,
    // Structs
    XIEventMask,
    // Devices
    XIAllMasterDevices,
    // Events
    XI_RawMotion,
    XI_LASTEVENT,
    // Masks
    XI_DeviceChangedMask,
    XI_KeyPressMask,
    XI_KeyReleaseMask,
    XI_ButtonPressMask,
    XI_ButtonReleaseMask,
    XI_MotionMask,
    XI_EnterMask,
    XI_LeaveMask,
    XI_FocusInMask,
    XI_FocusOutMask,
    XI_HierarchyChangedMask,
    XI_PropertyEventMask,
    XI_RawKeyPressMask,
    XI_RawKeyReleaseMask,
    XI_RawButtonPressMask,
    XI_RawButtonReleaseMask,
    XI_RawMotionMask,
    XI_TouchBeginMask,
    XI_TouchEndMask,
    XI_TouchOwnershipChangedMask,
    XI_TouchUpdateMask,
    XI_RawTouchBeginMask,
    XI_RawTouchEndMask,
    XI_RawTouchUpdateMask,
    XI_BarrierHitMask,
    XI_BarrierLeaveMask,
};
pub struct Display {
    xlib: xlib::Xlib,
    xinput2: xinput2::XInput2,
    xfixes: xfixes::XFixes,
    display: *mut xlib::Display,
}
impl Display {
    pub fn open() -> Self {
        let xlib = xlib::Xlib::open().unwrap();
        let xinput2 = xinput2::XInput2::open().unwrap();
        let xfixes = xfixes::XFixes::open().unwrap();
        let display = unsafe { (xlib.XOpenDisplay)(ptr::null()) };
        if display.is_null() {
            panic!("Failed to open display");
        }
        Display {
            xlib: xlib,
            xinput2: xinput2,
            xfixes: xfixes,
            display: display
        }
    }
    // xlib interface
    pub fn connection_number(&self) -> i32 {
        unsafe { (self.xlib.XConnectionNumber)(self.display) }
    }
    pub fn default_root_window(&self) -> u64 {
        unsafe { (self.xlib.XDefaultRootWindow)(self.display) }
    }
    pub fn default_screen_of_display(&self) -> &Screen {
        unsafe { &*(self.xlib.XDefaultScreenOfDisplay)(self.display) }
    }
    pub fn flush(&self) {
        unsafe { (self.xlib.XFlush)(self.display) };
    }
    pub fn grab_pointer(&self, grab_window: Window, owner_events: bool,
                        event_mask: i64, pointer_mode: i32, keyboard_mode: i32,
                        confine_to: Window, cursor: Cursor, time: Time)
    {
        unsafe { (self.xlib.XGrabPointer)(
            self.display, grab_window, owner_events as i32, event_mask as u32,
            pointer_mode, keyboard_mode, confine_to, cursor, time
        ) };
    }
    pub fn next_event(&self) -> Event {
        let mut event: xlib::XEvent = unsafe { mem::uninitialized() };
        unsafe { (self.xlib.XNextEvent)(self.display, &mut event) };
        match event.get_type() {
            xlib::KeyPress => Event::KeyPress(From::from(event)),
            xlib::KeyRelease => Event::KeyRelease(From::from(event)),
            xlib::ButtonPress => Event::ButtonPress(From::from(event)),
            xlib::ButtonRelease => Event::ButtonRelease(From::from(event)),
            xlib::MotionNotify => Event::MotionNotify(From::from(event)),
            xlib::EnterNotify => Event::EnterNotify(From::from(event)),
            xlib::LeaveNotify => Event::LeaveNotify(From::from(event)),
            xlib::FocusIn => Event::FocusIn(From::from(event)),
            xlib::FocusOut => Event::FocusOut(From::from(event)),
            xlib::KeymapNotify => Event::KeymapNotify(From::from(event)),
            xlib::Expose => Event::Expose(From::from(event)),
            xlib::GraphicsExpose => Event::GraphicsExpose(From::from(event)),
            xlib::NoExpose => Event::NoExpose(From::from(event)),
            xlib::VisibilityNotify => Event::VisibilityNotify(From::from(event)),
            xlib::CreateNotify => Event::CreateNotify(From::from(event)),
            xlib::DestroyNotify => Event::DestroyNotify(From::from(event)),
            xlib::UnmapNotify => Event::UnmapNotify(From::from(event)),
            xlib::MapNotify => Event::MapNotify(From::from(event)),
            xlib::MapRequest => Event::MapRequest(From::from(event)),
            xlib::ReparentNotify => Event::ReparentNotify(From::from(event)),
            xlib::ConfigureNotify => Event::ConfigureNotify(From::from(event)),
            xlib::ConfigureRequest => Event::ConfigureRequest(From::from(event)),
            xlib::GravityNotify => Event::GravityNotify(From::from(event)),
            xlib::ResizeRequest => Event::ResizeRequest(From::from(event)),
            xlib::CirculateNotify => Event::CirculateNotify(From::from(event)),
            xlib::CirculateRequest => Event::CirculateRequest(From::from(event)),
            xlib::PropertyNotify => Event::PropertyNotify(From::from(event)),
            xlib::SelectionClear => Event::SelectionClear(From::from(event)),
            xlib::SelectionRequest => Event::SelectionRequest(From::from(event)),
            xlib::SelectionNotify => Event::SelectionNotify(From::from(event)),
            xlib::ColormapNotify => Event::ColormapNotify(From::from(event)),
            xlib::ClientMessage => Event::ClientMessage(From::from(event)),
            xlib::MappingNotify => Event::MappingNotify(From::from(event)),
            xlib::GenericEvent => Event::GenericEvent(From::from(event)),
            _ => unreachable!(),
        }
    }
    pub fn pending(&self) -> i32 {
        unsafe { (self.xlib.XPending)(self.display) }
    }
    pub fn query_pointer(&self) -> (Window, Window, i32, i32, i32, i32, u32) {
        unsafe {
            let root = self.default_root_window();
            let mut root_return: Window = mem::uninitialized();
            let mut child_return: Window = mem::uninitialized();
            let mut root_x: i32 = mem::uninitialized();
            let mut root_y: i32 = mem::uninitialized();
            let mut child_x: i32 = mem::uninitialized();
            let mut child_y: i32 = mem::uninitialized();
            let mut mask: u32 = mem::uninitialized();
            (self.xlib.XQueryPointer)(self.display, root,
                &mut root_return, &mut child_return, &mut root_x, &mut root_y,
                &mut child_x, &mut child_y, &mut mask
            );
            (root_return, child_return, root_x, root_y, child_x, child_y, mask)
        }
    }
    pub fn select_input(&self, w: Window, event_mask: i64) {
        unsafe { (self.xlib.XSelectInput)(self.display, w, event_mask) };
    }
    pub fn ungrab_pointer(&self, time: Time) {
        unsafe { (self.xlib.XUngrabPointer)(self.display, time) };
    }
    pub fn warp_pointer(&self, src_w: Window, dest_w: Window,
                        src_x: i32, src_y: i32, src_width: u32, src_height: u32,
                        dest_x: i32, dest_y: i32) {
        unsafe { (self.xlib.XWarpPointer)(
            self.display, src_w, dest_w, src_x, src_y,
            src_width, src_height, dest_x, dest_y
        ) };
    }
    // xinput2 interface
    pub fn xi_select_events(&self, win: Window, mask: &mut [XIEventMask]) {
        unsafe { (self.xinput2.XISelectEvents)(self.display, win, &mut mask[0] as *mut XIEventMask, mask.len() as i32) };
    }
    // xfixes
    pub fn show_cursor(&self, w: Window) {
        unsafe { (self.xfixes.XFixesShowCursor)(self.display, w) };
    }
    pub fn hide_cursor(&self, w: Window) {
        unsafe { (self.xfixes.XFixesHideCursor)(self.display, w) };
    }
}
impl Drop for Display {
    fn drop(&mut self) {
        unsafe { (self.xlib.XCloseDisplay)(self.display) };
    }
}
pub enum Event {
    KeyPress(xlib::XKeyPressedEvent),
    KeyRelease(xlib::XKeyReleasedEvent),
    ButtonPress(xlib::XButtonPressedEvent),
    ButtonRelease(xlib::XButtonReleasedEvent),
    MotionNotify(xlib::XMotionEvent),
    EnterNotify(xlib::XEnterWindowEvent),
    LeaveNotify(xlib::XLeaveWindowEvent),
    FocusIn(xlib::XFocusInEvent),
    FocusOut(xlib::XFocusOutEvent),
    KeymapNotify(xlib::XKeymapEvent),
    Expose(xlib::XExposeEvent),
    GraphicsExpose(xlib::XGraphicsExposeEvent),
    NoExpose(xlib::XNoExposeEvent),
    VisibilityNotify(xlib::XVisibilityEvent),
    CreateNotify(xlib::XCreateWindowEvent),
    DestroyNotify(xlib::XDestroyWindowEvent),
    UnmapNotify(xlib::XUnmapEvent),
    MapNotify(xlib::XMapEvent),
    MapRequest(xlib::XMapRequestEvent),
    ReparentNotify(xlib::XReparentEvent),
    ConfigureNotify(xlib::XConfigureEvent),
    ConfigureRequest(xlib::XConfigureRequestEvent),
    GravityNotify(xlib::XGravityEvent),
    ResizeRequest(xlib::XResizeRequestEvent),
    CirculateNotify(xlib::XCirculateEvent),
    CirculateRequest(xlib::XCirculateRequestEvent),
    PropertyNotify(xlib::XPropertyEvent),
    SelectionClear(xlib::XSelectionClearEvent),
    SelectionRequest(xlib::XSelectionRequestEvent),
    SelectionNotify(xlib::XSelectionEvent),
    ColormapNotify(xlib::XColormapEvent),
    ClientMessage(xlib::XClientMessageEvent),
    MappingNotify(xlib::XMappingEvent),
    GenericEvent(xlib::XGenericEventCookie),
}

#![allow(dead_code, unused_variables, unused_imports)]
extern crate mio;
extern crate x11_dl;
extern crate dylib;
#[macro_use] mod link;
mod xfixes;
mod x11;
use x11::*;
use mio::*;
use mio::udp::UdpSocket;
use std::net::{SocketAddr, SocketAddrV4};
use std::str;
const X11_TOKEN: Token = Token(0);
const NET_TOKEN: Token = Token(1);
fn main() {
    let config = (Ipv4Addr::new(239, 255, 80, 80), 8080, 8080);
    let mut event_loop = EventLoop::new().unwrap();
    let mut server = Server::new(&mut event_loop, config);
    event_loop.run(&mut server).unwrap();
}
struct Server {
    config: (Ipv4Addr, u16, u16),
    // I/O
    display: Display,
    x11_socket: Io, // Keep alive to prevent closing the X11 socket
    udp_socket: UdpSocket,
    // State
    x: i32, y: i32,
    real_x: i32, real_y: i32,
    focused: bool,
}
impl Server {
    fn new(event_loop: &mut EventLoop<Self>, config: (Ipv4Addr, u16, u16)) -> Self {
        // Setup X11 display
        let display = Display::open();
        let root = display.default_root_window();
        let mut mask = [0u8; (XI_LASTEVENT as usize + 7) / 8];
        XISetMask(&mut mask, XI_RawMotion);
        let mut events = [XIEventMask {
            deviceid: XIAllMasterDevices,
            mask_len: mask.len() as i32,
            mask: &mut mask[0] as *mut u8,
        }];
        display.xi_select_events(root, &mut events);
        let x11_socket = Io::from_raw_fd(display.connection_number());
        event_loop.register(&x11_socket,
                            X11_TOKEN,
                            EventSet::readable(),
                            PollOpt::level()).unwrap();
        display.flush(); // TODO: Not sure why this is necessary
        // Setup UDP socket
        let udp_socket = UdpSocket::v4().unwrap();
        udp_socket.join_multicast(&IpAddr::V4(config.0)).unwrap();
        udp_socket.bind(&SocketAddr::V4(
            SocketAddrV4::new(Ipv4Addr::new(0, 0, 0, 0), config.1)
        )).unwrap();
        // Listen for UDP connections
        event_loop.register(&udp_socket,
                            NET_TOKEN,
                            EventSet::readable(),
                            PollOpt::edge()).unwrap();
        // Query dimensions for local screen
        let (_, _, x, y, _, _, _) = display.query_pointer();
        Server {
            config: config,
            display: display,
            x11_socket: x11_socket,
            udp_socket: udp_socket,
            x: x, y: y,
            real_x: x, real_y: y,
            focused: true,
        }
    }
    fn update_cursor(&mut self, x: i32, y: i32) {
        let addr = SocketAddr::V4(SocketAddrV4::new(self.config.0, self.config.2));
        self.udp_socket.send_to(b"cursor move\n", &addr).unwrap();
        self.x += x - self.real_x;
        self.y += y - self.real_y;
        self.real_x = x;
        self.real_y = y;
        if self.cursor_in_screen() {
            self.focus();
        } else {
            self.unfocus();
        }
    }
    fn cursor_in_screen(&self) -> bool {
        let screen = self.display.default_screen_of_display();
        self.x > 0 && self.y > 0 && self.x < screen.width - 1 && self.y < screen.height - 1
    }
    fn unfocus(&mut self) {
        if self.focused {
            let root = self.display.default_root_window();
            self.display.hide_cursor(root);
            self.display.grab_pointer(root, true,
                                      PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
                                      GrabModeAsync, GrabModeAsync, 0, 0, CurrentTime);
            self.focused = false;
        }
        self.center_cursor();
    }
    fn focus(&mut self) {
        if !self.focused {
            self.restore_cursor();
            self.display.ungrab_pointer(CurrentTime);
            self.display.show_cursor(self.display.default_root_window());
            self.focused = true;
        }
    }
    fn center_cursor(&mut self) {
        let root = self.display.default_root_window();
        let screen = self.display.default_screen_of_display();
        self.real_x = screen.width / 2;
        self.real_y = screen.height / 2;
        self.display.warp_pointer(0, root, 0, 0, 0, 0, self.real_x, self.real_y);
        self.display.next_event();
    }
    fn restore_cursor(&mut self) {
        let root = self.display.default_root_window();
        self.real_x = self.x;
        self.real_y = self.y;
        self.display.warp_pointer(0, root, 0, 0, 0, 0, self.real_x, self.real_y);
        self.display.next_event();
    }
}
impl Handler for Server {
    type Timeout = ();
    type Message = ();
    #[allow(unused_variables)]
    fn ready(&mut self, event_loop: &mut EventLoop<Self>, token: Token, events: EventSet) {
        match token {
            X11_TOKEN => {
                // TODO: Would XEventsQueued with QueuedAlready make more sense?
                assert!(self.display.pending() != 0);
                match self.display.next_event() {
                    Event::MotionNotify(e) => {
                        self.update_cursor(e.x_root, e.y_root);
                    },
                    Event::KeyPress(e) => {
                    },
                    Event::ButtonPress(e) => {
                        let addr = SocketAddr::V4(SocketAddrV4::new(self.config.0, self.config.2));
                        self.udp_socket.send_to(b"button press\n", &addr).unwrap();
                    },
                    Event::ButtonRelease(e) => {
                        let addr = SocketAddr::V4(SocketAddrV4::new(self.config.0, self.config.2));
                        self.udp_socket.send_to(b"button release\n", &addr).unwrap();
                    },
                    Event::GenericEvent(e) => {
                        let (_, _, x, y, _, _, _) = self.display.query_pointer();
                        self.update_cursor(x, y);
                    },
                    _ => unreachable!(),
                }
            },
            NET_TOKEN => {
                let mut buf = [0u8; 255];
                match self.udp_socket.recv_from(&mut buf).unwrap() {
                    Some((len, addr)) => {
                        print!("{}: {}", addr, str::from_utf8(&buf[..len]).unwrap());
                    },
                    None => (),
                }
            },
            _ => unreachable!(),
        }
    }
}

// x11-rs: Rust bindings for X11 libraries
// The X11 libraries are available under the MIT license.
// These bindings are public domain.
use std::path::Path;
use dylib::DynamicLibrary;
use x11_dl::error::{
  OpenError,
  OpenErrorKind,
};
//
// x11_link!
//
macro_rules! x11_link {
  { $struct_name:ident, [$($lib_name:expr),*],
    $(pub fn $fn_name:ident ($($param_name:ident : $param_type:ty),*) -> $ret_type:ty,)*
    variadic:
    $(pub fn $vfn_name:ident ($($vparam_name: ident : $vparam_type:ty),+) -> $vret_type:ty,)*
    globals:
    $(pub static $var_name:ident : $var_type:ty,)*
  } => {
    pub struct $struct_name {
      #[allow(dead_code)]
      lib: ::dylib::DynamicLibrary,
      $(pub $fn_name: unsafe extern "C" fn ($($param_type),*) -> $ret_type,)*
      $(pub $vfn_name: unsafe extern "C" fn ($($vparam_type),+, ...) -> $vret_type,)*
      $(pub $var_name: *mut $var_type,)*
    }
    impl $struct_name {
      pub fn open () -> Result<$struct_name, ::x11_dl::error::OpenError> {
        unsafe {
          let lib = try!(::link::open_lib(&[$($lib_name),*]));
          $(let $fn_name = try!(::link::get_sym(&lib, stringify!($fn_name)));)*
          $(let $vfn_name = try!(::link::get_sym(&lib, stringify!($vfn_name)));)*
          $(let $var_name = try!(::link::get_sym(&lib, stringify!($var_name)));)*
          return Ok($struct_name {
            lib: lib,
            $($fn_name: ::std::mem::transmute($fn_name),)*
            $($vfn_name: ::std::mem::transmute($vfn_name),)*
            $($var_name: $var_name as *mut $var_type,)*
          });
        }
      }
    }
  }
}
//
// public functions
//
pub fn get_sym (lib: &DynamicLibrary, name: &str) -> Result<*mut (), OpenError> {
  unsafe {
    match lib.symbol(name) {
      Ok(sym) => Ok(sym),
      Err(msg) => Err(OpenError::new(OpenErrorKind::Symbol, msg)),
    }
  }
}
pub fn open_lib (names: &[&'static str]) -> Result<DynamicLibrary, OpenError> {
  assert!(!names.is_empty());
  let mut msgs = Vec::new();
  for name in names.iter() {
    match DynamicLibrary::open(Some(Path::new(*name))) {
      Ok(lib) => { return Ok(lib); },
      Err(err) => { msgs.push(err); },
    }
  }
  let mut detail = String::new();
  for i in 0..msgs.len() {
    if i != 0 {
      detail.push_str(", ");
    }
    detail.push_str("\"");
    detail.push_str(msgs[i].as_ref());
    detail.push_str("\"");
  }
  return Err(OpenError::new(OpenErrorKind::Library, detail));
}

[package]
name = "elemeld"
version = "0.1.0"
authors = ["daxvena <kira.bruneau@gmail.com>"]
[dependencies]
mio = "*"
x11-dl = "*"
dylib = "*"