use models::users::user_suspensions::{self, SuspensionType};
use sea_orm::{ColumnTrait, EntityTrait, QueryFilter, QueryOrder};
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;
use utoipa::{IntoParams, ToSchema};
use uuid::Uuid;

use crate::errors::UserError;
use crate::services::service::UserService;

#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
pub struct SuspensionDto {
    pub id: Uuid,
    pub suspension_type: SuspensionType,
    pub reason: Option<String>,
    pub starts_at: OffsetDateTime,
    pub ends_at: Option<OffsetDateTime>,
    pub revoked_at: Option<OffsetDateTime>,
    pub created_at: OffsetDateTime,
}

impl From<user_suspensions::Model> for SuspensionDto {
    fn from(m: user_suspensions::Model) -> Self {
        Self {
            id: m.id,
            suspension_type: m.suspension_type,
            reason: m.reason,
            starts_at: m.starts_at,
            ends_at: m.ends_at,
            revoked_at: m.revoked_at,
            created_at: m.created_at,
        }
    }
}

#[derive(Debug, Clone, Deserialize, IntoParams, ToSchema)]
pub struct IncludeRevokedQuery {
    pub include_revoked: Option<bool>,
    pub active: Option<bool>,
}

impl UserService {
    pub async fn my_suspensions(
        &self,
        uid: i64,
        q: IncludeRevokedQuery,
    ) -> Result<Vec<SuspensionDto>, UserError> {
        let mut sel = user_suspensions::Entity::find()
            .filter(user_suspensions::Column::UserId.eq(uid))
            .order_by_desc(user_suspensions::Column::CreatedAt);

        if q.include_revoked != Some(true) {
            sel = sel.filter(user_suspensions::Column::RevokedAt.is_null());
        }
        if q.active == Some(true) {
            let now = time::OffsetDateTime::now_utc();
            sel = sel.filter(
                sea_orm::Condition::any()
                    .add(user_suspensions::Column::EndsAt.gt(now))
                    .add(user_suspensions::Column::EndsAt.is_null()),
            );
        }

        let rows = sel.all(self.database.read()).await?;
        Ok(rows.into_iter().map(SuspensionDto::from).collect())
    }
}