//! Consensus parameters for stream flow control.

/// Parameters from the consensus that are required for stream flow control.

// We want an exhaustive struct with public fields here. If we add a field here, it's probably

// because we need it. A builder pattern would mean that the user's code would fail at runtime if

// they didn't provide a parameter, rather than at compile time. There is also no `Default` for this

// struct as the defaults belong in `NetParameters`, so a non-exhaustive struct would not be able to

// be constructed.

#[derive(Clone, Debug)]

#[allow(clippy::exhaustive_structs)]

pub struct FlowCtrlParameters {

    /// See `tor_netdir::params::NetParameters::cc_xoff_client`.

    // This conversion rate is copied from c-tor (see `flow_control_new_consensus_params()`).

    // TODO: This const conversion rate becomes part of the public API, but it shouldn't be. The

    // alternative is a bunch of boilerplate code to hide it, so just leaving for now since

    // tor-proto is not stable.

    pub cc_xoff_client: CellCount<{ tor_cell::relaycell::PAYLOAD_MAX_SIZE_ALL as u32 }>,

    /// See `tor_netdir::params::NetParameters::cc_xoff_exit`.

    // This conversion rate is copied from c-tor (see `flow_control_new_consensus_params()`).

    pub cc_xoff_exit: CellCount<{ tor_cell::relaycell::PAYLOAD_MAX_SIZE_ALL as u32 }>,

    /// See `tor_netdir::params::NetParameters::cc_xon_rate`.

    // This conversion rate is copied from c-tor (see `flow_control_new_consensus_params()`).

    pub cc_xon_rate: CellCount<{ tor_cell::relaycell::PAYLOAD_MAX_SIZE_ANY as u32 }>,

    /// See `tor_netdir::params::NetParameters::cc_xon_change_pct`.

    pub cc_xon_change_pct: u32,

    /// See `tor_netdir::params::NetParameters::cc_xon_ewma_cnt`.

    pub cc_xon_ewma_cnt: u32,

}

impl FlowCtrlParameters {

    #[cfg(test)]

        // These have been copied from the current consensus, but may be out of date.

}

/// A cell count that can be converted into a byte count using a constant conversion rate.

///

/// The const generic is the conversion multiplier when converting from cells to bytes.

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]

pub struct CellCount<const BYTES_PER_CELL: u32>(u32);

impl<const BYTES_PER_CELL: u32> CellCount<BYTES_PER_CELL> {

    /// A new [`CellCount`].

    /// The [`CellCount`] as the number of cells.

    ///

    /// This is the value that [`CellCount`] was originally constructed with.

    /// The number of payload bytes corresponding to this [`CellCount`].

    ///

    /// This is a constant multiple of the cell count,

    /// and is the conversion we use for the consensus parameters.

    /// For example `cc_xoff_client` which says:

    ///

    /// > Specifies the outbuf length, in relay cell multiples

        // u32 to u64 cast

            // u32 to u64 cast

}

#[cfg(test)]

mod test {

    use super::*;

    #[test]

    fn compare_to_ctor_values() {

        let params = FlowCtrlParameters {

            cc_xoff_client: CellCount::new(1),

            cc_xoff_exit: CellCount::new(1),

            cc_xon_rate: CellCount::new(1),

            cc_xon_change_pct: 1,

            cc_xon_ewma_cnt: 1,

        };

        // If any of these assertions fail in the future,

        // it means that the value no longer matches with C-tor

        // `RELAY_PAYLOAD_SIZE_MIN`/`RELAY_PAYLOAD_SIZE_MAX`.

        // If this happens we should re-evaluate the status of things and see if we should hard-code

        // this to be the same as C-tor, or remove this check.

        /// `RELAY_PAYLOAD_SIZE_MIN` from c-tor

        const C_TOR_RELAY_PAYLOAD_SIZE_MIN: u64 = 509 - (16 + 1 + 2 + 2);

        /// `RELAY_PAYLOAD_SIZE_MAX` from c-tor

        const C_TOR_RELAY_PAYLOAD_SIZE_MAX: u64 = 509 - (1 + 2 + 2 + 4 + 2);

        assert_eq!(

            params.cc_xoff_client.as_bytes(),

            C_TOR_RELAY_PAYLOAD_SIZE_MIN,

        );

        assert_eq!(params.cc_xoff_exit.as_bytes(), C_TOR_RELAY_PAYLOAD_SIZE_MIN);

        assert_eq!(params.cc_xon_rate.as_bytes(), C_TOR_RELAY_PAYLOAD_SIZE_MAX);

    }

}