// src/bin/main.rs
#![no_std]
#![no_main]

use defmt::*;
use embassy_executor::Spawner;
use embassy_futures::yield_now;
use embassy_stm32::bind_interrupts;
use embassy_stm32::peripherals;
use embassy_stm32::usart::{BufferedUart, Config, BufferedInterruptHandler};

use static_cell::StaticCell;
use dma_gpio::config::{
    BAUD, PIPE_HW_RX, PIPE_HW_TX,
};
use dma_gpio::hw_uart_pc::{driver::uart_task, usart1};
use {defmt_rtt as _, panic_probe as _};

bind_interrupts!(struct Irqs {
    USART1 => BufferedInterruptHandler<peripherals::USART1>;
});

unsafe extern "C" {
    fn HAL_Init();
    fn HAL_PWR_EnterSTANDBYMode();
    fn HAL_PWREx_EnterSHUTDOWNMode();
}

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    info!("boot");
    let p = embassy_stm32::init(Default::default());
    info!("init m8");

    // HARDWARE UART to the PC
    let mut cfg = Config::default();
    cfg.baudrate = BAUD;
    static TX_BUF: StaticCell<[u8; 256]> = StaticCell::new();
    static RX_BUF: StaticCell<[u8; 256]> = StaticCell::new();
    let uart = BufferedUart::new(
        p.USART1,
        p.PA10, // RX pin
        p.PA9,  // TX pin
        TX_BUF.init([0; 256]),
        RX_BUF.init([0; 256]),
        Irqs,
        cfg,
    ).unwrap();
    // let yield_period = usart1::setup_and_spawn(BAUD);
    spawner.spawn(uart_task(uart, &PIPE_HW_TX, &PIPE_HW_RX).unwrap());
    // END OF HARDWARE UART to the PC

    unsafe {
        HAL_Init();
        HAL_PWR_EnterSTANDBYMode();

        // Example 2 (unreachable if above executes): enter Shutdown
        // HAL_PWREx_EnterSHUTDOWNMode();
    }
    loop {
        info!("tick start");
        // Timer::after(Duration::from_millis(100)).await;
        // info!("tick end");


        yield_now().await;
    }
}