//! Implement traits from [`crate::mgr`] for the circuit types we use.

use crate::build::TunnelBuilder;

use crate::mgr::{self, MockablePlan};

use crate::path::OwnedPath;

use crate::usage::{SupportedTunnelUsage, TargetTunnelUsage};

use crate::{DirInfo, Error, PathConfig, Result, timeouts};

use async_trait::async_trait;

use educe::Educe;

use futures::future::OptionFuture;

use std::sync::Arc;

use tor_basic_utils::skip_fmt;

use tor_error::{bad_api_usage, internal};

#[cfg(feature = "vanguards")]

use tor_guardmgr::vanguards::VanguardMgr;

use tor_linkspec::CircTarget;

use tor_proto::ClientTunnel;

use tor_proto::circuit::UniqId;

use tor_proto::client::circuit::{CircParameters, Path};

use tor_rtcompat::Runtime;

use tracing::instrument;

use web_time_compat::Instant;

#[async_trait]

impl mgr::AbstractTunnel for tor_proto::ClientTunnel {

    type Id = tor_proto::circuit::UniqId;

    // TODO: replace Itertools::exactly_one() with a stdlib equivalent when there is one.

    //

    // See issue #48919 <https://github.com/rust-lang/rust/issues/48919>

    #[allow(unstable_name_collisions)]

        use itertools::Itertools as _;

    async fn extend<T: CircTarget + Sync>(

        &self,

        target: &T,

        params: CircParameters,

        let circ = self.as_single_circ()?;

        circ.extend(target, params).await

        self.disused_since().await

}

/// The information generated by circuit planning, and used to build a

/// circuit.

#[derive(Educe)]

#[educe(Debug)]

pub(crate) struct Plan {

    /// The supported usage that the circuit will have when complete

    final_spec: SupportedTunnelUsage,

    /// An owned copy of the path to build.

    // TODO: it would be nice if this weren't owned.

    path: OwnedPath,

    /// The protocol parameters to use when constructing the circuit.

    params: CircParameters,

    /// If this path is using a guard, we'll use this object to report

    /// whether the circuit succeeded or failed.

    guard_status: Option<tor_guardmgr::GuardMonitor>,

    /// If this path is using a guard, we'll use this object to learn

    /// whether we're allowed to use the circuit or whether we have to

    /// wait a while.

    #[educe(Debug(method = "skip_fmt"))]

    guard_usable: Option<tor_guardmgr::GuardUsable>,

}

impl MockablePlan for Plan {}

#[async_trait]

impl<R: Runtime> crate::mgr::AbstractTunnelBuilder<R> for crate::build::TunnelBuilder<R> {

    type Tunnel = ClientTunnel;

    type Plan = Plan;

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

            #[cfg(all(feature = "vanguards", feature = "hs-common"))]

        };

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

    async fn build_tunnel(&self, plan: Plan) -> Result<(SupportedTunnelUsage, Self::Tunnel)> {

        use crate::build::GuardStatusHandle;

        use tor_guardmgr::GuardStatus;

        let Plan {

            final_spec,

            path,

            params,

            guard_status,

            guard_usable,

        } = plan;

        let guard_usable: OptionFuture<_> = guard_usable.into();

        let guard_status: Arc<GuardStatusHandle> = Arc::new(guard_status.into());

        guard_status.pending(GuardStatus::AttemptAbandoned);

        // TODO: We may want to lower the logic for handling

        // guard_status and guard_usable into build.rs, so that they

        // can be handled correctly on user-selected paths as well.

        //

        // This will probably require a different API for circuit

        // construction.

        match self

            .build_owned(

                path,

                &params,

                Arc::clone(&guard_status),

                final_spec.channel_usage(),

            )

            .await

        {

            Ok(tunnel) => {

                // Report success to the guard manager, so it knows that

                // this guard is reachable.

                guard_status.report(GuardStatus::Success);

                // We have to wait for the guard manager to tell us whether

                // this guard is actually _usable_ or not.  Possibly,

                // it is a speculative guard that we're only trying out

                // in case some preferable guard won't meet our needs.

                match guard_usable.await {

                    Some(Ok(true)) | None => (),

                    Some(Ok(false)) => return Err(Error::GuardNotUsable(tunnel.unique_id())),

                    Some(Err(_)) => {

                        return Err(internal!("Guard usability status cancelled").into());

                    }

                }

                Ok((final_spec, tunnel))

            }

            Err(e) => {

                // The attempt failed; the builder should have set the

                // pending status on the guard to some value which will

                // tell the guard manager whether to blame the guard or not.

                guard_status.commit();

                Err(e)

            }

        }

    }

        }

    #[cfg(feature = "vanguards")]

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

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

}