use actix::Actor;
use emgauwa_common::db;
use emgauwa_common::db::{DbController, DbJunctionRelaySchedule, DbRelay, DbSchedule};
use emgauwa_common::errors::EmgauwaError;
use emgauwa_common::models::{Controller, FromDbModel};
use emgauwa_common::types::EmgauwaUid;
use emgauwa_common::utils::{drop_privileges, init_logging};
use rppal_pfd::PiFaceDigital;
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;

use crate::relay_loop::run_relays_loop;
use crate::settings::Settings;
use crate::ws::run_ws_loop;

mod app_state;
mod drivers;
mod relay_loop;
mod settings;
mod utils;
mod ws;
mod errors;

async fn create_this_controller(
	conn: &mut PoolConnection<Sqlite>,
	settings: &Settings,
) -> Result<DbController, EmgauwaError> {
	DbController::create(
		conn,
		&EmgauwaUid::default(),
		&settings.name,
		settings.relays.len() as i64,
	)
	.await
	.map_err(EmgauwaError::from)
}

async fn create_this_relay(
	conn: &mut PoolConnection<Sqlite>,
	this_controller: &DbController,
	settings_relay: &settings::Relay,
) -> Result<DbRelay, EmgauwaError> {
	let relay = DbRelay::create(
		conn,
		&settings_relay.name,
		settings_relay.number,
		this_controller,
	)
	.await?;

	let off = DbSchedule::get_off(conn).await?;
	for weekday in 0..7 {
		DbJunctionRelaySchedule::set_schedule(conn, &relay, &off, weekday).await?;
	}

	Ok(relay)
}

#[actix::main]
async fn main() -> Result<(), std::io::Error> {
	let settings = settings::init()?;

	drop_privileges(&settings.permissions)?;

	init_logging(&settings.logging.level)?;

	let pool = db::init(&settings.database)
		.await
		.map_err(EmgauwaError::from)?;

	let mut conn = pool.acquire().await.map_err(EmgauwaError::from)?;

	let db_controller = match DbController::get_all(&mut conn)
		.await
		.map_err(EmgauwaError::from)?
		.pop()
	{
		None => futures::executor::block_on(create_this_controller(&mut conn, &settings))?,
		Some(c) => c,
	};

	for relay in &settings.relays {
		if DbRelay::get_by_controller_and_num(
			&mut conn,
			&db_controller,
			relay.number,
		)
		.await
		.map_err(EmgauwaError::from)?
		.is_none()
		{
			create_this_relay(&mut conn, &db_controller, relay)
				.await
				.map_err(EmgauwaError::from)?;
		}
	}

	let db_controller = db_controller
		.update(&mut conn, &db_controller.name, settings.relays.len() as i64)
		.await
		.map_err(EmgauwaError::from)?;

	let this = Controller::from_db_model(&mut conn, db_controller).map_err(EmgauwaError::from)?;

	let now = chrono::Local::now().time();
	let initial_states: Vec<bool> = this.relays.iter().map(|r| r.active_schedule.is_on(&now)).collect();

	let mut pfd: Option<PiFaceDigital> = None;
	let drivers = settings.relays_make_drivers(&mut pfd, initial_states)?;

	let url = format!(
		"ws://{}:{}/api/v1/ws/controllers",
		settings.server.host, settings.server.port
	);

	let app_state = app_state::AppState::new(pool.clone(), this, settings, drivers).start();

	log::info!("Starting main loops");

	let _ = tokio::join!(
		tokio::spawn(run_relays_loop(app_state.clone())),
		tokio::spawn(run_ws_loop(pool.clone(), app_state.clone(), url)),
	);

	Ok(())
}