use super::*;

use tokio::net::{self, TcpListener};

pub struct TcpStream {
    stream:net::TcpStream,
}
impl Stream for TcpStream {
    type Socket = net::TcpStream;

    fn recv(&mut self, _buffer:&mut [u8]) -> Result<usize, ()> {
        Err(())
    }

    fn send(&mut self, _buffer:&mut [u8]) -> Result<(), ()> {
        Err(())
    }

    fn stream(&mut self) -> &mut Self::Socket {
        &mut self.stream
    }
}

pub struct TcpServer {
    listener:Option<net::TcpListener>,
}
impl TcpServer {
    pub fn new() -> Self
    {
        Self {
            listener:None,
        }
    }
}
impl Server for TcpServer {
    type Stream = TcpStream;

    async fn bind(&mut self, interface:&str) -> Result<(), ()>
    {
        match TcpListener::bind(interface).await {
            Ok(listener) => {
                self.listener = Some(listener);
                Ok(())
            }
            Err(_) => Err(())
        }
    }

    async fn accept<F, Fut, Args>(&self, callback:F, args:Args) -> Result<JoinHandle<Result<(),()>>,()>
        where
            F: Fn(Self::Stream, SocketAddr, Args) -> Fut + Send + Sync + 'static,
            Fut: std::future::Future<Output = Result<(),()>> + Send + 'static,
            Args: Send + 'static
    {
        match &self.listener {
            Some(listener) => {
                match listener.accept().await {
                    Ok((stream, addr)) => {
                        Ok(tokio::spawn(async move {
                            callback(Self::Stream { stream:stream }, addr, args).await
                        }))
                    }
                    Err(_) => Err(())
                }
            }
            None => Err(())
        }
    }

    fn close(&mut self) {
        self.listener = None;
    }
}