#![no_std]
#![no_main]
#![macro_use]
#![feature(type_alias_impl_trait)]
// #![feature(async_fn_in_trait)]

use embassy_executor::{Executor, _export::StaticCell};
use esp_println::{logger::init_logger, println};
use esp_wifi::{initialize, EspWifiInitFor};
use hal::clock::{ClockControl, CpuClock};
use hal::{embassy, peripherals::Peripherals, timer::TimerGroup, Rng};
use hal::{prelude::*, Rtc};

use esp_backtrace as _;

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

mod util;

#[entry]
fn main() -> ! {
    init_logger(log::LevelFilter::Info);
    // tracing_subscriber::fmt::init();

    let peripherals = Peripherals::take();

    let system = system!(peripherals);
    let mut peripheral_clock_control = system.peripheral_clock_control;
    let clocks = clocks!(system);
    rtc!(peripherals);

    let timer = timer!(peripherals, clocks, peripheral_clock_control);
    let init = initialize(
        EspWifiInitFor::Wifi,
        timer,
        Rng::new(peripherals.RNG),
        system.radio_clock_control,
        &clocks,
    )
    .unwrap();

    let wifi = get_wifi!(peripherals);
    // let esp_now = esp_wifi::esp_now::EspNow::new(&init, wifi).unwrap();
    // println!("esp-now version {}", esp_now.get_version().unwrap());

    let timer_group0 = TimerGroup::new(peripherals.TIMG0, &clocks, &mut peripheral_clock_control);
    embassy::init(&clocks, timer_group0.timer0);
    let executor = EXECUTOR.init(Executor::new());
    executor.run(|spawner| {
        // spawner.spawn(run(esp_now)).ok();
    })
}