//! Re-exports of the smol runtime for use with arti.

//! This crate defines a slim API around our async runtime so that we

//! can swap it out easily.

/// Types used for networking (smol implementation).

pub(crate) mod net {

    use super::SmolRuntime;

    use crate::network::{TcpConnectOptions, TcpListenOptions};

    #[cfg(unix)]

    use crate::network::{UnixConnectOptions, UnixListenOptions};

    use crate::{impls, traits};

    use async_trait::async_trait;

    use futures::stream::{self, Stream};

    use paste::paste;

    use smol::Async;

    #[cfg(unix)]

    use smol::net::unix::{UnixListener, UnixStream};

    use smol::net::{TcpListener, TcpStream, UdpSocket as SmolUdpSocket};

    use std::io::Result as IoResult;

    use std::net::SocketAddr;

    use std::pin::Pin;

    use std::task::{Context, Poll};

    use tor_general_addr::unix;

    use tracing::instrument;

    /// Provide wrapper for different stream types

    /// (e.g async_net::TcpStream and async_net::unix::UnixStream).

    macro_rules! impl_stream {

        { $kind:ident, $addr:ty } => { paste! {

            /// A `Stream` of incoming streams.

            pub struct [<Incoming $kind Streams>] {

                /// Underlying stream of incoming connections.

                inner: Pin<Box<dyn Stream<Item = IoResult<([<$kind Stream>], $addr)>> + Send + Sync>>,

            }

            impl [<Incoming $kind Streams>] {

                /// Create a new `Incoming*Streams` from a listener.

            }

            impl Stream for [<Incoming $kind Streams>] {

                type Item = IoResult<([<$kind Stream>], $addr)>;

            }

            impl traits::NetStreamListener<$addr> for [<$kind Listener>] {

                type Stream = [<$kind Stream>];

                type Incoming = [<Incoming $kind Streams>];

            }

        }}

    }

    impl_stream! { Tcp, SocketAddr }

    #[cfg(unix)]

    impl_stream! { Unix, unix::SocketAddr }

    #[async_trait]

    impl traits::NetStreamProvider<SocketAddr> for SmolRuntime {

        type Stream = TcpStream;

        type Listener = TcpListener;

        type ConnectOptions = TcpConnectOptions;

        type ListenOptions = TcpListenOptions;

        #[instrument(skip_all, level = "trace")]

        async fn connect(

            &self,

            addr: &SocketAddr,

            options: &Self::ConnectOptions,

        ) -> IoResult<Self::Stream> {

            // The smol runtime uses async-io internally.

            let stream = impls::tcp_async_io_connect(addr, options).await?;

            // The socket is already non-blocking,

            // so `Async` doesn't need to set as non-blocking again.

            Ok(Async::new_nonblocking(stream)?.into())

        }

        async fn listen(

            &self,

            addr: &SocketAddr,

            options: &Self::ListenOptions,

            // Use an implementation that's the same across all runtimes.

            // The socket is already non-blocking, so `Async` doesn't need to set as non-blocking

            // again. If it *were* to be blocking, then I/O operations would block in async

            // contexts, which would lead to deadlocks.

            Ok(Async::new_nonblocking(impls::tcp_listen(addr, options)?)?.into())

    }

    #[cfg(unix)]

    #[async_trait]

    impl traits::NetStreamProvider<unix::SocketAddr> for SmolRuntime {

        type Stream = UnixStream;

        type Listener = UnixListener;

        type ConnectOptions = UnixConnectOptions;

        type ListenOptions = UnixListenOptions;

        #[instrument(skip_all, level = "trace")]

        async fn connect(

            &self,

            addr: &unix::SocketAddr,

            options: &Self::ConnectOptions,

        ) -> IoResult<Self::Stream> {

            // Will fail to compile if we add options without handling them here.

            let UnixConnectOptions {} = options;

            let path = addr

                .as_pathname()

                .ok_or(crate::unix::UnsupportedAfUnixAddressType)?;

            UnixStream::connect(path).await

        }

        async fn listen(

            &self,

            addr: &unix::SocketAddr,

            options: &Self::ListenOptions,

            // Will fail to compile if we add options without handling them here.

            let path = addr

                .as_pathname()

                .ok_or(crate::unix::UnsupportedAfUnixAddressType)?;

            UnixListener::bind(path)

    }

    #[cfg(not(unix))]

    crate::impls::impl_unix_non_provider! { SmolRuntime }

    #[async_trait]

    impl traits::UdpProvider for SmolRuntime {

        type UdpSocket = UdpSocket;

            SmolUdpSocket::bind(addr)

                .await

    }

    /// Wrapper for `SmolUdpSocket`.

    // Required to implement `traits::UdpSocket`.

    pub struct UdpSocket {

        /// The underlying socket.

        socket: SmolUdpSocket,

    }

    #[async_trait]

    impl traits::UdpSocket for UdpSocket {

            self.socket.recv_from(buf).await

            self.socket.send_to(buf, target).await

    }

    impl traits::StreamOps for TcpStream {

        #[cfg(target_os = "linux")]

    }

    #[cfg(unix)]

    impl traits::StreamOps for UnixStream {

    }

}

// ==============================

use crate::traits::*;

use futures::task::{FutureObj, Spawn, SpawnError};

use futures::{Future, FutureExt};

use std::pin::Pin;

use std::time::Duration;

/// Type to wrap `smol::Executor`.

#[derive(Clone)]

pub struct SmolRuntime {

    /// Instance of the smol executor we own.

    executor: std::sync::Arc<smol::Executor<'static>>,

}

/// Construct new instance of the smol runtime.

//

// TODO: Make SmolRuntime multi-threaded.

impl SleepProvider for SmolRuntime {

    type SleepFuture = Pin<Box<dyn Future<Output = ()> + Send + 'static>>;

}

impl ToplevelBlockOn for SmolRuntime {

}

impl Blocking for SmolRuntime {

    type ThreadHandle<T: Send + 'static> = blocking::Task<T>;

    {

}

impl Spawn for SmolRuntime {

}