淀川三十石船と高槻藩の宿場物流を「待ち行列理論（M/M/1）」と
現代のインターネット輻輳制御（TCP BBR）で読み解く歴史数理紀行

#![forbid(unsafe_code)]

/// Steady-state metrics for an M/M/1 queueing system under Little's Law (L = lambda * W).
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Mm1Metrics {
    pub utilization_rho: f64,
    pub mean_queue_length_lq: f64,
    pub mean_wait_time_wq_sec: f64,
    pub mean_system_time_w_sec: f64,
}

/// Computes exact steady-state M/M/1 metrics given arrival rate lambda and service rate mu.
/// Returns None if the system is unstable (lambda >= mu).
pub fn analyze_mm1_queue(arrival_rate_lambda: f64, service_rate_mu: f64) -> Option<Mm1Metrics> {
    if arrival_rate_lambda < 0.0 || service_rate_mu <= 0.0 || arrival_rate_lambda >= service_rate_mu {
        return None;
    }
    let rho = arrival_rate_lambda / service_rate_mu;
    let lq = (rho * rho) / (1.0 - rho);
    let wq = rho / (service_rate_mu * (1.0 - rho));
    let w = 1.0 / (service_rate_mu - arrival_rate_lambda);

    Some(Mm1Metrics {
        utilization_rho: rho,
        mean_queue_length_lq: lq,
        mean_wait_time_wq_sec: wq,
        mean_system_time_w_sec: w,
    })
}

/// BBR-inspired Bandwidth-Delay Product (BDP) pacing state machine.
#[derive(Debug, Clone, Copy)]
pub struct BbrPacingController {
    pub max_bw_bytes_per_sec: f64,
    pub min_rtt_sec: f64,
    pub pacing_gain: f64,
    pub cwnd_gain: f64,
}

#[derive(Debug, Clone, Copy)]
pub struct PacingSchedule {
    pub target_inflight_bdp_bytes: usize,
    pub target_cwnd_bytes: usize,
    pub inter_packet_interval_nanos: u64,
}

impl BbrPacingController {
    /// Updates bottleneck bandwidth and minimum RTT estimates from a delivery sample.
    #[inline]
    pub fn update_telemetry(&mut self, delivered_bytes: usize, interval_sec: f64, rtt_sec: f64) {
        if interval_sec > 1e-6 {
            let sample_bw = (delivered_bytes as f64) / interval_sec;
            if sample_bw > self.max_bw_bytes_per_sec {
                self.max_bw_bytes_per_sec = sample_bw;
            }
        }
        if rtt_sec > 1e-6 && (self.min_rtt_sec <= 0.0 || rtt_sec < self.min_rtt_sec) {
            self.min_rtt_sec = rtt_sec;
        }
    }

    /// Computes Kleinrock's optimal BDP congestion window and inter-packet pacing interval.
    pub fn compute_pacing_schedule(&self, mss_bytes: usize) -> PacingSchedule {
        let bdp = self.max_bw_bytes_per_sec * self.min_rtt_sec;
        let cwnd = (bdp * self.cwnd_gain).ceil() as usize;
        let effective_rate = (self.max_bw_bytes_per_sec * self.pacing_gain).max(1.0);
        let interval_sec = (mss_bytes as f64) / effective_rate;
        let nanos = (interval_sec * 1e9).round() as u64;

        PacingSchedule {
            target_inflight_bdp_bytes: bdp.ceil() as usize,
            target_cwnd_bytes: cwnd.max(4 * mss_bytes),
            inter_packet_interval_nanos: nanos.max(100),
        }
    }
}