#![feature(allocator_api)]
#![feature(impl_trait_in_assoc_type)]
#![no_std]
#![no_main]

mod allocator;
mod ble;
mod client;
mod commands;
mod error;
mod locks;
mod packet_pool;
mod panic_handler;
mod timer;

extern crate alloc;

use crate::allocator::PicoHeap;
use cyw43_pio::{DEFAULT_CLOCK_DIVIDER, PioSpi};
use embassy_rp::{
    bind_interrupts, dma,
    executor::Executor,
    gpio::{Level, Output},
    peripherals::{DMA_CH0, PIO0},
    pio::{InterruptHandler, Pio},
};
use sachy_fmt::{info, unwrap};
use static_cell::StaticCell;

bind_interrupts!(struct Irqs {
    PIO0_IRQ_0 => InterruptHandler<PIO0>;
    DMA_IRQ_0 => dma::InterruptHandler<DMA_CH0>;
    POWMAN_IRQ_TIMER => embassy_rp::aon_timer::InterruptHandler;
});

const HEAP_SIZE: usize = 256 * 1024;

#[global_allocator]
static HEAP: PicoHeap<HEAP_SIZE> = PicoHeap::empty();

#[cortex_m_rt::entry]
fn main() -> ! {
    let p = embassy_rp::init(Default::default());

    info!("Welcome to Sachy Water!");
    info!("Initialising Heap, SIZE: {}", HEAP_SIZE);
    unwrap!(HEAP.init());

    let pwr = Output::new(p.PIN_23, Level::Low);
    let cs = Output::new(p.PIN_25, Level::High);
    let mut pio = Pio::new(p.PIO0, Irqs);
    let spi = PioSpi::new(
        &mut pio.common,
        pio.sm0,
        DEFAULT_CLOCK_DIVIDER,
        pio.irq0,
        cs,
        p.PIN_24,
        p.PIN_29,
        dma::Channel::new(p.DMA_CH0, Irqs),
    );

    static CORE0: StaticCell<Executor> = StaticCell::new();

    CORE0.init_with(Executor::new).run(|spawner| {
        spawner.spawn(unwrap!(ble::setup(spawner, pwr, spi)));
        spawner.spawn(unwrap!(timer::run(spawner, p.POWMAN)));
        spawner.spawn(unwrap!(commands::task(p.PIN_8)));
    });
}