use std::io;

use tokio::io::unix::AsyncFd;
use tracing::instrument;

#[derive(Debug)]
pub struct TunInterface {
    inner: AsyncFd<crate::TunInterface>,
}

impl TunInterface {
    #[instrument]
    pub fn new(tun: crate::TunInterface) -> io::Result<Self> {
        Ok(Self {
            inner: AsyncFd::new(tun)?,
        })
    }

    #[instrument]
    pub async fn send(&self, buf: &[u8]) -> io::Result<usize> {
        loop {
            let mut guard = self.inner.writable().await?;
            match guard.try_io(|inner| inner.get_ref().send(buf)) {
                Ok(result) => return result,
                Err(_would_block) => continue,
            }
        }
    }

    // #[instrument]
    pub async fn recv(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        loop {
            log::debug!("TunInterface receiving...");
            let mut guard = self.inner.readable_mut().await?;
            log::debug!("Got! readable_mut");
            match guard.try_io(|inner| {
                // log::debug!("Got! {:#?}", inner);
                let raw_ref = (*inner).get_mut();
                // log::debug!("Got mut ref! {:#?}", raw_ref);
                let recved = raw_ref.recv(buf);
                // log::debug!("Got recved! {:#?}", recved);
                recved
            }) {
                Ok(result) => {
                    log::debug!("HORRAY");
                    return result
                },
                Err(_would_block) => {
                    log::debug!("WouldBlock");
                    continue
                },
            }
        }
    }

    #[instrument]
    pub async fn try_recv(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        let mut guard = self.inner.readable_mut().await?;
        match guard.try_io(|inner| (*inner).get_mut().recv(buf)) {
            Ok(result) => Ok(result.unwrap_or_default()),
            Err(_would_block) => Err(io::Error::new(io::ErrorKind::WouldBlock, "WouldBlock")),
        }
    }
}