#![no_std]
#![no_main]

use core::{cell::Cell, time::Duration};

use chrono::{DurationRound, NaiveDateTime, TimeDelta};
use display_interface_spi::SPIInterface;
use embedded_hal_bus::spi::ExclusiveDevice;
use esp_backtrace as _;
use esp_hal::{
	delay::Delay,
	gpio::{Input, Level, Output, Pull},
	main,
	reset::reset_reason,
	rtc_cntl::{
		sleep::{RtcSleepConfig, TimerWakeupSource},
		Rtc,
	},
	spi::master::{Config, Spi},
	time::RateExtU32,
};
use render::{render_digit, render_time};
use weact_studio_epd::{
	graphics::{buffer_len, Display, Display213BlackWhite, DisplayRotation},
	Color, WeActStudio213BlackWhiteDriver,
};

mod render;

#[main]
fn main() -> ! {
	let peripherals = esp_hal::init(Default::default());
	let delay = Delay::new();

	let mut rtc = Rtc::new(peripherals.LPWR);
	let mut cfg = RtcSleepConfig::deep();
	cfg.set_rtc_fastmem_pd_en(false);

	let mut led = Output::new(peripherals.GPIO8, Level::Low);
	led.set_low();

	// check wakeup

	let woken_up: bool = match reset_reason() {
		Some(r) => match r {
			esp_hal::rtc_cntl::SocResetReason::CoreDeepSleep => true,
			_ => false,
		},
		None => false,
	};
	// let wakeup_src = wakeup_cause();

	// setup display

	let spi_bus = Spi::new(
		peripherals.SPI2,
		Config::default().with_frequency(100_u32.kHz()),
	)
	.unwrap()
	.with_sck(peripherals.GPIO4)
	.with_mosi(peripherals.GPIO6);

	let mut driver = WeActStudio213BlackWhiteDriver::new(
		SPIInterface::new(
			ExclusiveDevice::new(spi_bus, Output::new(peripherals.GPIO7, Level::High), delay)
				.unwrap(),
			Output::new(peripherals.GPIO9, Level::High),
		),
		Input::new(peripherals.GPIO21, Pull::Up),
		Output::new(peripherals.GPIO20, Level::High),
		delay,
	);

	let mut display = Display213BlackWhite::new();
	display.set_rotation(DisplayRotation::Rotate90);

	let mut digit: DigitDisplay = DigitDisplay::new();

	// get data

	// init driver?

	if woken_up {
		driver.wake_up().unwrap();
	} else {
		rtc.set_current_time(NaiveDateTime::UNIX_EPOCH);
		driver.init().unwrap();
	}

	// (re)render time

	let mut render_count: u8 = critical_section::with(|cs| RENDER_COUNT.borrow(cs).get());

	if woken_up && render_count < 10 {
		render_count += 1;

		// now check what digits to render

		render_digit(Point::zero, 16, num, target)

	} else {
		render_count = 0;

		render_time(&rtc.current_time().time(), &mut display);
		driver.full_update(&display).unwrap();
	}

	critical_section::with(|cs| RENDER_COUNT.borrow(cs).set(render_count));

	// prepare for sleep

	driver.sleep().unwrap();

	let refresh_offset: usize = 60;

	let time = rtc
		.current_time()
		.duration_trunc(TimeDelta::try_seconds(refresh_offset as i64).unwrap())
		.unwrap();

	let wakeup_source = TimerWakeupSource::new(Duration::from_micros(
		(time + Duration::from_secs(refresh_offset as u64))
			.signed_duration_since(rtc.current_time())
			.num_microseconds()
			.unwrap_or_default() as u64,
	));

	led.set_high();

	// sleep

	rtc.sleep_deep(&[&wakeup_source]);
}