//! Module providing [`CircuitExtender`].

use super::{Circuit, ReactorResultChannel};

use crate::circuit::circhop::HopSettings;

use crate::client::circuit::handshake::HandshakeRole;

use crate::client::reactor::MetaCellDisposition;

use crate::crypto::cell::HopNum;

use crate::crypto::handshake::fast::CreateFastClient;

use crate::crypto::handshake::ntor_v3::NtorV3Client;

use crate::tunnel::TunnelScopedCircId;

use crate::{Error, Result};

use crate::{HopLocation, congestion};

use oneshot_fused_workaround as oneshot;

use std::borrow::Borrow;

use tor_cell::chancell::msg::HandshakeType;

use tor_cell::relaycell::msg::{Extend2, Extended2};

use tor_cell::relaycell::{AnyRelayMsgOuter, UnparsedRelayMsg};

use tor_error::internal;

use crate::circuit::circhop::SendRelayCell;

use crate::client::circuit::path;

use crate::client::reactor::MetaCellHandler;

use crate::crypto::handshake::ntor::NtorClient;

use crate::crypto::handshake::{ClientHandshake, KeyGenerator};

use tor_cell::relaycell::extend::CircResponseExt;

use tor_linkspec::{EncodedLinkSpec, OwnedChanTarget};

use tracing::trace;

/// An object that can extend a circuit by one hop, using the `MetaCellHandler` trait.

///

/// Yes, I know having trait bounds on structs is bad, but in this case it's necessary

/// since we want to be able to use `H::KeyType`.

pub(crate) struct CircuitExtender<H>

where

    H: ClientHandshake,

{

    /// The peer that we're extending to.

    ///

    /// Used to extend our record of the circuit's path.

    peer_id: OwnedChanTarget,

    /// Handshake state.

    state: Option<H::StateType>,

    /// In-progress settings that we're negotiating for this hop.

    settings: HopSettings,

    /// An identifier for logging about this reactor's circuit.

    unique_id: TunnelScopedCircId,

    /// The hop we're expecting the EXTENDED2 cell to come back from.

    expected_hop: HopNum,

    /// A oneshot channel that we should inform when we are done with this extend operation.

    operation_finished: Option<oneshot::Sender<Result<()>>>,

}

impl<H> CircuitExtender<H>

where

    H: ClientHandshake + HandshakeAuxDataHandler,

    H::KeyGen: KeyGenerator,

{

    /// Start extending a circuit, sending the necessary EXTEND cell and returning a

    /// new `CircuitExtender` to be called when the reply arrives.

    ///

    /// The `handshake_id` is the numeric identifier for what kind of

    /// handshake we're doing.  The `key` is the relay's onion key that

    /// goes along with the handshake, and the `linkspecs` are the

    /// link specifiers to include in the EXTEND cell to tell the

    /// current last hop which relay to connect to.

    #[allow(clippy::too_many_arguments)]

    #[allow(clippy::blocks_in_conditions)]

                circ_id = %unique_id,

                linkspecs = ?linkspecs,

            );

            // Prepare a message to send message to the last hop...

            // ... and now we wait for a response.

        })() {

            }

                // It's okay if the receiver went away.

            }

        }

    /// Perform the work of extending the circuit another hop.

    ///

    /// This is a separate function to simplify the error-handling work of handle_msg().

            circ_id = %self.unique_id,

        );

        // Now perform the second part of the handshake, and see if it

        // succeeded.

        // Handle auxiliary data returned from the server, e.g. validating that

        // requested extensions have been acknowledged.

        // If we get here, it succeeded.  Add a new hop to the circuit.

}

impl<H> MetaCellHandler for CircuitExtender<H>

where

    H: ClientHandshake + HandshakeAuxDataHandler,

    H::StateType: Send,

    H::KeyGen: KeyGenerator,

{

            // ignore it if the receiving channel went away.

        } else {

        }

}

/// Specifies handling of auxiliary handshake data for a given `ClientHandshake`.

//

// For simplicity we implement this as a trait of the handshake object itself.

// This is currently sufficient because

//

// 1. We only need or want one handler implementation for a given handshake type.

// 2. We currently don't need to keep extra state; i.e. its method doesn't take

//    &self.

//

// If we end up wanting to instantiate objects for one or both of the

// `ClientHandshake` object or the `HandshakeAuxDataHandler` object, we could

// decouple them by making this something like:

//

// ```

// trait HandshakeAuxDataHandler<H> where H: ClientHandshake

// ```

pub(crate) trait HandshakeAuxDataHandler: ClientHandshake {

    /// Handle auxiliary handshake data returned when creating or extending a

    /// circuit.

    fn handle_server_aux_data(

        settings: &mut HopSettings,

        data: &<Self as ClientHandshake>::ServerAuxData,

    ) -> Result<()>;

}

impl HandshakeAuxDataHandler for NtorV3Client {

        // Process all extensions.

        // If "flowctl-cc" is not enabled, this loop will always return an error, so tell clippy

        // that it's okay.

        #[cfg_attr(not(feature = "flowctl-cc"), allow(clippy::never_loop))]

                    cfg_if::cfg_if! {

                        if #[cfg(feature = "flowctl-cc")] {

                            // Unexpected ACK extension as in if CC is disabled on our side, we would never have

                            // requested it. Reject and circuit must be closed.

                            // Invalid increment, reject and circuit must be closed.

                            // Excellent, we have a negotiated sendme increment. Set it for this circuit.

                        } else {

                            let _ = ack_ext;

                            return Err(Error::HandshakeProto(

                                "Received unexpected `AckCongestionControl` ntorv3 extension".into(),

                            ));

                        }

                    }

                }

                // Any other extensions is not expected. Reject and circuit must be closed.

                _ => {

                }

            }

        }

}

impl HandshakeAuxDataHandler for NtorClient {

        // This handshake doesn't have any auxiliary data; nothing to do.

}

impl HandshakeAuxDataHandler for CreateFastClient {

        // This handshake doesn't have any auxiliary data; nothing to do.

}