use futures_io::{AsyncRead, AsyncWrite};
use std::{
    future::Future,
    pin::Pin,
    task::{Context, Poll},
};
use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};

pub fn resolver(
    config: ResolverConfig,
    options: ResolverOpts,
) -> Result<JiveResolver, trust_dns_resolver::error::ResolveError> {
    JiveResolver::new(config, options, JiveRuntimeHandle)
}

pub fn resolver_from_system_conf() -> Result<JiveResolver, trust_dns_resolver::error::ResolveError>
{
    JiveResolver::from_system_conf(JiveRuntimeHandle)
}

#[derive(Clone)]
pub struct JiveRuntime;

pub struct JiveTcpStream {
    pub(crate) io: jive::io::Async<jive::net::TcpStream>,
}

pub struct JiveUdpSocket {
    io: jive::io::Async<jive::net::UdpSocket>,
}

pub type JiveResolver = trust_dns_resolver::AsyncResolver<JiveConnection, JiveConnectionProvider>;

pub type JiveConnection = trust_dns_resolver::name_server::GenericConnection;
pub type JiveConnectionProvider =
    trust_dns_resolver::name_server::GenericConnectionProvider<JiveRuntime>;

#[derive(Clone, Copy)]
pub struct JiveRuntimeHandle;

pub struct JiveTimer;

impl JiveTcpStream {
    pub fn into_inner(self) -> jive::io::Async<jive::net::TcpStream> {
        self.io
    }

    pub fn from_inner(io: jive::io::Async<jive::net::TcpStream>) -> Self {
        JiveTcpStream { io }
    }
}

impl trust_dns_resolver::name_server::RuntimeProvider for JiveRuntime {
    type Handle = JiveRuntimeHandle;
    type Tcp = JiveTcpStream;
    type Timer = JiveTimer;
    type Udp = JiveUdpSocket;
}

impl trust_dns_resolver::name_server::Spawn for JiveRuntimeHandle {
    fn spawn_bg<F>(&mut self, future: F)
    where
        F: Future<Output = Result<(), trust_dns_proto::error::ProtoError>> + Send + 'static,
    {
        let _join = jive::spawn(future);
    }
}

#[async_trait::async_trait]
impl trust_dns_proto::tcp::Connect for JiveTcpStream {
    async fn connect_with_bind(
        addr: std::net::SocketAddr,
        bind_addr: Option<std::net::SocketAddr>,
    ) -> std::io::Result<Self> {
        if let Some(_bind_addr) = bind_addr {
            todo!("Implement connect with bind");
        } else {
            let io = jive::io::Async::<jive::net::TcpStream>::connect(addr).await?;

            Ok(JiveTcpStream { io })
        }
    }
}

impl trust_dns_proto::tcp::DnsTcpStream for JiveTcpStream {
    type Time = JiveTimer;
}

impl AsyncRead for JiveTcpStream {
    fn poll_read(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        buf: &mut [u8],
    ) -> Poll<std::io::Result<usize>> {
        Pin::new(&mut self.get_mut().io).poll_read(cx, buf)
    }
}

impl AsyncWrite for JiveTcpStream {
    fn poll_write(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        buf: &[u8],
    ) -> Poll<std::io::Result<usize>> {
        Pin::new(&mut self.get_mut().io).poll_write(cx, buf)
    }

    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
        Pin::new(&mut self.get_mut().io).poll_flush(cx)
    }

    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
        Pin::new(&mut self.get_mut().io).poll_close(cx)
    }
}

#[async_trait::async_trait]
impl trust_dns_proto::udp::UdpSocket for JiveUdpSocket {
    type Time = JiveTimer;

    async fn bind(addr: std::net::SocketAddr) -> std::io::Result<Self> {
        let io = jive::io::Async::<jive::net::UdpSocket>::bind(addr).await?;

        Ok(JiveUdpSocket { io })
    }

    fn poll_send_to(
        &self,
        cx: &mut Context<'_>,
        buf: &[u8],
        target: std::net::SocketAddr,
    ) -> Poll<std::io::Result<usize>> {
        self.io.poll_send_to(cx, buf, target)
    }

    fn poll_recv_from(
        &self,
        cx: &mut Context<'_>,
        buf: &mut [u8],
    ) -> Poll<std::io::Result<(usize, std::net::SocketAddr)>> {
        self.io.poll_recv_from(cx, buf)
    }
}

#[async_trait::async_trait]
impl trust_dns_proto::Time for JiveTimer {
    async fn delay_for(duration: std::time::Duration) {
        jive::time::sleep(duration).await
    }

    async fn timeout<F: 'static + Future + Send>(
        duration: std::time::Duration,
        future: F,
    ) -> Result<F::Output, std::io::Error> {
        jive::time::timeout(duration, Box::pin(future)).await
    }
}

impl trust_dns_proto::Executor for JiveRuntime {
    fn new() -> Self {
        Self
    }

    fn block_on<F: Future>(&mut self, future: F) -> F::Output {
        jive::block_on(future)
    }
}