#![no_std]
#![no_main]
#[path = "../common.rs"]
mod common;

use common::*;
use defmt::{assert, assert_eq, unreachable};
use embassy_executor::Spawner;
use embassy_stm32::mode::Blocking;
use embassy_stm32::usart::{Config, ConfigError, Error, Uart};
use embassy_time::{Duration, Instant, block_for};

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    let p = init();
    info!("Hello World!");

    // Arduino pins D0 and D1
    // They're connected together with a 1K resistor.
    let mut usart = peri!(p, UART);
    let mut rx = peri!(p, UART_RX);
    let mut tx = peri!(p, UART_TX);

    {
        let config = Config::default();
        let mut usart = Uart::new_blocking(usart.reborrow(), rx.reborrow(), tx.reborrow(), config).unwrap();

        let test_usart = async |usart: &mut Uart<'_, Blocking>| -> Result<(), Error> {
            // We can't send too many bytes, they have to fit in the FIFO.
            // This is because we aren't sending+receiving at the same time.

            let data = [0xC0, 0xDE];
            usart.blocking_write(&data)?;

            let mut buf = [0; 2];
            usart.blocking_read(&mut buf)?;
            assert_eq!(buf, data);

            // Test flush doesn't hang.
            usart.blocking_write(&data)?;
            usart.blocking_flush()?;

            // Test flush doesn't hang if there's nothing to flush
            usart.blocking_flush()?;

            Ok(())
        };

        let mut is_ok = false;
        for _ in 0..3 {
            match test_usart(&mut usart).await {
                Ok(()) => is_ok = true,
                Err(Error::Noise) => is_ok = false,
                Err(e) => defmt::panic!("{}", e),
            }

            if is_ok {
                break;
            }
        }

        assert!(is_ok);
    }

    // Test error handling with with an overflow error
    {
        let config = Config::default();
        let mut usart = Uart::new_blocking(usart.reborrow(), rx.reborrow(), tx.reborrow(), config).unwrap();

        // Send enough bytes to fill the RX FIFOs off all USART versions.
        let data = [0; 64];
        usart.blocking_write(&data).unwrap();
        usart.blocking_flush().unwrap();

        // USART can still take up to 1 bit time (?) to receive the last byte
        // that we just flushed, so wait a bit.
        // otherwise, we might clear the overrun flag from an *earlier* byte and
        // it gets set again when receiving the last byte is done.
        block_for(Duration::from_millis(1));

        // The error should be reported first.
        let mut buf = [0; 1];
        let err = usart.blocking_read(&mut buf);
        assert_eq!(err, Err(Error::Overrun));

        // At least the first data byte should still be available on all USART versions.
        usart.blocking_read(&mut buf).unwrap();
        assert_eq!(buf[0], data[0]);
    }

    // Test that baudrate divider is calculated correctly.
    // Do it by comparing the time it takes to send a known number of bytes.
    for baudrate in [300, 9600, 115200, 250_000, 337_934, 1_000_000, 2_000_000] {
        info!("testing baudrate {}", baudrate);

        let mut config = Config::default();
        config.baudrate = baudrate;
        let mut usart = match Uart::new_blocking(usart.reborrow(), rx.reborrow(), tx.reborrow(), config) {
            Ok(x) => x,
            Err(ConfigError::BaudrateTooHigh) => {
                info!("baudrate too high");
                assert!(baudrate >= 1_000_000);
                continue;
            }
            Err(ConfigError::BaudrateTooLow) => {
                info!("baudrate too low");
                assert!(baudrate <= 300);
                continue;
            }
            Err(_) => unreachable!(),
        };

        let n = (baudrate as usize / 100).max(64);

        let start = Instant::now();
        for _ in 0..n {
            usart.blocking_write(&[0x00]).unwrap();
        }
        usart.blocking_flush().unwrap();
        let dur = Instant::now() - start;
        let want_dur = Duration::from_micros(n as u64 * 10 * 1_000_000 / (baudrate as u64));
        let fuzz = want_dur / 5;
        if dur < want_dur - fuzz || dur > want_dur + fuzz {
            defmt::panic!(
                "bad duration for baudrate {}: got {:?} want {:?}",
                baudrate,
                dur,
                want_dur
            );
        }
    }

    info!("Test OK");
    cortex_m::asm::bkpt();
}
