use sea_orm::{
    ActiveValue::{NotSet, Set},
    ColumnTrait, DatabaseConnection, EntityTrait, QueryFilter,
};
use thiserror::Error;
use web_push::SubscriptionInfo;

use crate::User;
use orm::entities::{prelude::*, web_push_subscription};

#[derive(Error, Debug, PartialEq)]
pub enum WebPushServiceError {
    #[error("database error - caused by: {0}")]
    DbError(#[from] sea_orm::DbErr),
}

pub struct WebPushService {}

impl WebPushService {
    pub async fn create(
        user: &User,
        db: &DatabaseConnection,
        subscription: SubscriptionInfo,
    ) -> Result<SubscriptionInfo, WebPushServiceError> {
        let subscription = WebPushSubscription::insert(web_push_subscription::ActiveModel {
            id: NotSet,
            owner_id: Set(user.id.clone()),
            endpoint: Set(subscription.endpoint),
            p256dh: Set(subscription.keys.p256dh),
            auth: Set(subscription.keys.auth),
        })
        .exec_with_returning(db)
        .await?;

        Ok(SubscriptionInfo::new(
            subscription.endpoint,
            subscription.p256dh,
            subscription.auth,
        ))
    }

    pub async fn exists(
        user: &User,
        db: &DatabaseConnection,
        subscription: &SubscriptionInfo,
    ) -> Result<bool, WebPushServiceError> {
        let result = WebPushSubscription::find()
            .filter(web_push_subscription::Column::OwnerId.eq(&user.id))
            .filter(web_push_subscription::Column::Endpoint.eq(&subscription.endpoint))
            .filter(web_push_subscription::Column::Auth.eq(&subscription.keys.auth))
            .filter(web_push_subscription::Column::P256dh.eq(&subscription.keys.p256dh))
            .one(db)
            .await?;

        Ok(result.is_some())
    }

    pub async fn delete_by_id(db: &DatabaseConnection, id: i32) -> Result<(), WebPushServiceError> {
        WebPushSubscription::delete_by_id(id).exec(db).await?;
        Ok(())
    }

    pub async fn get_all_by_owner_id(
        db: &DatabaseConnection,
        owner: &str,
    ) -> Result<Vec<(SubscriptionInfo, i32)>, WebPushServiceError> {
        let subscriptions = WebPushSubscription::find()
            .filter(web_push_subscription::Column::OwnerId.eq(owner))
            .all(db)
            .await?;

        let subscriptions = subscriptions
            .into_iter()
            .map(|subscription| {
                (
                    SubscriptionInfo::new(
                        subscription.endpoint,
                        subscription.p256dh,
                        subscription.auth,
                    ),
                    subscription.id,
                )
            })
            .collect();

        Ok(subscriptions)
    }
}