controller/emgauwa-controller/src/relay_loop.rs

use std::time::Duration;

use actix::Addr;
use chrono::{Local, Timelike};
use emgauwa_lib::constants::RELAYS_RETRY_TIMEOUT;
use emgauwa_lib::errors::EmgauwaError;
use emgauwa_lib::models::Controller;
use emgauwa_lib::types::{RelayStates, Weekday};
use emgauwa_lib::utils::printable_relay_states;
use futures::pin_mut;
use tokio::time;
use tokio::time::timeout;
use utils::app_state_get_controller_notifier;

use crate::app_state::AppState;
use crate::utils;

pub async fn run_relays_loop(app_state: Addr<AppState>) {
	log::debug!("Spawned relays loop");
	loop {
		let run_result = run_relays(&app_state).await;
		if let Err(err) = run_result {
			log::error!("Error running relays: {}", err);
		}
		time::sleep(RELAYS_RETRY_TIMEOUT).await;
	}
}

async fn run_relays(app_state: &Addr<AppState>) -> Result<(), EmgauwaError> {
	let notifier = &*app_state_get_controller_notifier(app_state).await?;

	let mut last_weekday = emgauwa_lib::utils::get_weekday();
	let mut this = utils::app_state_get_this(app_state).await?;
	let mut relay_states: RelayStates = Vec::new();
	init_relay_states(&mut relay_states, &this);
	calc_relay_states(&mut relay_states, &mut this, app_state).await?;

	loop {
		log::debug!(
			"Relay loop at {}: {}",
			Local::now().naive_local().time(),
			printable_relay_states(&this.get_relay_states())
		);

		let notifier_future = notifier.notified();
		pin_mut!(notifier_future);
		let mut changed = timeout(get_next_duration(&this), &mut notifier_future)
			.await
			.is_ok();

		check_weekday(app_state, &mut last_weekday, &mut changed).await?;

		if changed {
			log::debug!("Reloading controller in relay loop");
			this = utils::app_state_get_this(app_state).await?;
		}

		calc_relay_states(&mut relay_states, &mut this, app_state).await?;
	}
}

fn init_relay_states(relay_states: &mut RelayStates, this: &Controller) {
	relay_states.clear();
	for _ in 0..this.c.relay_count {
		relay_states.push(None);
	}
}

async fn calc_relay_states(
	relay_states: &mut RelayStates,
	this: &mut Controller,
	app_state: &Addr<AppState>,
) -> Result<(), EmgauwaError> {
	let now = Local::now().time();

	this.relays
		.iter_mut()
		.zip(relay_states.iter_mut())
		.for_each(|(relay, state)| {
			relay.is_on = Some(relay.active_schedule.is_on(&now));
			*state = relay.is_on;
		});
	utils::app_state_update_relays_on(app_state, relay_states.clone()).await
}

fn get_next_duration(this: &Controller) -> Duration {
	let now = Local::now().time();
	let now_in_s = now.num_seconds_from_midnight();
	let next_timestamp = this
		.get_next_time(&now)
		.map_or(86400, |t| t.num_seconds_from_midnight());

	let duration_to_next = Duration::from_secs((next_timestamp - now_in_s) as u64);

	log::debug!(
		"Next timestamp: {}; Waiting for {}s",
		next_timestamp,
		duration_to_next.as_secs()
	);

	duration_to_next
}

async fn check_weekday(
	app_state: &Addr<AppState>,
	last_weekday: &mut Weekday,
	changed: &mut bool,
) -> Result<(), EmgauwaError> {
	let current_weekday = emgauwa_lib::utils::get_weekday();
	if current_weekday.ne(last_weekday) {
		log::debug!("Weekday changed");
		*last_weekday = current_weekday;
		utils::app_state_reload(app_state).await?;
		*changed = true;
	}

	Ok(())
}