#![no_std]
#![no_main]

use core::panic::PanicInfo;

use embassy_executor::Spawner;
use embassy_futures::join::join;
use embassy_rp::{
    bind_interrupts,
    gpio::{Level, Output},
    peripherals::{PIN_15, PIO0},
    pio::{InterruptHandler, Pio},
};
use embassy_time::Timer;

use dht_pio::{Dht22Type2, DhtError};
use embassy_serial;

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    loop {
        unsafe {
            PANIC_LED.as_mut().unwrap().set_high();
        }
    }
}

static mut PANIC_LED: Option<Output<'static, PIN_15>> = None;

bind_interrupts!(struct Irqs {
    PIO0_IRQ_0 => InterruptHandler<PIO0>;
});

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    let p = embassy_rp::init(Default::default());

    unsafe {
        PANIC_LED = Some(Output::new(p.PIN_15, Level::Low));
    }

    // debug: serial port
    let (mut serial, usb_future) =
        embassy_serial::Serial::new(p.USB, embassy_serial::SerialConfig::new());

    // pio access
    let pio = p.PIO0;
    let Pio {
        mut common,

        // dht22 state machine
        sm1,
        ..
    } = Pio::new(pio, Irqs);

    // create DHT22
    let mut dht = Dht22Type2::new(&mut common, sm1, p.PIN_0);

    let dht_reading = async {
        loop {
            match dht.read().await {
                Ok(reading) => {
                    serial.send_msg("temp:\n").await.unwrap();
                    serial
                        .send_number(reading.temperature as u32, 10)
                        .await
                        .unwrap();
                    serial.send_msg("humid:\n").await.unwrap();
                    serial
                        .send_number(reading.humidity as u32, 10)
                        .await
                        .unwrap();
                }
                Err(err) => serial
                    .send_msg(match err {
                        DhtError::Timeout => "dht timeout error\n\r",
                        DhtError::CrcMismatch(_, _) => "dht checksum error\n\r",
                        DhtError::ReadError => "dht read error\n\r",
                    })
                    .await
                    .unwrap(),
            }

            Timer::after_secs(3).await;
        }
    };

    join(usb_future, dht_reading).await;
}