use crate::db::{Controller, Relay, Schedule};
use futures::executor;
use serde::Serialize;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;
use crate::db::types::ControllerUid;

#[derive(Debug, Serialize)]
pub struct ReturnSchedule {
	#[serde(flatten)]
	pub schedule: Schedule,
	pub tags: Vec<String>,
}

impl ReturnSchedule {
	pub fn from_schedule(schedule: Schedule, conn: &mut PoolConnection<Sqlite>) -> Self {
		let schedule = schedule.clone();
		let tags = executor::block_on(schedule.get_tags(conn)).unwrap();

		ReturnSchedule {
			schedule,
			tags,
		}
	}

	pub fn from_schedule_ref(schedule: &Schedule, conn: &mut PoolConnection<Sqlite>) -> Self {
		Self::from_schedule(schedule.clone(), conn)
	}
}

#[derive(Debug, Serialize)]
pub struct ReturnRelay {
	#[serde(flatten)]
	pub relay: Relay,
	pub controller: Controller,
	pub controller_id: ControllerUid,
	pub tags: Vec<String>,
}

impl ReturnRelay {
	pub fn from_relay(relay: Relay, conn: &mut PoolConnection<Sqlite>) -> Self {
		let relay = relay.clone();
		let controller = executor::block_on(Controller::get(conn, relay.controller_id)).unwrap();
		let controller_uid = controller.uid.clone();
		let tags = executor::block_on(relay.get_tags(conn)).unwrap();

		ReturnRelay {
			relay,
			controller,
			controller_id: controller_uid,
			tags,
		}
	}

	pub fn from_relay_ref(relay: &Relay, conn: &mut PoolConnection<Sqlite>) -> Self {
		Self::from_relay(relay.clone(), conn)
	}
}