#![no_main]
#![no_std]

extern crate alloc;

use az::*;
use core::cell::RefCell;
use cortex_m::delay::Delay;
use embedded_alloc::Heap;
use embedded_hal::{blocking::spi::Write, digital::v2::OutputPin};
use fixed::types::I16F16;
use fugit::RateExtU32;
use lights_core::{
    BodyPattern, DashboardPattern, Event, TRANS_PRIDE_BODY, TRANS_PRIDE_DASHBOARD, UI,
};
use panic_halt as _;
use rp_pico::{
    entry,
    hal::{
        clocks::init_clocks_and_plls,
        pac::{CorePeripherals, Peripherals},
        spi::{Enabled, Spi, SpiDevice, ValidSpiPinout},
        watchdog::Watchdog,
        Clock, Sio,
    },
    Pins,
};

#[global_allocator]
static HEAP: Heap = Heap::empty();

const LIGHT_SCALE: I16F16 = I16F16::lit("256.0");
const GLOBAL_BRIGHTESS: u8 = 1;

struct BikeUI<D: SpiDevice, P: ValidSpiPinout<D>> {
    spi: RefCell<Spi<Enabled, D, P, 8>>,
}

impl<D: SpiDevice, P: ValidSpiPinout<D>> BikeUI<D, P> {
    fn new(spi: Spi<Enabled, D, P, 8>) -> Self {
        Self {
            spi: RefCell::new(spi),
        }
    }
}

impl<D: SpiDevice, P: ValidSpiPinout<D>> UI for BikeUI<D, P> {
    fn check_event(&self) -> Option<Event> {
        None
    }

    fn update_lights(&self, dashboard_lights: DashboardPattern, body_lights: BodyPattern) {
        let mut lights: [u8; 20] = [0; 20];
        lights[16] = 0xff;
        lights[17] = 0xff;
        lights[18] = 0xff;
        lights[19] = 0xff;
        for (idx, rgb) in dashboard_lights.iter().enumerate() {
            lights[(idx + 1) * 4 + 0] = 0xe0 + GLOBAL_BRIGHTESS;
            lights[(idx + 1) * 4 + 1] = (I16F16::from(rgb.r) * LIGHT_SCALE).saturating_as();
            lights[(idx + 1) * 4 + 2] = (I16F16::from(rgb.b) * LIGHT_SCALE).saturating_as();
            lights[(idx + 1) * 4 + 3] = (I16F16::from(rgb.g) * LIGHT_SCALE).saturating_as();
        }
        let mut spi = self.spi.borrow_mut();
        spi.write(lights.as_slice());
    }
}

#[entry]
fn main() -> ! {
    {
        use core::mem::MaybeUninit;
        const HEAP_SIZE: usize = 8096;
        static mut HEAP_MEM: [MaybeUninit<u8>; HEAP_SIZE] = [MaybeUninit::uninit(); HEAP_SIZE];
        unsafe { HEAP.init(HEAP_MEM.as_ptr() as usize, HEAP_SIZE) }
    }

    let mut pac = Peripherals::take().unwrap();
    let core = CorePeripherals::take().unwrap();
    let sio = Sio::new(pac.SIO);
    let mut watchdog = Watchdog::new(pac.WATCHDOG);

    let pins = Pins::new(
        pac.IO_BANK0,
        pac.PADS_BANK0,
        sio.gpio_bank0,
        &mut pac.RESETS,
    );

    let clocks = init_clocks_and_plls(
        12_000_000u32,
        pac.XOSC,
        pac.CLOCKS,
        pac.PLL_SYS,
        pac.PLL_USB,
        &mut pac.RESETS,
        &mut watchdog,
    )
    .ok()
    .unwrap();

    let mut delay = Delay::new(core.SYST, clocks.system_clock.freq().to_Hz());
    let mut spi_clk = pins.gpio10.into_function();
    let mut spi_sdo = pins.gpio11.into_function();
    let spi = Spi::<_, _, _, 8>::new(pac.SPI1, (spi_sdo, spi_clk));
    let mut spi = spi.init(
        &mut pac.RESETS,
        clocks.peripheral_clock.freq(),
        1_u32.MHz(),
        embedded_hal::spi::MODE_1,
    );

    let ui = BikeUI::new(spi);

    // let app = App::new(Box::new(ui));
    // app.tick(TRANS_PRIDE_DASHBOARD, TRANS_PRIDE_BODY);
    ui.update_lights(TRANS_PRIDE_DASHBOARD, TRANS_PRIDE_BODY);

    /*
    spi.write(&[
        0, 0, 0, 0, 0xe1, 0x80, 0x00, 0x00, 0xe1, 0x00, 0x80, 0x00, 0xe1, 0x00, 0x00, 0x80, 0xff,
        0xff, 0xff, 0xff,
    ]);
    */

    let mut led_pin = pins.led.into_push_pull_output();

    loop {
        led_pin.set_high().unwrap();
        delay.delay_ms(500);
        led_pin.set_low().unwrap();
        delay.delay_ms(500);
    }
}