chrony-confile 0.1.0

//! Builder pattern for programmatic configuration generation.
//!
//! Provides [`ServerBuilder`] and [`PoolBuilder`] for constructing `server` and `pool`
//! directives with type-safe method chaining. All options are validated at call time
//! via the bounded integer newtypes from [`values`](crate::values).

use crate::ast::*;
use crate::span::Span;
use crate::values::*;

/// Builder for creating `server` directives programmatically.
///
/// Provides a type-safe, chainable API for constructing [`DirectiveKind::Server`] values
/// with all supported options. Every option is validated at call time via the bounded
/// integer newtypes from [`crate::values`].
///
/// # Examples
///
/// ```rust
/// use chrony_confile::builder::ServerBuilder;
/// use chrony_confile::values::{PollInterval, UdpPort};
///
/// let directive = ServerBuilder::new("ntp.example.com")
///     .iburst()
///     .prefer()
///     .minpoll(PollInterval::new(4)?)
///     .maxpoll(PollInterval::new(10)?)
///     .build();
///
/// assert_eq!(directive.kind.name(), "server");
/// # Ok::<_, Box<dyn std::error::Error>>(())
/// ```
#[derive(Debug, Clone)]
pub struct ServerBuilder {
    pub(crate) config: ServerConfig,
}

impl ServerBuilder {
    /// Creates a new builder for the given hostname.
    ///
    /// All other options are initialized to chrony defaults.
    #[must_use]
    pub fn new(hostname: impl Into<String>) -> Self {
        Self {
            config: ServerConfig {
                hostname: hostname.into(),
                ..Default::default()
            },
        }
    }

    /// Enables the `iburst` option (initial burst of quick measurements).
    #[must_use]
    pub fn iburst(mut self) -> Self {
        self.config.iburst = true;
        self
    }

    /// Enables the `burst` option (always burst measurements).
    #[must_use]
    pub fn burst(mut self) -> Self {
        self.config.burst = true;
        self
    }

    /// Sets the `prefer` selection option.
    #[must_use]
    pub fn prefer(mut self) -> Self {
        self.config.select_opts.set(SelectOptions::PREFER);
        self
    }

    /// Sets the `noselect` selection option.
    #[must_use]
    pub fn noselect(mut self) -> Self {
        self.config.select_opts.set(SelectOptions::NOSELECT);
        self
    }

    /// Sets the `trust` selection option.
    #[must_use]
    pub fn trust(mut self) -> Self {
        self.config.select_opts.set(SelectOptions::TRUST);
        self
    }

    /// Sets the `require` selection option.
    #[must_use]
    pub fn require(mut self) -> Self {
        self.config.select_opts.set(SelectOptions::REQUIRE);
        self
    }

    /// Enables NTS (Network Time Security) for this source.
    #[must_use]
    pub fn nts(mut self) -> Self {
        self.config.nts = true;
        self
    }

    /// Marks the source as initially offline.
    #[must_use]
    pub fn offline(mut self) -> Self {
        self.config.connectivity = SourceConnectivity::Offline;
        self
    }

    /// Sets the minimum polling interval (as a power of 2 in seconds).
    #[must_use]
    pub fn minpoll(mut self, poll: PollInterval) -> Self {
        self.config.minpoll = poll;
        self
    }

    /// Sets the maximum polling interval (as a power of 2 in seconds).
    #[must_use]
    pub fn maxpoll(mut self, poll: PollInterval) -> Self {
        self.config.maxpoll = poll;
        self
    }

    /// Sets the UDP port for this source.
    #[must_use]
    pub fn port(mut self, port: UdpPort) -> Self {
        self.config.port = port;
        self
    }

    /// NTS port for the server.
    #[must_use]
    pub fn ntsport(mut self, port: UdpPort) -> Self {
        self.config.nts_port = port;
        self
    }

    /// Sets the maximum expected round-trip delay (seconds).
    #[must_use]
    pub fn maxdelay(mut self, delay: f64) -> Self {
        self.config.max_delay = delay;
        self
    }

    /// Max delay ratio.
    #[must_use]
    pub fn maxdelayratio(mut self, ratio: f64) -> Self {
        self.config.max_delay_ratio = ratio;
        self
    }

    /// Max delay dev ratio.
    #[must_use]
    pub fn maxdelaydevratio(mut self, ratio: f64) -> Self {
        self.config.max_delay_dev_ratio = ratio;
        self
    }

    /// Max delay quantile.
    #[must_use]
    pub fn maxdelayquant(mut self, quant: f64) -> Self {
        self.config.max_delay_quant = quant;
        self
    }

    /// Min delay.
    #[must_use]
    pub fn mindelay(mut self, delay: f64) -> Self {
        self.config.min_delay = delay;
        self
    }

    /// Asymmetry.
    #[must_use]
    pub fn asymmetry(mut self, asym: f64) -> Self {
        self.config.asymmetry = asym;
        self
    }

    /// Auto offline mode.
    #[must_use]
    pub fn auto_offline(mut self) -> Self {
        self.config.auto_offline = true;
        self
    }

    /// Interleaved mode (xleave).
    #[must_use]
    pub fn xleave(mut self) -> Self {
        self.config.interleaved = true;
        self
    }

    /// Copy peer measurement statistics.
    #[must_use]
    pub fn copy(mut self) -> Self {
        self.config.copy = true;
        self
    }

    /// Presend poll interval.
    #[must_use]
    pub fn presend(mut self, poll: PollInterval) -> Self {
        self.config.presend = poll;
        self
    }

    /// Filter value.
    #[must_use]
    pub fn filter(mut self, n: u32) -> Self {
        self.config.filter = Some(n);
        self
    }

    /// Address family.
    #[must_use]
    pub fn family(mut self, family: AddressFamily) -> Self {
        self.config.family = family;
        self
    }

    /// Extension field ID (hex).
    #[must_use]
    pub fn extfield(mut self, id: u32) -> Self {
        self.config.ext_fields = id;
        self
    }

    /// Sets the time offset for this source (seconds).
    #[must_use]
    pub fn offset(mut self, offset: f64) -> Self {
        self.config.offset = offset;
        self
    }

    /// Sets the NTP protocol version for this source.
    #[must_use]
    pub fn version(mut self, version: NtpVersion) -> Self {
        self.config.version = Some(version);
        self
    }

    /// Sets the authentication key ID for this source.
    #[must_use]
    pub fn key(mut self, key_id: u32) -> Self {
        self.config.authkey = key_id;
        self
    }

    /// Sets the authentication key ID (alias for `key`).
    #[must_use]
    pub fn authkey(mut self, key_id: u32) -> Self {
        self.config.authkey = key_id;
        self
    }

    /// Sets the minimum number of samples to keep.
    #[must_use]
    pub fn minsamples(mut self, n: u32) -> Self {
        self.config.min_samples = Some(n);
        self
    }

    /// Sets the maximum number of samples to keep.
    #[must_use]
    pub fn maxsamples(mut self, n: u32) -> Self {
        self.config.max_samples = Some(n);
        self
    }

    /// Sets the poll target number of samples.
    #[must_use]
    pub fn polltarget(mut self, target: PollTarget) -> Self {
        self.config.poll_target = target;
        self
    }

    /// Sets the minimum stratum for this source.
    #[must_use]
    pub fn minstratum(mut self, stratum: Stratum) -> Self {
        self.config.min_stratum = stratum;
        self
    }

    /// Sets the certificate set ID for NTS.
    #[must_use]
    pub fn certset(mut self, id: u32) -> Self {
        self.config.cert_set = id;
        self
    }

    /// Builds and returns a `server` directive with the configured options.
    #[must_use]
    pub fn build(self) -> Box<Directive> {
        Box::new(Directive::new(
            DirectiveKind::Server(self.config),
            Span::new(None, 0, 0, 0),
        ))
    }
}

/// Builder for creating `pool` directives.
#[derive(Debug, Clone)]
pub struct PoolBuilder {
    config: PoolConfig,
}

impl PoolBuilder {
    /// Creates a new builder for the given pool hostname.
    ///
    /// All other options are initialized to chrony defaults.
    #[must_use]
    pub fn new(hostname: impl Into<String>) -> Self {
        Self {
            config: PoolConfig {
                source: ServerConfig {
                    hostname: hostname.into(),
                    ..Default::default()
                },
                max_sources: 4,
            },
        }
    }

    /// Enables the `iburst` option (initial burst of quick measurements).
    #[must_use]
    pub fn iburst(mut self) -> Self {
        self.config.source.iburst = true;
        self
    }

    #[must_use]
    pub fn burst(mut self) -> Self {
        self.config.source.burst = true;
        self
    }

    #[must_use]
    pub fn prefer(mut self) -> Self {
        self.config.source.select_opts.set(SelectOptions::PREFER);
        self
    }

    #[must_use]
    pub fn noselect(mut self) -> Self {
        self.config.source.select_opts.set(SelectOptions::NOSELECT);
        self
    }

    #[must_use]
    pub fn trust(mut self) -> Self {
        self.config.source.select_opts.set(SelectOptions::TRUST);
        self
    }

    #[must_use]
    pub fn require(mut self) -> Self {
        self.config.source.select_opts.set(SelectOptions::REQUIRE);
        self
    }

    #[must_use]
    pub fn nts(mut self) -> Self {
        self.config.source.nts = true;
        self
    }

    #[must_use]
    pub fn offline(mut self) -> Self {
        self.config.source.connectivity = SourceConnectivity::Offline;
        self
    }

    #[must_use]
    pub fn minpoll(mut self, poll: PollInterval) -> Self {
        self.config.source.minpoll = poll;
        self
    }

    #[must_use]
    pub fn maxpoll(mut self, poll: PollInterval) -> Self {
        self.config.source.maxpoll = poll;
        self
    }

    #[must_use]
    pub fn port(mut self, port: UdpPort) -> Self {
        self.config.source.port = port;
        self
    }

    #[must_use]
    pub fn maxdelay(mut self, delay: f64) -> Self {
        self.config.source.max_delay = delay;
        self
    }

    #[must_use]
    pub fn offset(mut self, offset: f64) -> Self {
        self.config.source.offset = offset;
        self
    }

    #[must_use]
    pub fn version(mut self, version: NtpVersion) -> Self {
        self.config.source.version = Some(version);
        self
    }

    #[must_use]
    pub fn key(mut self, key_id: u32) -> Self {
        self.config.source.authkey = key_id;
        self
    }

    /// Sets the minimum number of samples to keep.
    #[must_use]
    pub fn minsamples(mut self, n: u32) -> Self {
        self.config.source.min_samples = Some(n);
        self
    }

    /// Sets the maximum number of samples to keep.
    #[must_use]
    pub fn maxsamples(mut self, n: u32) -> Self {
        self.config.source.max_samples = Some(n);
        self
    }

    /// Sets the poll target number of samples.
    #[must_use]
    pub fn polltarget(mut self, target: PollTarget) -> Self {
        self.config.source.poll_target = target;
        self
    }

    /// Sets the maximum number of sources from this pool.
    #[must_use]
    pub fn maxsources(mut self, n: u32) -> Self {
        self.config.max_sources = n;
        self
    }

    /// Builds and returns a `pool` directive with the configured options.
    #[must_use]
    pub fn build(self) -> Box<Directive> {
        Box::new(Directive::new(
            DirectiveKind::Pool(self.config),
            Span::new(None, 0, 0, 0),
        ))
    }
}