use std::borrow::Borrow;
use std::ops::DerefMut;

use chrono::NaiveTime;
use serde_derive::{Deserialize, Serialize};
use sqlx::pool::PoolConnection;
use sqlx::Sqlite;

use crate::db::model_utils::Period;
use crate::db::{DbJunctionTag, DbTag};
use crate::errors::DatabaseError;
use crate::types::ScheduleUid;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DbSchedule {
	#[serde(skip)]
	pub id: i64,
	#[serde(rename = "id")]
	pub uid: ScheduleUid,
	pub name: String,
	pub periods: DbPeriods,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
pub struct DbPeriods(pub Vec<Period>);

impl DbSchedule {
	pub async fn get_all(
		conn: &mut PoolConnection<Sqlite>,
	) -> Result<Vec<DbSchedule>, DatabaseError> {
		sqlx::query_as!(DbSchedule, "SELECT * FROM schedules")
			.fetch_all(conn.deref_mut())
			.await
			.map_err(DatabaseError::from)
	}

	pub async fn get(
		conn: &mut PoolConnection<Sqlite>,
		id: i64,
	) -> Result<Option<DbSchedule>, DatabaseError> {
		sqlx::query_as!(DbSchedule, "SELECT * FROM schedules WHERE id = ?", id)
			.fetch_optional(conn.deref_mut())
			.await
			.map_err(DatabaseError::from)
	}

	pub async fn get_by_uid(
		conn: &mut PoolConnection<Sqlite>,
		filter_uid: &ScheduleUid,
	) -> Result<Option<DbSchedule>, DatabaseError> {
		sqlx::query_as!(
			DbSchedule,
			"SELECT * FROM schedules WHERE uid = ?",
			filter_uid
		)
		.fetch_optional(conn.deref_mut())
		.await
		.map_err(DatabaseError::from)
	}

	pub async fn get_by_tag(
		conn: &mut PoolConnection<Sqlite>,
		tag: &DbTag,
	) -> Result<Vec<DbSchedule>, DatabaseError> {
		sqlx::query_as!(DbSchedule, "SELECT schedule.* FROM schedules AS schedule INNER JOIN junction_tag ON junction_tag.schedule_id = schedule.id WHERE junction_tag.tag_id = ?", tag.id)
			.fetch_all(conn.deref_mut())
			.await
			.map_err(DatabaseError::from)
	}

	pub async fn delete_by_uid(
		conn: &mut PoolConnection<Sqlite>,
		filter_uid: ScheduleUid,
	) -> Result<(), DatabaseError> {
		let filter_uid = match filter_uid {
			ScheduleUid::Off => Err(DatabaseError::Protected),
			ScheduleUid::On => Err(DatabaseError::Protected),
			ScheduleUid::Any(_) => Ok(filter_uid),
		}?;

		if sqlx::query_scalar!("SELECT 1 FROM schedules WHERE uid = ?", filter_uid)
			.fetch_optional(conn.deref_mut())
			.await?
			.is_none()
		{
			return Err(DatabaseError::NotFound);
		}

		sqlx::query!("DELETE FROM schedules WHERE uid = ?", filter_uid)
			.execute(conn.deref_mut())
			.await
			.map(|res| match res.rows_affected() {
				0 => Err(DatabaseError::DeleteError),
				_ => Ok(()),
			})?
	}

	pub async fn create(
		conn: &mut PoolConnection<Sqlite>,
		new_uid: ScheduleUid,
		new_name: &str,
		new_periods: &DbPeriods,
	) -> Result<DbSchedule, DatabaseError> {
		sqlx::query_as!(
			DbSchedule,
			"INSERT INTO schedules (uid, name, periods) VALUES (?, ?, ?) RETURNING *",
			new_uid,
			new_name,
			new_periods,
		)
		.fetch_optional(conn.deref_mut())
		.await?
		.ok_or(DatabaseError::InsertGetError)
	}

	pub async fn get_by_uid_or_create(
		conn: &mut PoolConnection<Sqlite>,
		uid: ScheduleUid,
		name: &str,
		periods: &DbPeriods,
	) -> Result<(DbSchedule, bool), DatabaseError> {
		match DbSchedule::get_by_uid(conn, &uid).await? {
			Some(schedule) => Ok((schedule, false)),
			None => {
				let schedule = DbSchedule::create(conn, uid, name, periods).await?;
				Ok((schedule, true))
			}
		}
	}

	pub async fn get_on(conn: &mut PoolConnection<Sqlite>) -> Result<DbSchedule, DatabaseError> {
		if let Some(schedule) = DbSchedule::get_by_uid(conn, &ScheduleUid::On).await? {
			return Ok(schedule);
		}
		let periods = DbPeriods(vec![Period::new_on()]);
		Self::create(conn, ScheduleUid::On, "On", &periods).await
	}

	pub async fn get_off(conn: &mut PoolConnection<Sqlite>) -> Result<DbSchedule, DatabaseError> {
		if let Some(schedule) = DbSchedule::get_by_uid(conn, &ScheduleUid::Off).await? {
			return Ok(schedule);
		}
		let periods = DbPeriods(vec![]);
		Self::create(conn, ScheduleUid::Off, "Off", &periods).await
	}

	pub async fn update(
		&self,
		conn: &mut PoolConnection<Sqlite>,
		new_name: &str,
		new_periods: &DbPeriods,
	) -> Result<DbSchedule, DatabaseError> {
		// overwrite periods on protected schedules
		let new_periods = match self.uid {
			ScheduleUid::Off | ScheduleUid::On => self.periods.borrow(),
			ScheduleUid::Any(_) => new_periods,
		};

		sqlx::query!(
			"UPDATE schedules SET name = ?, periods = ? WHERE id = ?",
			new_name,
			new_periods,
			self.id,
		)
		.execute(conn.deref_mut())
		.await?;

		DbSchedule::get(conn, self.id)
			.await?
			.ok_or(DatabaseError::UpdateGetError)
	}

	pub async fn get_tags(
		&self,
		conn: &mut PoolConnection<Sqlite>,
	) -> Result<Vec<String>, DatabaseError> {
		Ok(sqlx::query_scalar!("SELECT tag FROM tags INNER JOIN junction_tag ON junction_tag.tag_id = tags.id WHERE junction_tag.schedule_id = ?", self.id)
			.fetch_all(conn.deref_mut())
			.await?)
	}

	pub async fn set_tags(
		&self,
		conn: &mut PoolConnection<Sqlite>,
		new_tags: &[String],
	) -> Result<(), DatabaseError> {
		sqlx::query!("DELETE FROM junction_tag WHERE schedule_id = ?", self.id)
			.execute(conn.deref_mut())
			.await?;

		for new_tag in new_tags {
			let tag: DbTag = DbTag::get_by_tag_or_create(conn, new_tag).await?;
			DbJunctionTag::link_schedule(conn, &tag, self).await?;
		}
		Ok(())
	}

	pub fn is_on(&self, now: &NaiveTime) -> bool {
		self.periods.0.iter().any(|period| period.is_on(now))
	}

	pub fn get_next_time(&self, now: &NaiveTime) -> Option<NaiveTime> {
		self.periods
			.0
			.iter()
			.filter_map(|period| period.get_next_time(now))
			.min()
	}
}