use molybdos::reexport::*;

use embassy_rp::{
    adc,
    adc::Adc,
    gpio::{
        Level,
        Output,
        Pin,
    },
    peripherals::{
        SPI0,
        SPI1,
        USB,
    },
    spi,
    spi::{
        Async,
        Spi,
    },
    watchdog::Watchdog,
};
use embassy_sync::{
    blocking_mutex::raw::{
        CriticalSectionRawMutex,
        RawMutex,
    },
    mutex::Mutex,
};
use static_cell::StaticCell;
use tap::Pipe;

use molybdos::pal::StaticOutput;

embassy_rp::bind_interrupts! {
    struct Irqs {
        USBCTRL_IRQ => embassy_rp::usb::InterruptHandler<USB>;
        ADC_IRQ_FIFO => adc::InterruptHandler;
    }
}

static BME_SPI: StaticCell<Mutex<CriticalSectionRawMutex, Spi<SPI1, Async>>> = StaticCell::new();
static SD_SPI: StaticCell<Mutex<CriticalSectionRawMutex, Spi<SPI0, Async>>> = StaticCell::new();
static ADC: StaticCell<Mutex<CriticalSectionRawMutex, Adc<adc::Async>>> = StaticCell::new();

pub struct Split<BmeSpi, BmeSpiMutex, SdSpi, SdSpiMutex>
where
    SdSpiMutex: RawMutex + 'static,
    SdSpi: 'static,
    BmeSpiMutex: RawMutex + 'static,
    BmeSpi: 'static,
{
    pub sd_spi:  &'static Mutex<SdSpiMutex, SdSpi>,
    pub sd_cs:   StaticOutput,
    pub bme_spi: &'static Mutex<BmeSpiMutex, BmeSpi>,
    pub bme_cs:  StaticOutput,
    pub wdt:     Watchdog,
    pub usb:     molybdos::pal::UsbDriver,

    pub adc: &'static Mutex<CriticalSectionRawMutex, Adc<'static, adc::Async>>,
    // pub leds: [StaticOutput; crate::N_LED],
}

pub fn split(
    config: embassy_rp::config::Config,
) -> Split<crate::BMESpi, CriticalSectionRawMutex, crate::SdSpi, CriticalSectionRawMutex> {
    let periphs = embassy_rp::init(config);

    let wdt = Watchdog::new(periphs.WATCHDOG);

    let bme_cs = periphs.PIN_5.degrade().pipe(|cs| Output::new(cs, Level::High));
    let bme_spi = {
        let sck = periphs.PIN_10;
        let mosi = periphs.PIN_11;
        let miso = periphs.PIN_8;

        let mut conf = spi::Config::default();
        conf.frequency = 1_000_000;

        let bme_spi =
            Spi::new(periphs.SPI1, sck, mosi, miso, periphs.DMA_CH0, periphs.DMA_CH1, conf)
                .pipe(Mutex::<CriticalSectionRawMutex, _>::new);
        BME_SPI.init(bme_spi)
    };

    let sd_cs = periphs.PIN_9.degrade().pipe(|cs| Output::new(cs, Level::High));
    let sd_spi = {
        let mosi = periphs.PIN_19;
        let sck = periphs.PIN_18;
        let miso = periphs.PIN_20;

        let mut conf = spi::Config::default();
        conf.frequency = 16_000_000;

        let sd_spi =
            Spi::new(periphs.SPI0, sck, mosi, miso, periphs.DMA_CH3, periphs.DMA_CH4, conf)
                .pipe(Mutex::new);

        SD_SPI.init(sd_spi)
    };

    let usb_driver = embassy_rp::usb::Driver::new(periphs.USB, Irqs);

    let adc = Adc::new(periphs.ADC, Irqs, adc::Config::default());

    let adc = ADC.init(Mutex::new(adc));

    Split {
        sd_spi,
        sd_cs,
        bme_spi,
        bme_cs,
        wdt,
        usb: usb_driver,

        adc,
    }
}