//! A generalised Embassy driver for the Strike Sensor v1
//! ⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁢⁢⁤⁤⁤⁢⁢⁤⁢⁤⁢⁤⁢⁢⁢⁤⁢⁢⁤⁢⁢⁢⁢⁤⁢⁤⁢⁢⁤⁢⁢⁤⁢⁢⁤⁤⁤⁤⁢⁤⁢⁤⁢⁢⁢⁢⁢⁤⁢⁢⁤⁢⁢⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁢⁤⁤⁤⁤⁤⁢⁤⁢⁢⁤⁤⁢⁤⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁢⁢⁢⁤⁤⁤⁢⁤⁢⁢⁤⁢⁢⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁢⁤⁤⁤⁤⁤⁢⁤⁢⁤⁢⁢⁤⁤⁢⁤⁢⁤⁢⁤⁢⁢⁢⁤⁢⁤⁢⁢⁤⁢⁢⁤⁢⁢⁤⁢⁢⁤⁢⁤⁢⁢⁤⁤⁤⁢⁢⁤⁢⁢⁢⁤⁤⁤⁢⁤⁢⁤⁤⁤⁤⁤⁢⁤⁢⁤⁢⁤⁢⁢⁢⁤⁢⁤⁢⁢⁤⁢⁢⁤⁢⁢⁤⁢⁢⁤⁢⁤⁢⁢⁢⁤⁤⁤⁢⁤⁢⁢⁢⁤⁤⁤⁢⁤⁢⁢⁢⁤⁢⁤⁢⁤⁢⁤⁢⁢⁤⁢⁢⁤⁢⁤⁤⁤⁤⁤⁢⁤⁢⁤⁢⁢⁤⁢⁢⁤⁢⁢⁢⁤⁢⁤⁢⁤⁢⁢⁢⁤⁢⁢⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁢⁤⁢⁤⁢⁢⁢⁤⁢⁢⁢⁤⁢⁤⁢⁤⁢⁢⁢⁤⁢⁢⁢⁤⁢⁤⁤⁤⁤⁤⁢⁤⁢⁤⁢⁤⁢⁢⁢⁤⁢⁢⁤⁢⁢⁢⁢⁤⁢⁢⁤⁢⁢⁤⁢⁤⁢⁢⁤⁤⁤⁢⁢⁤⁢⁢⁤⁢⁤⁤⁢⁤⁢⁢⁤⁢⁢⁤⁢⁤⁢⁢⁤⁤⁤⁢⁢⁤⁢⁢⁢⁤⁤⁤⁢⁤⁢⁤⁤⁤⁤⁤⁢⁢⁤⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁤⁢⁢⁤⁢⁢⁢⁢⁤⁤⁢⁢⁤⁤⁤⁢⁢⁤⁢⁤⁢⁢⁢⁢⁢⁤⁢⁢⁤⁤⁢⁢⁢⁤⁢⁢⁤⁤⁢⁢⁤⁤⁢⁤⁢⁢⁢⁤⁢⁤⁢⁢⁤⁤⁢⁢⁢⁤⁢⁢⁤⁤⁤⁢⁢⁤⁢⁢⁤⁤⁢⁢⁤⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁢⁤⁤⁢⁢⁢⁤⁢⁢⁤⁤⁢⁤⁤⁤⁢⁢⁤⁤⁢⁤⁤⁤⁢⁢⁤⁤⁢⁤⁤⁢⁢⁢⁤⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁤⁢⁢⁤⁢⁢⁢⁢⁤⁤⁢⁢⁤⁤⁢⁤⁤⁤⁢⁢⁤⁤⁢⁢⁤⁤⁢⁢⁤⁤⁤⁢⁢⁤⁢⁢⁤⁤⁤⁢⁢⁢⁢⁤⁢⁢⁢⁢⁢⁤⁢⁢⁤⁤⁤⁢⁢⁤⁢⁢⁤⁤⁤⁢⁢⁢⁢⁢⁤⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁢⁤⁤⁢⁢⁤⁤⁢⁢⁤⁢⁢⁤⁢⁢⁢⁤⁢⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁢⁢⁢⁤⁢⁤⁢⁢⁤⁤⁢⁤⁢⁢⁢⁤⁢⁢⁢⁢⁤⁤⁢⁢⁤⁤⁢⁢⁢⁤⁢⁢⁤⁤⁢⁢⁤⁢⁢⁢⁤⁤⁢⁤⁢⁤⁢⁢⁤⁤⁢⁢⁤⁤⁢⁤⁢⁢⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁢⁤⁢⁤⁢⁢⁢⁤⁢⁤⁢⁢⁤⁤⁢⁢⁤⁢⁢⁤⁢⁢⁢⁤⁢⁢⁢⁢⁤⁤⁤⁢⁢⁢⁢⁢⁤⁤⁢⁢⁤⁢⁢⁢⁤⁤⁢⁤⁤⁢⁢⁢⁤⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁢⁢⁤⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁢⁤⁤⁢⁢⁢⁢⁢⁤⁢⁢⁢⁤⁢⁤⁢⁢⁤⁤⁢⁤⁢⁤⁢⁢⁤⁤⁢⁢⁤⁢⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁢⁤⁤⁢⁢⁤⁢⁢⁢⁤⁤⁤⁢⁢⁢⁢⁢⁤⁤⁢⁤⁤⁤⁢⁢⁤⁤⁢⁤⁤⁢⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁢⁢⁢⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁢⁢⁤⁢⁤⁤⁢⁢⁢⁢⁢⁤⁤⁢⁤⁢⁤⁢⁤⁢⁢⁤⁤⁤⁤⁢⁢⁤⁢⁢⁢⁢⁤⁢⁤⁢⁤⁢⁢⁢⁢⁢⁢⁤⁢⁢⁤⁢⁤⁢⁤⁢⁢⁢⁢⁢⁢⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁤⁢⁤⁤⁢⁢⁤⁤⁢⁤⁢⁢⁢⁤⁢⁤⁤⁤⁢⁢⁢⁤⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁤⁢⁤⁢⁢⁤⁢⁤⁤⁢⁢⁢⁢⁢⁤⁤⁢⁤⁢⁤⁢⁢⁤⁤⁢⁤⁢⁢⁢⁢⁤⁢⁤⁢⁢⁢⁢⁤⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁤⁤⁤⁢⁢⁢⁤⁢⁤⁢⁢⁤⁢⁢⁤⁤⁢⁤⁤⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁢⁤⁢⁤⁢⁢⁤⁢⁢⁤⁤⁢⁤⁤⁤⁢⁤⁤⁤⁤⁤⁢⁤⁢⁢⁤⁢⁢⁤⁢⁢⁢⁤⁢⁢⁢⁤⁢⁤⁢⁤⁢⁢⁤⁢⁢⁤⁢⁤⁢⁢⁢⁢⁤⁤⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁢⁤⁢⁢⁤⁢⁢⁢⁤⁢⁤⁤⁢⁤⁢⁤⁢⁤⁢⁢⁤⁤⁢⁤⁢⁤⁢⁤⁢⁢⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁢⁢⁤⁤⁤⁢⁢⁤⁢⁢⁢⁤⁢⁢⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁢⁤⁢⁢⁤⁢⁢⁤⁢⁢⁢⁤⁢⁢⁢⁢⁤⁢⁤⁤⁢⁤⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁢⁢⁤⁤⁤⁢⁢⁤⁢⁤⁢⁤⁢⁢⁢⁤⁢⁢⁤⁢⁢⁤⁢⁤⁢⁤⁢⁤⁤⁢⁢⁤⁢⁢⁤⁢⁢⁤⁢⁤⁢⁤⁢⁢⁤⁢⁢⁤⁢⁤⁢⁤⁢⁤⁢⁤⁢⁤⁢⁢⁤⁤⁢⁢⁤⁢⁤⁤⁢⁤⁢⁤⁢⁤⁢⁤⁢⁢⁢⁤⁢⁢⁢⁤⁢⁤⁢⁤⁢⁤⁢⁢⁤⁤⁢⁤⁢⁤⁢⁤⁢⁢⁢⁢⁤⁢⁤⁤⁢⁤⁢⁤⁢⁢⁢⁤⁤⁢⁢⁤⁢⁢⁤⁢⁢⁤⁢⁤⁢⁢⁤⁤⁢⁢⁢⁤⁢⁢⁢⁤⁢⁤⁢⁢⁤⁢⁢⁢⁢⁤⁢⁢⁤⁢⁢⁤⁢⁢⁢⁤⁢⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁢⁤⁤⁢⁤⁢⁢⁤⁢⁢⁢⁢⁢⁤⁢⁤⁢⁤⁢
#![no_std]

#[cfg(feature = "alloc")]
extern crate alloc;

mod analysis;
pub mod drivers;
pub mod traits;

use core::cell::Cell;

#[cfg(feature = "debug")]
use defmt::info;
use embassy_sync::{
    blocking_mutex::raw::NoopRawMutex,
    zerocopy_channel::{Channel, Receiver, Sender},
};
use embassy_time::{Duration, Instant, Ticker, Timer};

use crate::traits::{AdcSource, BufferMut, PwmSource, TimeSource};

pub const BLOCK_SIZE: usize = 512;
pub type ZeroCopyChannel<'device> = Channel<'device, NoopRawMutex, (i64, [u16; BLOCK_SIZE])>;

#[derive(Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
struct DetectorState {
    max_duty: Cell<u8>,
    duty: Cell<u8>,
    avg: Cell<u16>,
    strikes: Cell<u16>,
    warn_level: Cell<u16>,
}

impl Default for DetectorState {
    fn default() -> Self {
        Self {
            max_duty: Cell::new(0),
            duty: Cell::new(0),
            avg: Cell::new(0),
            strikes: Cell::new(0),
            warn_level: Cell::new(255),
        }
    }
}

#[derive(Debug, Clone)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct DetectorConfig {
    blip_threshold: Cell<u16>,
    blip_size: Cell<usize>,
}

impl DetectorConfig {
    pub const fn new(blip_threshold: u16, blip_size: usize) -> Self {
        Self {
            blip_threshold: Cell::new(blip_threshold),
            blip_size: Cell::new(blip_size),
        }
    }

    pub const fn blip_threshold(&self) -> u16 {
        self.blip_threshold.get()
    }

    pub const fn blip_size(&self) -> usize {
        self.blip_size.get()
    }

    pub fn set_blip_threshold(&self, blip_threshold: u16) {
        self.blip_threshold.set(blip_threshold);
    }

    pub fn set_blip_size(&self, blip_size: usize) {
        self.blip_size.set(blip_size);
    }
}

impl Default for DetectorConfig {
    fn default() -> Self {
        Self::new(14, 2)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum DetectorUpdate<'a> {
    Tick {
        timestamp: i64,
        level: u16,
    },
    Detection {
        timestamp: i64,
        average: u16,
        samples: &'a [u16],
        peaks: &'a [(usize, u16)],
    },
}

pub struct DetectorDriver<T: TimeSource, P: PwmSource, A: AdcSource> {
    state: DetectorState,
    config: DetectorConfig,
    timer: T,
    pwm: P,
    adc: A,
}

impl<T, P, A> DetectorDriver<T, P, A>
where
    T: TimeSource,
    P: PwmSource,
    A: AdcSource,
{
    pub fn new(config: DetectorConfig, timer: T, pwm: P, adc: A) -> Self {
        Self {
            state: Default::default(),
            config,
            timer,
            pwm,
            adc,
        }
    }

    pub async fn reset_timer_source(&mut self, timer_source: T::Source) {
        self.timer.reset_from_source(timer_source).await;
    }

    pub fn get_timestamp(&self) -> i64 {
        self.timer.timestamp()
    }

    pub fn set_blip_threshold(&self, threshold: u16) {
        self.config.blip_threshold.set(threshold);
    }

    pub fn set_blip_size(&self, size: usize) {
        self.config.blip_size.set(size);
    }

    pub fn set_config(&self, config: DetectorConfig) {
        self.set_blip_size(config.blip_size());
        self.set_blip_threshold(config.blip_threshold());
    }

    pub fn get_config(&self) -> DetectorConfig {
        self.config.clone()
    }

    pub async fn tune(&mut self, samples: &mut [u16]) {
        let mut duty = 0;
        let max_duty = self.pwm.max_duty();
        self.pwm.set_duty(duty);
        Timer::after_secs(2).await;
        let mut act_value = self.adc.sample_average(samples).await;
        #[cfg(feature = "debug")]
        info!("START: {}", act_value);

        while act_value < 1500 {
            duty += 2;
            if duty >= max_duty {
                #[cfg(feature = "debug")]
                info!("RESET: {} @ Duty {}", act_value, duty);
                duty = 0;
                self.pwm.set_duty(duty);
                Timer::after_secs(2).await;
                act_value = self.adc.sample_average(samples).await;
                continue;
            }
            self.pwm.set_duty(duty);
            Timer::after_millis(250).await;
            act_value = self.adc.sample_average(samples).await;
            #[cfg(feature = "debug")]
            info!("UPDATE: {} @ Duty {}", act_value, duty);
        }
        self.state.max_duty.set(duty as u8);
        duty = (duty / 6) * 5;
        self.pwm.set_duty(duty);
        self.state.duty.set(duty as u8);
        // Allow voltage level to stabilize after tuning
        Timer::after_secs(2).await;
        let avg = self.adc.sample_average(samples).await;
        #[cfg(feature = "debug")]
        info!("SET: {} @ Duty {}/{}", avg, duty, self.state.max_duty.get());
        self.state.avg.set(avg);
    }

    /// Samples and returns an `i64` timestamp.
    pub async fn sample_with_zerocopy<'a>(
        &self,
        dma: &mut Sender<'a, NoopRawMutex, (i64, [u16; BLOCK_SIZE])>,
    ) {
        loop {
            let (time, samples) = dma.send().await;
            self.adc.sample(samples).await;
            *time = self.get_timestamp();
            dma.send_done();
        }
    }

    pub fn detect_from_sample<B, F>(
        &self,
        timestamp: i64,
        samples: &[u16],
        peaks: &mut B,
        update: F,
    ) where
        B: BufferMut<(usize, u16)>,
        F: Fn(DetectorUpdate<'_>),
    {
        peaks.clear();

        let new_avg = analysis::analyse_buffer_by_stepped_windows(
            self.config.blip_threshold.get(),
            samples,
            self.state.avg.get(),
            peaks,
        );

        let blips = peaks.len();

        if blips >= self.config.blip_size.get() {
            self.state
                .strikes
                .update(|strike| strike.saturating_add(32));

            update(DetectorUpdate::Detection {
                timestamp,
                average: self.state.avg.get(),
                samples,
                peaks: peaks.as_slice(),
            });
        }

        self.state.avg.set(new_avg);
    }

    pub async fn detect_with_zerocopy<'a, 'd, B, F>(
        &self,
        dma: &mut Receiver<'a, NoopRawMutex, (i64, [u16; BLOCK_SIZE])>,
        peaks: &'d mut B,
        update: F,
    ) where
        B: BufferMut<(usize, u16)>,
        F: Fn(DetectorUpdate<'_>),
    {
        loop {
            let (timestamp, samples) = dma.receive().await;

            self.detect_from_sample(*timestamp, samples, peaks, &update);

            dma.receive_done();
        }
    }

    pub async fn tick<F>(&self, update: F)
    where
        F: Fn(DetectorUpdate),
    {
        let mut inactive: Option<Instant> = None;
        let mut interval = Ticker::every(Duration::from_secs(1));

        loop {
            interval.next().await;
            let strikes = self.state.strikes.get();
            let mut warn_level = self.state.warn_level.get();

            if strikes > 32 {
                warn_level = warn_level.saturating_add(strikes);
            }

            let decay = warn_level >> 8;

            self.state.strikes.set(0);
            self.state.warn_level.set(warn_level - decay);

            match inactive {
                Some(_) if decay > 0 => {
                    inactive = None;
                }
                Some(val) if val.elapsed() >= Duration::from_secs(3600) => break,
                None if decay == 0 => {
                    inactive = Some(Instant::now());
                }
                None => {
                    update(DetectorUpdate::Tick {
                        timestamp: self.get_timestamp(),
                        level: warn_level - 255,
                    });
                }
                _ => continue,
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use core::{future::poll_fn, ops::RangeBounds, slice::SliceIndex};
    use embassy_time::MockDriver;
    use rand::{Rng, distr::uniform::SampleRange};

    #[cfg(not(feature = "alloc"))]
    extern crate alloc;
    use super::*;

    #[derive(Debug, Default)]
    struct MockMachine {
        pwm: Cell<u16>,
    }

    impl MockMachine {
        fn adc_sample_avg(&self) -> u16 {
            self.pwm.get().saturating_mul(14)
        }
    }

    struct MockPwm<'a>(&'a MockMachine);

    impl PwmSource for MockPwm<'_> {
        fn max_duty(&self) -> u16 {
            255
        }

        fn set_duty(&mut self, duty: u16) {
            self.0.pwm.set(duty);
        }

        // These do nothing
        fn enable(&mut self) {}
        fn disable(&mut self) {}
    }

    struct MockAdc<'a>(&'a MockMachine);

    impl AdcSource for MockAdc<'_> {
        async fn sample(&self, samples: &mut [u16]) {
            samples.fill(self.0.adc_sample_avg());
        }

        async fn sample_average(&self, _samples: &mut [u16]) -> u16 {
            self.0.adc_sample_avg()
        }
    }

    struct MockTimeSource;

    impl TimeSource for MockTimeSource {
        type Source = ();

        async fn reset_from_source(&mut self, _source: Self::Source) {}

        fn timestamp(&self) -> i64 {
            0
        }
    }

    #[cfg(not(feature = "alloc"))]
    impl BufferMut<(usize, u16)> for alloc::vec::Vec<(usize, u16)> {
        fn push(&mut self, value: (usize, u16)) {
            self.push(value);
        }

        fn clear(&mut self) {
            self.clear();
        }

        fn len(&self) -> usize {
            self.len()
        }

        fn is_empty(&self) -> bool {
            self.is_empty()
        }

        fn as_slice(&self) -> &[(usize, u16)] {
            self
        }
    }

    async fn tune_detector_manually<'a>(
        detector: &mut DetectorDriver<MockTimeSource, MockPwm<'a>, MockAdc<'a>>,
        buf: &mut [u16],
        driver: &MockDriver,
    ) {
        let mut tuning = core::pin::pin!(detector.tune(buf));

        poll_fn(|cx| match tuning.as_mut().poll(cx) {
            core::task::Poll::Ready(_) => core::task::Poll::Ready(()),
            core::task::Poll::Pending => {
                cx.waker().wake_by_ref();
                driver.advance(Duration::from_secs(2));

                core::task::Poll::Pending
            }
        })
        .await;
    }

    fn generate_noisy_signal<
        I: SliceIndex<[u16], Output = [u16]> + RangeBounds<usize>,
        S: RangeBounds<i16> + SampleRange<i16> + Clone,
    >(
        samples: &mut [u16],
        amplitude: S,
        range: I,
    ) {
        let mut noise = wyrand::WyRand::new(141);

        let samples = samples
            .get_mut(range)
            .expect("Range to be sized the same or smaller than the slice");

        for sample in samples.iter_mut() {
            *sample = ((*sample as i16) - noise.random_range(amplitude.clone())) as u16;
        }
    }

    fn generate_drop_signal(samples: &mut [u16]) {
        // Example voltage drop signal
        samples[5] -= 60;
        samples[6] -= 55;
        samples[7] -= 50;
        samples[8] -= 45;
        samples[9] -= 40;
        samples[10] -= 35;
        samples[11] -= 30;
        samples[12] -= 28;
        samples[13] -= 26;
        samples[14] -= 24;
        samples[15] -= 22;
        samples[16] -= 20;
        samples[17] -= 18;
        samples[18] -= 16;
        samples[19] -= 14;
        samples[20] -= 12;
        samples[21] -= 11;
        samples[22] -= 10;
        samples[23] -= 9;
        samples[24] -= 8;
        samples[25] -= 7;
        samples[26] -= 6;
        samples[27] -= 5;
        samples[28] -= 4;
        samples[29] -= 3;
        samples[30] -= 2;
        samples[31] -= 1;
    }

    #[pollster::test]
    async fn tuning_cycle_completes() {
        let driver = embassy_time::MockDriver::get();
        driver.reset();
        let device = MockMachine::default();
        let pwm = MockPwm(&device);
        let adc = MockAdc(&device);

        let mut detector = DetectorDriver::new(Default::default(), MockTimeSource, pwm, adc);
        let mut buf = [0; 16];

        tune_detector_manually(&mut detector, &mut buf, driver).await;

        assert_eq!(detector.state.max_duty.get(), 108);
        assert_eq!(detector.state.duty.get(), 90);
        assert_eq!(detector.adc.sample_average(&mut buf).await, 1260);
    }

    #[pollster::test]
    async fn tick_updates_only_on_raised_levels() {
        let driver = embassy_time::MockDriver::get();
        driver.reset();
        let device = MockMachine::default();
        let pwm = MockPwm(&device);
        let adc = MockAdc(&device);

        let detector = DetectorDriver::new(Default::default(), MockTimeSource, pwm, adc);

        detector.state.max_duty.set(98);
        detector.state.duty.set(64);
        detector.state.avg.set(896);

        {
            let mut tick = core::pin::pin!(detector.tick(|a| {
                assert_eq!(
                    a,
                    DetectorUpdate::Tick {
                        timestamp: 0,
                        level: 300
                    }
                );
            }));

            poll_fn(|cx| match tick.as_mut().poll(cx) {
                core::task::Poll::Ready(_) => core::task::Poll::Ready(()),
                core::task::Poll::Pending => {
                    if detector.state.warn_level.get() > 255 {
                        return core::task::Poll::Ready(());
                    }
                    detector.state.strikes.set(300);
                    driver.advance(Duration::from_secs(1));
                    cx.waker().wake_by_ref();
                    core::task::Poll::Pending
                }
            })
            .await;
        }

        assert_eq!(detector.state.warn_level.get(), 553);
    }

    #[pollster::test]
    async fn detection_updates_only_on_large_enough_signals() {
        let driver = embassy_time::MockDriver::get();
        driver.reset();
        let device = MockMachine::default();
        let pwm = MockPwm(&device);
        let adc = MockAdc(&device);

        let detector = DetectorDriver::new(Default::default(), MockTimeSource, pwm, adc);
        detector.pwm.0.pwm.set(64);
        detector.state.max_duty.set(98);
        detector.state.duty.set(64);
        detector.state.avg.set(896);

        let mut samples = alloc::vec![0; BLOCK_SIZE];

        detector.adc.sample(&mut samples).await;

        samples[5] -= 3;
        samples[6] -= 1;

        let mut peaks = alloc::vec::Vec::with_capacity(512);

        detector.detect_from_sample(0, &samples, &mut peaks, |_| {
            panic!("This update function shouldn't be called");
        });

        assert_eq!(peaks.len(), 0);

        generate_drop_signal(&mut samples);

        let expected_peaks = alloc::vec![(0, 25), (8, 21)];
        let called = Cell::new(false);

        detector.detect_from_sample(0, &samples, &mut peaks, |update: DetectorUpdate<'_>| {
            called.set(true);
            assert_eq!(
                update,
                DetectorUpdate::Detection {
                    timestamp: 0,
                    average: detector.state.avg.get(),
                    samples: &samples,
                    peaks: expected_peaks.as_slice()
                }
            )
        });

        assert_eq!(peaks.len(), 2);
        assert!(called.get());

        called.set(false);

        let mut samples = alloc::vec![0; BLOCK_SIZE];
        let expected_peaks = alloc::vec![(16, 15), (24, 19), (32, 18)];

        detector.adc.sample(&mut samples).await;

        // Big noisy signal
        generate_noisy_signal(&mut samples, -40..=40, 20..55);

        detector.detect_from_sample(0, &samples, &mut peaks, |update| {
            called.set(true);
            assert_eq!(
                update,
                DetectorUpdate::Detection {
                    timestamp: 0,
                    average: detector.state.avg.get(),
                    samples: &samples,
                    peaks: expected_peaks.as_slice()
                }
            )
        });

        assert!(called.get());
        assert_eq!(peaks.len(), 3);

        detector.adc.sample(&mut samples).await;

        // Smaller noisy signal
        generate_noisy_signal(&mut samples, -15..=15, 10..75);

        detector.detect_from_sample(0, &samples, &mut peaks, |_| {
            panic!("This update function shouldn't be called");
        });

        assert_eq!(peaks.len(), 0);
    }

    #[pollster::test]
    async fn detection_sensitivity_can_be_configured() {
        let driver = embassy_time::MockDriver::get();
        driver.reset();
        let device = MockMachine::default();
        let pwm = MockPwm(&device);
        let adc = MockAdc(&device);

        let detector = DetectorDriver::new(Default::default(), MockTimeSource, pwm, adc);
        detector.pwm.0.pwm.set(64);
        detector.state.max_duty.set(98);
        detector.state.duty.set(64);
        detector.state.avg.set(896);

        let mut samples = alloc::vec![0; BLOCK_SIZE];
        let mut peaks = alloc::vec::Vec::with_capacity(BLOCK_SIZE);

        // Require bigger size blips.
        detector.config.blip_size.set(3);

        detector.adc.sample(&mut samples).await;
        generate_drop_signal(&mut samples);

        detector.detect_from_sample(0, &samples, &mut peaks, |_update| {
            panic!("Update shouldn't be called");
        });

        assert_eq!(peaks.len(), 2);

        // Require bigger threshold for blip detection
        detector.config.blip_size.set(2);
        detector.config.blip_threshold.set(24);

        detector.detect_from_sample(0, &samples, &mut peaks, |_update| {
            panic!("Update shouldn't be called");
        });

        // Update didn't call because detected blip wasn't big enough
        assert_eq!(peaks.len(), 1);
    }
}