#![feature(allocator_api)]
#![allow(unexpected_cfgs)]
#![no_std]
#![no_main]

mod allocator;
mod detector;
mod errors;
mod locks;
mod net;
#[cfg(not(feature = "defmt"))]
mod panic_handler;
mod rpc;
mod rtc;
mod state;
mod updates;
mod utils;
mod wifi;

use crate::{allocator::PicoHeap, rtc::GlobalRtc};
use cyw43_pio::{DEFAULT_CLOCK_DIVIDER, PioSpi};
use embassy_executor::Executor;
use embassy_rp::{
    adc as rp_adc, bind_interrupts,
    clocks::RoscRng,
    gpio::{Level, Output},
    multicore::{Stack, spawn_core1},
    peripherals::PIO0,
    pio::{InterruptHandler, Pio},
    rtc::{self as rp_rtc, Rtc},
};
use sachy_fmt::*;
use static_cell::{ConstStaticCell, StaticCell};

extern crate alloc;

#[cfg(feature = "defmt")]
use {defmt_rtt as _, panic_probe as _};

mod constants {
    include!(concat!(env!("OUT_DIR"), "/constants.rs"));
}

use constants::HEAP_SIZE;

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

bind_interrupts!(struct Irqs {
    ADC_IRQ_FIFO => rp_adc::InterruptHandler;
    PIO0_IRQ_0 => InterruptHandler<PIO0>;
    RTC_IRQ => rp_rtc::InterruptHandler, rtc::GlobalRtcHandler;
});

#[unsafe(no_mangle)]
unsafe extern "Rust" fn __getrandom_v03_custom(
    dest: *mut u8,
    len: usize,
) -> Result<(), getrandom::Error> {
    let slice = unsafe {
        // Initialise the buffer with zeros before transmuting it into
        // a mutable slice
        core::ptr::write_bytes(dest, 0, len);
        core::slice::from_raw_parts_mut(dest, len)
     };

    RoscRng.fill_bytes(slice);

    Ok(())
}

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

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

    info!("Initialising drivers");
    let pwm = embassy_strike_driver::drivers::rp::PwmDriver::new(p.PWM_SLICE5, p.PIN_27);
    let adc = embassy_strike_driver::drivers::rp::AdcDriver::new(p.ADC, p.PIN_26, p.DMA_CH1, Irqs);

    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,
        p.DMA_CH0,
    );

    info!("Initialising RTC");
    let rtc = GlobalRtc::init(Rtc::new(p.RTC, Irqs));

    static CORE1_STACK: ConstStaticCell<Stack<8192>> = ConstStaticCell::new(Stack::new());

    info!("Initialising executors for multi-core tasks");
    spawn_core1(p.CORE1, CORE1_STACK.take(), move || {
        static EXECUTOR1: StaticCell<Executor> = StaticCell::new();

        EXECUTOR1.init_with(Executor::new).run(|spawner| {
            info!("Spawning Detector task on Core 1");
            spawner.must_spawn(detector::detector_task(adc, pwm, rtc));
        })
    });

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

    EXECUTOR0.init_with(Executor::new).run(|spawner| {
        info!("Spawning Network tasks on Core 0");
        spawner.must_spawn(wifi::main_loop(spawner, rtc, spi, pwr));
    });
}