//! Types for managing directory configuration.

//!

//! Directory configuration tells us where to load and store directory

//! information, where to fetch it from, and how to validate it.

//!

//! # Semver note

//!

//! The types in this module are re-exported from `arti-client`: any changes

//! here must be reflected in the version of `arti-client`.

use crate::retry::DownloadSchedule;

use crate::storage::DynStore;

use crate::{Authority, Result};

use tor_config::ConfigBuildError;

use tor_netdir::fallback::FallbackDir;

use tor_netdoc::doc::netstatus;

use derive_builder::Builder;

use std::path::PathBuf;

use serde::Deserialize;

/// Configuration information about the Tor network itself; used as

/// part of Arti's configuration.

///

/// This type is immutable once constructed. To make one, use

/// [`NetworkConfigBuilder`], or deserialize it from a string.

#[serde(deny_unknown_fields)]

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

pub struct NetworkConfig {

    /// List of locations to look in when downloading directory information, if

    /// we don't actually have a directory yet.

    ///

    /// (If we do have a cached directory, we use directory caches listed there

    /// instead.)

    ///

    /// This section can be changed in a running Arti client.  Doing so will

    /// affect future download attempts only.

    #[serde(default = "fallbacks::default_fallbacks")]

    #[builder(default = "fallbacks::default_fallbacks()")]

    fallback_caches: Vec<FallbackDir>,

    /// List of directory authorities which we expect to sign consensus

    /// documents.

    ///

    /// (If none are specified, we use a default list of authorities shipped

    /// with Arti.)

    ///

    /// This section cannot be changed in a running Arti client.

    #[serde(default = "crate::authority::default_authorities")]

    #[builder(default = "crate::authority::default_authorities()")]

    authorities: Vec<Authority>,

}

impl Default for NetworkConfig {

}

impl NetworkConfig {

    /// Return a new builder to construct a NetworkConfig.

    /// Return the configured directory authorities

    /// Return the configured fallback directories

}

impl NetworkConfigBuilder {

    /// Check that this builder will give a reasonable network.

}

/// Configuration information for how exactly we download documents from the

/// Tor directory caches.

///

/// This type is immutable once constructed. To make one, use

/// [`DownloadScheduleConfigBuilder`], or deserialize it from a string.

#[serde(deny_unknown_fields)]

#[builder(build_fn(error = "ConfigBuildError"))]

pub struct DownloadScheduleConfig {

    /// Top-level configuration for how to retry our initial bootstrap attempt.

    #[serde(default = "default_retry_bootstrap")]

    #[builder(default = "default_retry_bootstrap()")]

    retry_bootstrap: DownloadSchedule,

    /// Configuration for how to retry a consensus download.

    #[serde(default)]

    #[builder(default)]

    retry_consensus: DownloadSchedule,

    /// Configuration for how to retry an authority cert download.

    #[serde(default)]

    #[builder(default)]

    retry_certs: DownloadSchedule,

    /// Configuration for how to retry a microdescriptor download.

    #[serde(default = "default_microdesc_schedule")]

    #[builder(default = "default_microdesc_schedule()")]

    retry_microdescs: DownloadSchedule,

}

/// Default value for retry_bootstrap in DownloadScheduleConfig.

/// Default value for microdesc_bootstrap in DownloadScheduleConfig.

impl Default for DownloadScheduleConfig {

}

impl DownloadScheduleConfig {

    /// Return a new builder to make a [`DownloadScheduleConfig`]

}

/// Configuration type for network directory operations.

///

/// This type is immutable once constructed.

///

/// To create an object of this type, use [`DirMgrConfigBuilder`], or

/// deserialize it from a string. (Arti generally uses Toml for configuration,

/// but you can use other formats if you prefer.)

///

/// Many members of this type can be replaced with a new configuration on a

/// running Arti client. Those that cannot are documented.

#[builder(build_fn(error = "ConfigBuildError"))]

pub struct DirMgrConfig {

    /// Location to use for storing and reading current-format

    /// directory information.

    ///

    /// Cannot be changed on a running Arti client.

    #[builder(setter(into))]

    cache_path: PathBuf,

    /// Configuration information about the network.

    #[builder(default)]

    network_config: NetworkConfig,

    /// Configuration information about when we download things.

    ///

    /// This can be replaced on a running Arti client. Doing so affects _future_

    /// download attempts, but has no effect on attempts that are currently in

    /// progress or being retried.

    ///

    /// (The above is a limitation: we would like it to someday have an effect

    /// on in-progress attempts as well, at least at the top level.  Users

    /// should _not_ assume that the effect of changing this option will always

    /// be delayed.)

    #[builder(default)]

    schedule_config: DownloadScheduleConfig,

    /// A map of network parameters that we're overriding from their settings in

    /// the consensus.

    ///

    /// This can be replaced on a running Arti client.  Doing so will take

    /// effect the next time a consensus is downloaded.

    ///

    /// (The above is a limitation: we would like it to someday take effect

    /// immediately. Users should _not_ assume that the effect of changing this

    /// option will always be delayed.)

    #[builder(default)]

    override_net_params: netstatus::NetParams<i32>,

}

impl DirMgrConfigBuilder {

    /// Overrides the network consensus parameter named `param` with a

    /// new value.

    ///

    /// If the new value is out of range, it will be clamped to the

    /// acceptable range.

    ///

    /// If the parameter is not recognized by Arti, it will be

    /// ignored, and a warning will be produced when we try to apply

    /// it to the consensus.

    ///

    /// By default no parameters will be overridden.

}

impl DirMgrConfig {

    /// Return a new builder to construct a DirMgrConfig.

    /// Create a store from this configuration.

    ///

    /// Note that each time this is called, a new store object will be

    /// created: you probably only want to call this once.

    /// Return the configured cache path.

    /// Return a slice of the configured authorities

    /// Return the configured set of fallback directories

    /// Return set of configured networkstatus parameter overrides.

    /// Return the schedule configuration we should use to decide when to

    /// attempt and retry downloads.

    /// Construct a new configuration object where all replaceable fields in

    /// `self` are replaced with those from  `new_config`.

    ///

    /// Any fields which aren't allowed to change at runtime are copied from self.

    /// Construct a new configuration object where all replaceable fields in

    /// `self` are replaced with those from  `new_config`.

    ///

    /// Any fields which aren't allowed to change at runtime are copied from self.

    #[cfg(feature = "experimental-api")]

}

impl DownloadScheduleConfig {

    /// Return configuration for retrying our entire bootstrap

    /// operation at startup.

    /// Return configuration for retrying a consensus download.

    /// Return configuration for retrying an authority certificate download

    /// Return configuration for retrying an authority certificate download

}

/// Helpers for initializing the fallback list.

mod fallbacks {

    use tor_llcrypto::pk::{ed25519::Ed25519Identity, rsa::RsaIdentity};

    use tor_netdir::fallback::FallbackDir;

    /// Return a list of the default fallback directories shipped with

    /// arti.

}

#[cfg(test)]

mod test {

    #![allow(clippy::unwrap_used)]

    #![allow(clippy::unnecessary_wraps)]

    use super::*;

    use tempfile::tempdir;

    #[test]

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

        let tmp = tempdir().unwrap();

        let dir = DirMgrConfigBuilder::default()

            .cache_path(tmp.path().to_path_buf())

            .build()

            .unwrap();

        assert!(dir.authorities().len() >= 3);

        assert!(dir.fallbacks().len() >= 3);

        // TODO: verify other defaults.

        Ok(())

    }

    #[test]

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

        let dflt = NetworkConfig::default();

        // with nothing set, we get the default.

        let mut bld = NetworkConfig::builder();

        let cfg = bld.build().unwrap();

        assert_eq!(cfg.authorities().len(), dflt.authorities.len());

        assert_eq!(cfg.fallbacks().len(), dflt.fallback_caches.len());

        // with any authorities set, the fallback list _must_ be set

        // or the build fails.

        bld.authorities(vec![

            Authority::builder()

                .name("Hello")

                .v3ident([b'?'; 20].into())

                .build()

                .unwrap(),

            Authority::builder()

                .name("world")

                .v3ident([b'!'; 20].into())

                .build()

                .unwrap(),

        ]);

        assert!(bld.build().is_err());

        bld.fallback_caches(vec![FallbackDir::builder()

            .rsa_identity([b'x'; 20].into())

            .ed_identity([b'y'; 32].into())

            .orport("127.0.0.1:99".parse().unwrap())

            .orport("[::]:99".parse().unwrap())

            .build()

            .unwrap()]);

        let cfg = bld.build().unwrap();

        assert_eq!(cfg.authorities().len(), 2);

        assert_eq!(cfg.fallbacks().len(), 1);

        Ok(())

    }

    #[test]

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

        use std::time::Duration;

        let mut bld = DownloadScheduleConfig::builder();

        let cfg = bld.build().unwrap();

        assert_eq!(cfg.retry_microdescs().parallelism(), 4);

        assert_eq!(cfg.retry_microdescs().n_attempts(), 3);

        assert_eq!(cfg.retry_bootstrap().n_attempts(), 128);

        bld.retry_consensus(DownloadSchedule::new(7, Duration::new(86400, 0), 1))

            .retry_bootstrap(DownloadSchedule::new(4, Duration::new(3600, 0), 1))

            .retry_certs(DownloadSchedule::new(5, Duration::new(3600, 0), 1))

            .retry_microdescs(DownloadSchedule::new(6, Duration::new(3600, 0), 0));

        let cfg = bld.build().unwrap();

        assert_eq!(cfg.retry_microdescs().parallelism(), 1); // gets clamped

        assert_eq!(cfg.retry_microdescs().n_attempts(), 6);

        assert_eq!(cfg.retry_bootstrap().n_attempts(), 4);

        assert_eq!(cfg.retry_consensus().n_attempts(), 7);

        assert_eq!(cfg.retry_certs().n_attempts(), 5);

        Ok(())

    }

    #[test]

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

        let mut bld = DirMgrConfig::builder();

        let tmp = tempdir().unwrap();

        let cfg = bld

            .override_net_param("circwindow".into(), 999)

            .cache_path(tmp.path())

            .network_config(NetworkConfig::default())

            .schedule_config(DownloadScheduleConfig::default())

            .build()

            .unwrap();

        assert_eq!(cfg.override_net_params().get("circwindow").unwrap(), &999);

        Ok(())

    }

}