libc = { version = "^0.2", optional = true } # raw sockets

mio = { version = "0.8", features = ["os-poll"] } # cross-platform IO notification queue

mod poll;

use libc::{self, c_int};

use std::{io, ptr, time};

pub(crate) type FileDescriptor = c_int;

pub(crate) trait AsFileDescriptor {

    fn as_file_descriptor(&self) -> FileDescriptor;

}

pub(crate) struct UserData(u64);

#[inline]

pub(crate) fn register_polling<F: AsFileDescriptor>(

    poller: &Poller, entity: F, user: UserData, read: bool, write: bool

) -> io::Result<()> {

    let file_descriptor = entity.as_file_descriptor();

    return poller.register(file_descriptor, user, read, write);

}

#[inline]

pub(crate) fn unregister_polling<F: AsFileDescriptor>(

    poller: &Poller, entity: F

) -> io::Result<()> {

    let file_descriptor = entity.as_file_descriptor();

    return poller.unregister(file_descriptor);

}

#[cfg(unix)]

pub(crate) struct Poller {

    handle: c_int,

    events: Vec<libc::epoll_event>

}

// All of this is gleaned from the `mio` crate.

#[cfg(unix)]

impl Poller {

    pub fn new(event_capacity: usize) -> io::Result<Self> {

        assert!(event_capacity < i32::MAX as usize); // because of argument to `epoll_wait`.

        let handle = syscall_result(unsafe{ libc::epoll_create1(libc::EPOLL_CLOEXEC) })?;

        return Ok(Self{

            handle,

            events: Vec::with_capacity(event_capacity),

        })

    }

    fn register(&self, fd: FileDescriptor, user: UserData, read: bool, write: bool) -> io::Result<()> {

        let mut event = libc::epoll_event{

            events: Self::events_from_rw_flags(read, write),

            u64: user.0,

        };

        syscall_result(unsafe{

            libc::epoll_ctl(self.handle, libc::EPOLL_CTL_ADD, fd, &mut event)

        })?;

        return Ok(());

    }

    fn unregister(&self, fd: FileDescriptor) -> io::Result<()> {

        syscall_result(unsafe{

            libc::epoll_ctl(self.handle, libc::EPOLL_CTL_DEL, fd, ptr::null_mut())

        })?;

        return Ok(());

    }

    pub fn wait(&mut self, timeout: time::Duration) -> io::Result<()> {

        // See `mio` for the reason. Works around a linux bug

        #[cfg(target_pointer_width = "32")]

        const MAX_TIMEOUT: u128 = 1789569;

        #[cfg(not(target_pointer_width = "32"))]

        const MAX_TIMEOUT: u128 = c_int::MAX as u128;

        let mut timeout_millis = timeout.as_millis();

        if timeout_millis > MAX_TIMEOUT {

            timeout_millis = -1; // effectively infinite

        }

        let num_events = syscall_result(unsafe{

            libc::epoll_wait(self.handle, self.events.as_mut(), self.events.capacity() as i32, timeout_millis)

        })?;

        unsafe{

            debug_assert!(num_events >= 0);

            self.events.set_len(num_events as usize);

        }

        return Ok(());

    }

    fn events_from_rw_flags(read: bool, write: bool) -> u32 {

        let mut events = libc::EPOLLET;

        if read {

            events |= libc::EPOLLIN | libc::EPOLLRDHUP;

        }

        if write {

            events |= libc::EPOLLOUT;

        }

        return events as u32;

    }

}

#[inline]

fn syscall_result(result: c_int) -> io::Result<c_int> {

    if result < 0 {

        return Err(io::Error::last_os_error());

    } else {

        return Ok(result);

    }

}

#[cfg(not(unix))]

struct Poller {

}

use mio::{event, Interest, Registry, Token};

// The following is essentially stolen from `mio`'s io_source.rs file.

#[cfg(unix)]

trait AsRawFileDescriptor {

    fn as_raw_file_descriptor(&self) -> c_int;

}

impl AsRawFileDescriptor for SocketTcpClient {

    fn as_raw_file_descriptor(&self) -> c_int {

        return self.socket_handle;

    }

}

impl<T: AsRawFileDescriptor> event::Source for T {

    fn register(&mut self, registry: &Registry, token: Token, interests: Interest) -> std::io::Result<()> {

        registry.selector().register()

    }

    fn reregister(&mut self, registry: &Registry, token: Token, interests: Interest) -> std::io::Result<()> {

        todo!()

    }

    fn deregister(&mut self, registry: &Registry) -> std::io::Result<()> {

        todo!()

    }

}