use std::{fmt::Display, time::Instant};

use crate::ui::utils::ByteSpeed;

#[derive(Debug, Clone, PartialEq)]
pub enum EstimatedTime {
    Known(f64),
    Unknown,
}

#[derive(Debug, Clone, PartialEq)]
pub struct ByteSeries {
    raw: Vec<(f64, u64)>,
    start: Instant,
}

impl From<f64> for EstimatedTime {
    fn from(value: f64) -> Self {
        if value.is_finite() {
            Self::Known(value)
        } else {
            Self::Unknown
        }
    }
}

impl Display for EstimatedTime {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            EstimatedTime::Known(x) => write!(f, "{x:.1}s"),
            EstimatedTime::Unknown => write!(f, "[unknown]"),
        }
    }
}

impl ByteSeries {
    pub fn new(start: Instant) -> Self {
        Self {
            start,
            raw: vec![(0.0, 0)],
        }
    }

    pub fn push(&mut self, time: Instant, bytes: u64) {
        let secs = time.duration_since(self.start).as_secs_f64();
        self.raw.push((secs, bytes));
    }

    pub fn last_datapoint(&self) -> (f64, u64) {
        self.raw.last().copied().unwrap_or((0.0, 0))
    }

    pub fn bytes_encountered(&self) -> u64 {
        self.last_datapoint().1
    }

    pub fn total_avg_speed(&self) -> ByteSpeed {
        let s = self.bytes_encountered();
        let speed = s as f64 / self.last_datapoint().0;
        ByteSpeed(if speed.is_nan() { 0.0 } else { speed })
    }

    pub fn estimated_time_left(&self, total_bytes: u64) -> EstimatedTime {
        let speed = self.total_avg_speed().0;
        // Saturating subtract is necessary because bytes encountered may be greater
        // than total bytes, due to the nature of block writing.
        let bytes_left = total_bytes.saturating_sub(self.bytes_encountered());
        let secs_left = bytes_left as f64 / speed;
        EstimatedTime::from(secs_left)
    }

    pub fn start(&self) -> Instant {
        self.start
    }

    pub fn speed(&self, t: f64, window: f64) -> f64 {
        let b0 = self.interp(t - window);
        let b1 = self.interp(t);

        (b1 - b0) / window
    }

    /// Returns a series of points representing a timeseries, aggregated by the given window size.
    pub fn speeds(&self, window: f64) -> impl Iterator<Item = (f64, f64)> + '_ {
        let bins = (self.last_datapoint().0 / window).ceil() as usize;
        (0..bins).map(move |i| {
            let t = i as f64 * window;
            (t, self.speed(t, window))
        })
    }

    /// Returns the index of the sample right before the requested time.
    fn find_idx_below(&self, t: f64) -> usize {
        let mut min = 0;
        if t <= self.raw[min].0 {
            return min;
        }

        let mut max = self.raw.len() - 1;
        if self.raw[max].0 <= t {
            return max;
        }

        loop {
            if min >= max - 1 {
                return min;
            }
            let mid = (min + max) / 2;
            let mid_val = self.raw[mid].0;
            if t < mid_val {
                max = mid;
            } else {
                min = mid;
            }
        }
    }

    /// Returns the interpolated number of bytes encountered at the given time.
    pub fn interp(&self, t: f64) -> f64 {
        if t < 0.0 {
            return self.raw[0].1 as f64;
        }
        let (last, last_val) = self.last_datapoint();
        if t >= last {
            return last_val as f64;
        }

        let i0 = self.find_idx_below(t);
        let i1 = i0 + 1;
        let (x0, y0) = self.raw[i0];
        let (x1, y1) = self.raw[i1];

        (y1 as f64 - y0 as f64) * (t - x0) / (x1 - x0) + y0 as f64
    }
}

#[cfg(test)]
mod tests {
    use std::time::{Duration, Instant};

    use approx::assert_relative_eq;

    use super::ByteSeries;
    use test_case::test_case;

    fn example_2s() -> ByteSeries {
        let now = Instant::now();
        let mut s = ByteSeries::new(now);
        s.push(now.checked_add(Duration::from_secs_f64(0.1)).unwrap(), 10);
        s.push(now.checked_add(Duration::from_secs_f64(0.2)).unwrap(), 20);
        s.push(now.checked_add(Duration::from_secs_f64(0.5)).unwrap(), 30);
        s.push(now.checked_add(Duration::from_secs_f64(1.0)).unwrap(), 40);
        s.push(now.checked_add(Duration::from_secs_f64(1.5)).unwrap(), 80);
        s.push(now.checked_add(Duration::from_secs_f64(2.0)).unwrap(), 100);
        s
    }

    #[test_case(0.0 => is eq 0; "zero")]
    #[test_case(-10.0 => is eq 0; "negative")]
    #[test_case(0.4 => is eq 2; "between")]
    #[test_case(0.5 => is eq 3; "exact")]
    #[test_case(2.0 => is eq 6; "exactly last")]
    #[test_case(3.0 => is eq 6; "over")]
    fn find_idx_below(t: f64) -> usize {
        example_2s().find_idx_below(t)
    }

    #[test_case(0.0, 0.0; "zero")]
    #[test_case(-10.0, 0.0; "negative")]
    #[test_case(0.75, 35.0; "between")]
    #[test_case(0.5, 30.0; "exact")]
    #[test_case(2.0, 100.0; "exactly last")]
    #[test_case(3.0, 100.0; "over")]
    fn interp_bytes(t: f64, expected: f64) {
        let actual = example_2s().interp(t);
        assert_relative_eq!(actual, expected);
    }
}