//! Implement a concrete type to build channels.

use std::io;

use std::net::SocketAddr;

use std::sync::{Arc, Mutex};

use crate::{event::ChanMgrEventSender, Error};

use std::time::Duration;

use tor_error::{bad_api_usage, internal};

use tor_linkspec::{ChanTarget, OwnedChanTarget};

use tor_llcrypto::pk;

use tor_rtcompat::{tls::TlsConnector, Runtime, TcpProvider, TlsProvider};

use async_trait::async_trait;

use futures::stream::FuturesUnordered;

use futures::task::SpawnExt;

use futures::StreamExt;

use futures::{FutureExt, TryFutureExt};

/// Time to wait between starting parallel connections to the same relay.

static CONNECTION_DELAY: Duration = Duration::from_millis(150);

/// TLS-based channel builder.

///

/// This is a separate type so that we can keep our channel management

/// code network-agnostic.

pub(crate) struct ChanBuilder<R: Runtime> {

    /// Asynchronous runtime for TLS, TCP, spawning, and timeouts.

    runtime: R,

    /// Used to update our bootstrap reporting status.

    event_sender: Mutex<ChanMgrEventSender>,

    /// Object to build TLS connections.

    tls_connector: <R as TlsProvider<R::TcpStream>>::Connector,

}

impl<R: Runtime> ChanBuilder<R> {

    /// Construct a new ChanBuilder.

}

#[async_trait]

impl<R: Runtime> crate::mgr::ChannelFactory for ChanBuilder<R> {

    type Channel = tor_proto::channel::Channel;

    type BuildSpec = OwnedChanTarget;

        use tor_rtcompat::SleepProviderExt;

        // TODO: make this an option.  And make a better value.

}

/// Connect to one of the addresses in `addrs` by running connections in parallel until one works.

///

/// This implements a basic version of RFC 8305 "happy eyeballs".

            }

                // We got a failure on one of the streams. Store the error.

                // TODO(eta): ideally we'd start the next connection attempt immediately.

            }

        }

    }

    // Ensure we don't continue trying to make connections.

impl<R: Runtime> ChanBuilder<R> {

    /// As build_channel, but don't include a timeout.

        // TODO: add a random hostname here if it will be used for SNI?

}

impl crate::mgr::AbstractChannel for tor_proto::channel::Channel {

    type Ident = pk::ed25519::Ed25519Identity;

}

#[cfg(test)]

mod test {

    #![allow(clippy::unwrap_used)]

    use super::*;

    use crate::{

        mgr::{AbstractChannel, ChannelFactory},

        Result,

    };

    use pk::ed25519::Ed25519Identity;

    use pk::rsa::RsaIdentity;

    use std::net::SocketAddr;

    use std::time::{Duration, SystemTime};

    use tor_proto::channel::Channel;

    use tor_rtcompat::{test_with_one_runtime, TcpListener};

    use tor_rtmock::{io::LocalStream, net::MockNetwork, MockSleepRuntime};

    // Make sure that the builder can build a real channel.  To test

    // this out, we set up a listener that pretends to have the right

    // IP, fake the current time, and use a canned response from

    // [`testing::msgs`] crate.

    #[test]

    fn build_ok() -> Result<()> {

        use crate::testing::msgs;

        let orport: SocketAddr = msgs::ADDR.parse().unwrap();

        let ed: Ed25519Identity = msgs::ED_ID.into();

        let rsa: RsaIdentity = msgs::RSA_ID.into();

        let client_addr = "192.0.2.17".parse().unwrap();

        let tls_cert = msgs::X509_CERT.into();

        let target = OwnedChanTarget::new(vec![orport], ed, rsa);

        let now = SystemTime::UNIX_EPOCH + Duration::new(msgs::NOW, 0);

        test_with_one_runtime!(|rt| async move {

            // Stub out the internet so that this connection can work.

            let network = MockNetwork::new();

            // Set up a client runtime with a given IP

            let client_rt = network

                .builder()

                .add_address(client_addr)

                .runtime(rt.clone());

            // Mock the current time too

            let client_rt = MockSleepRuntime::new(client_rt);

            // Set up a relay runtime with a different IP

            let relay_rt = network

                .builder()

                .add_address(orport.ip())

                .runtime(rt.clone());

            // open a fake TLS listener and be ready to handle a request.

            let lis = relay_rt.mock_net().listen_tls(&orport, tls_cert).unwrap();

            // Tell the client to believe in a different timestamp.

            client_rt.jump_to(now);

            // Create the channelbuilder that we want to test.

            let (snd, _rcv) = crate::event::channel();

            let builder = ChanBuilder::new(client_rt, snd);

            let (r1, r2): (Result<Channel>, Result<LocalStream>) = futures::join!(

                async {

                    // client-side: build a channel!

                    builder.build_channel(&target).await

                },

                async {

                    // relay-side: accept the channel

                    // (and pretend to know what we're doing).

                    let (mut con, addr) = lis.accept().await.expect("accept failed");

                    assert_eq!(client_addr, addr.ip());

                    crate::testing::answer_channel_req(&mut con)

                        .await

                        .expect("answer failed");

                    Ok(con)

                }

            );

            let chan = r1.unwrap();

            assert_eq!(chan.ident(), &ed);

            assert!(chan.is_usable());

            r2.unwrap();

            Ok(())

        })

    }

    // TODO: Write tests for timeout logic, once there is smarter logic.

}