// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
// ┃ Copyright: (c) 2023, Mike 'PhiSyX' S. (https://github.com/PhiSyX)         ┃
// ┃ SPDX-License-Identifier: MPL-2.0                                          ┃
// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
// ┃                                                                           ┃
// ┃  This Source Code Form is subject to the terms of the Mozilla Public      ┃
// ┃  License, v. 2.0. If a copy of the MPL was not distributed with this      ┃
// ┃  file, You can obtain one at https://mozilla.org/MPL/2.0/.                ┃
// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

use std::ops;
use std::sync::Arc;

// --------- //
// Interface //
// --------- //

#[async_trait::async_trait]
pub trait HttpContextInterface: Send + Sync {
	type State;

	async fn new(
		extensions: &super::Extensions,
		state: Self::State,
	) -> Option<Self>
	where
		Self: Sized;

	fn shared(self) -> Arc<Self>
	where
		Self: Sized,
	{
		Arc::new(self)
	}
}

// --------- //
// Structure //
// --------- //

pub struct HttpContext<T> {
	pub(crate) context: Arc<T>,
	pub request: HttpRequest<T>,
	pub response: HttpResponse<T>,
	#[cfg(feature = "cookies")]
	pub cookies: crate::http::cookies::Cookies,

	#[cfg(feature = "cookies")]
	pub session: SessionContext,
}

pub struct HttpRequest<T> {
	pub(crate) context: Arc<T>,
	pub ip: std::net::SocketAddr,
	pub method: hyper::Method,
	pub uri: hyper::Uri,
	pub raw_query: Option<String>,
	pub referer: Option<axum::headers::Referer>,
}

pub struct HttpResponse<T> {
	pub(crate) context: Arc<T>,
}

#[cfg(feature = "cookies")]
pub struct SessionContext {
	pub(crate) handle: axum_sessions::SessionHandle,
}

// -------------- //
// Implémentation //
// -------------- //

impl<T> HttpContext<T> {
	#[cfg(feature = "auth")]
	/// Déconnecte l'utilisateur de la session, et détruit le cookie de
	/// connexion associé à l'utilisateur.
	pub async fn logout_user(&mut self) {
		let mut session = self.session.write().await;
		session.remove(crate::auth::AUTH_USER_ID_SESSION);
		session.remove(crate::auth::AUTH_ADMIN_ID_SESSION);
		session.regenerate();

		if let Some(mut user_cookie) = self
			.cookies
			.private()
			.get(crate::auth::AUTH_USER_ID_SESSION)
		{
			let expires_in = time::OffsetDateTime::now_utc()
				.checked_sub(time::Duration::days(100));
			user_cookie.set_path("/");
			user_cookie.set_expires(expires_in);
			self.cookies.private().add(user_cookie);
		}

		if let Some(mut adm_cookie) = self
			.cookies
			.private()
			.get(crate::auth::AUTH_ADMIN_ID_SESSION)
		{
			let expires_in = time::OffsetDateTime::now_utc()
				.checked_sub(time::Duration::days(100));
			adm_cookie.set_path("/");
			adm_cookie.set_expires(expires_in);
			self.cookies.private().add(adm_cookie);
		}
	}
}

impl<T> HttpResponse<T> {
	/// Rend l'HTML d'une vue.
	#[inline]
	pub fn html<R>(
		&self,
		html: impl Into<axum::response::Html<R>>,
	) -> axum::response::Html<R>
	where
		R: Into<axum::body::Full<hyper::body::Bytes>>,
	{
		html.into()
	}

	/// Retourne un JSON en réponse.
	//
	// BUG(phisyx): provoque une erreur avec la commande `cargo doc`.
	// ISSUE(rust): "rustdoc RPITIT ICE:
	//               compiler\rustc_middle\src\ty\generic_args.rs:900:9: type
	//               parameter impl ToString/#1 (impl ToString/1) out of range
	//               when substituting, args=[MyStruct] "
	//               https://github.com/rust-lang/rust/issues/113929
	// ISSUE(rust): Closed (Fixed by https://github.com/rust-lang/rust/pull/113956).
	#[inline]
	pub fn json<D>(&self, data: D) -> axum::response::Json<D>
	where
		D: serde::Serialize,
	{
		// axum::response::Json(serde_json::json!(data))
		data.into()
	}

	/// Redirige le client vers une URL (Code HTTP 303).
	#[inline]
	pub fn redirect_to(&self, uri: impl ToString) -> axum::response::Redirect
	where
		Self: Sized,
	{
		axum::response::Redirect::to(uri.to_string().as_ref())
	}

	/// Redirige le client vers une URL de manière permanente (Code HTTP 308).
	#[inline]
	pub fn redirect_permanent(
		&self,
		uri: impl ToString,
	) -> axum::response::Redirect
	where
		Self: Sized,
	{
		axum::response::Redirect::permanent(uri.to_string().as_ref())
	}

	/// Redirige le client vers une URL de manière temporaire (Code HTTP 307).
	#[inline]
	pub fn redirect_temporary(
		&self,
		uri: impl ToString,
	) -> axum::response::Redirect
	where
		Self: Sized,
	{
		axum::response::Redirect::temporary(uri.to_string().as_ref())
	}
}

#[cfg(feature = "cookies")]
impl SessionContext {
	pub async fn read(
		&self,
	) -> tokio::sync::RwLockReadGuard<'_, axum_sessions::async_session::Session>
	{
		self.handle.read().await
	}

	pub async fn write(
		&mut self,
	) -> tokio::sync::RwLockWriteGuard<'_, axum_sessions::async_session::Session>
	{
		self.handle.write().await
	}

	#[cfg(feature = "auth")]
	pub async fn is_logged<User>(&self) -> bool
	where
		User: serde::de::DeserializeOwned,
	{
		self.read()
			.await
			.get::<User>(crate::auth::AUTH_ADMIN_ID_SESSION)
			.is_some() || self
			.read()
			.await
			.get::<User>(crate::auth::AUTH_USER_ID_SESSION)
			.is_some()
	}

	#[cfg(feature = "auth")]
	pub async fn is_logged_as_admin<User>(&self) -> bool
	where
		User: serde::de::DeserializeOwned,
	{
		self.read()
			.await
			.get::<User>(crate::auth::AUTH_ADMIN_ID_SESSION)
			.is_some()
	}

	#[cfg(feature = "auth")]
	pub async fn is_logged_as_user<User>(&self) -> bool
	where
		User: serde::de::DeserializeOwned,
	{
		self.read()
			.await
			.get::<User>(crate::auth::AUTH_USER_ID_SESSION)
			.is_some()
	}
}

// -------------- //
// Implémentation // -> Interface
// -------------- //

impl<T> ops::Deref for HttpContext<T> {
	type Target = Arc<T>;

	fn deref(&self) -> &Self::Target {
		&self.context
	}
}