use futures::executor::block_on;
use serde_derive::{Deserialize, Serialize};
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;

use crate::db::{DbJunctionRelaySchedule, DbMacroAction};
use crate::errors::{DatabaseError, EmgauwaError};
use crate::models::{FromDbModel, Relay, Schedule};

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct MacroAction {
	pub schedule: Schedule,
	pub relay: Relay,
	pub weekday: i64,
}


impl FromDbModel for MacroAction {
	type DbModel = DbMacroAction;
	type DbModelCache = ();

	fn from_db_model(
		conn: &mut PoolConnection<Sqlite>,
		db_model: Self::DbModel,
	) -> Result<Self, DatabaseError> {
		Self::from_db_model_cache(conn, db_model, ())
	}

	fn from_db_model_cache(
		conn: &mut PoolConnection<Sqlite>,
		db_model: Self::DbModel,
		_cache: Self::DbModelCache,
	) -> Result<Self, DatabaseError> {
		let schedule_db = block_on(db_model.get_schedule(conn))?;
		let schedule = Schedule::from_db_model(conn, schedule_db)?;

		let relay_db = block_on(db_model.get_relay(conn))?;
		let relay = Relay::from_db_model(conn, relay_db)?;

		let weekday = db_model.weekday;

		Ok(MacroAction {
			schedule,
			relay,
			weekday,
		})
	}
}

impl MacroAction {
	pub async fn execute(&self, conn: &mut PoolConnection<Sqlite>) -> Result<(), EmgauwaError> {
		DbJunctionRelaySchedule::set_schedule(conn, &self.relay.r, &self.schedule.s, self.weekday)
			.await?;
		Ok(())
	}
}