//! Configuration logic for tor-ptmgr.

use std::net::SocketAddr;

use derive_builder::Builder;

use serde::{Deserialize, Serialize};

use tor_config::{impl_standard_builder, ConfigBuildError};

use tor_config_path::CfgPath;

use tor_linkspec::PtTransportName;

#[cfg(feature = "tor-channel-factory")]

use {crate::PtClientMethod, tor_socksproto::SocksVersion};

/// A single pluggable transport.

///

/// Pluggable transports are programs that transform and obfuscate traffic on

/// the network between a Tor client and a Tor bridge, so that an adversary

/// cannot recognize it as Tor traffic.

///

/// A pluggable transport can be either _managed_ (run as an external process

/// that we launch and monitor), or _unmanaged_ (running on a local port, not

/// controlled by Arti).

#[builder(derive(Debug, Serialize, Deserialize))]

#[builder(build_fn(error = "ConfigBuildError", validate = "Self::validate"))]

pub struct TransportConfig {

    /// Names of the transport protocols that we are willing to use from this transport.

    ///

    /// (These protocols are arbitrary identifiers that describe which protocols

    /// we want. They must match names that the binary knows how to provide.)

    //

    // NOTE(eta): This doesn't use the list builder stuff, because you're not likely to

    //            set this field more than once.

    pub(crate) protocols: Vec<PtTransportName>,

    /// The path to the binary to run, if any.

    ///

    /// This needs to be the path to some executable file on disk.

    ///

    /// Present only for managed transports.

    #[builder(default, setter(strip_option))]

    pub(crate) path: Option<CfgPath>,

    /// One or more command-line arguments to pass to the binary.

    ///

    /// Meaningful only for managed transports.

    // TODO: Should this be OsString? That's a pain to parse...

    //

    // NOTE(eta): This doesn't use the list builder stuff, because you're not likely to

    //            set this field more than once.

    #[builder(default)]

    pub(crate) arguments: Vec<String>,

    /// The location at which to contact this transport.

    ///

    /// Present only for unmanaged transports.

    #[builder(default, setter(strip_option))]

    pub(crate) proxy_addr: Option<SocketAddr>,

    /// If true, launch this transport on startup.  Otherwise, we launch

    /// it on demand.

    ///

    /// Meaningful only for managed transports.

    #[builder(default)]

    pub(crate) run_on_startup: bool,

}

impl_standard_builder! { TransportConfig: !Default }

impl TransportConfigBuilder {

    /// Inspect the list of protocols (ie, transport names)

    ///

    /// If none have yet been specified, returns an empty list.

    /// Make sure that this builder is internally consistent.

            // TODO: There is no ConfigBuildError for "one of two fields is missing."

            (None, Some(_)) => {

                } else {

                }

            }

        }

}

/// The pluggable transport structure used internally. This is more type-safe than working with

/// `TransportConfig` directly, since we can't change `TransportConfig` as it's part of the public

/// API.

#[derive(Clone, Debug, Eq, PartialEq)]

pub(crate) enum TransportOptions {

    /// Options for a managed PT transport.

    #[cfg(feature = "managed-pts")]

    Managed(ManagedTransportOptions),

    /// Options for an unmanaged PT transport.

    Unmanaged(UnmanagedTransportOptions),

}

impl TryFrom<TransportConfig> for TransportOptions {

    type Error = tor_error::Bug;

        // We rely on the validation performed in `TransportConfigBuilder::validate` to ensure that

        // mutually exclusive options were not set. We could do validation again here, but it would

        // be error-prone to duplicate the validation logic. We also couldn't check things like if

        // `run_on_startup` was `Some`/`None`, since that's only available to the builder.

            cfg_if::cfg_if! {

                if #[cfg(feature = "managed-pts")] {

                } else {

                    let _ = path;

                    Err(tor_error::internal!(

                        "Path is set but 'managed-pts' feature is not enabled. How did this pass builder validation?"

                    ))

                }

            }

        } else {

        }

}

/// A pluggable transport that is run as an external process that we launch and monitor.

#[cfg(feature = "managed-pts")]

#[derive(Clone, Debug, Eq, PartialEq)]

pub(crate) struct ManagedTransportOptions {

    /// See [TransportConfig::protocols].

    pub(crate) protocols: Vec<PtTransportName>,

    /// See [TransportConfig::path].

    pub(crate) path: CfgPath,

    /// See [TransportConfig::arguments].

    pub(crate) arguments: Vec<String>,

    /// See [TransportConfig::run_on_startup].

    pub(crate) run_on_startup: bool,

}

/// A pluggable transport running on a local port, not controlled by Arti.

#[derive(Clone, Debug, Eq, PartialEq)]

pub(crate) struct UnmanagedTransportOptions {

    /// See [TransportConfig::protocols].

    pub(crate) protocols: Vec<PtTransportName>,

    /// See [TransportConfig::proxy_addr].

    pub(crate) proxy_addr: SocketAddr,

}

impl UnmanagedTransportOptions {

    /// A client method that can be used to contact this transport.

    #[cfg(feature = "tor-channel-factory")]

    /// Return true if this transport is configured on localhost.

}