use uuid::Uuid;

use crate::error::UserResult;
use crate::features::UserService;

use super::types::{
    ListNotificationsQuery, MarkReadCmd, NotificationView, RecentMentionView, ReportView,
    SaveMessageCmd, SavedMessageView, ScheduledMessageView, SubmitReportCmd, UnreadCountResp,
    UpdateReportCmd,
};
use super::usecase;

impl UserService {
    pub async fn list_notifications(
        &self,
        caller: Uuid,
        q: ListNotificationsQuery,
    ) -> UserResult<Vec<NotificationView>> {
        usecase::list_notifications(self, caller, q).await
    }

    pub async fn mark_notifications_read(
        &self,
        caller: Uuid,
        cmd: MarkReadCmd,
    ) -> UserResult<u64> {
        usecase::mark_read(self, caller, cmd).await
    }

    pub async fn mark_all_notifications_read(&self, caller: Uuid) -> UserResult<u64> {
        usecase::mark_all_read(self, caller).await
    }

    pub async fn unread_notifications_count(
        &self,
        caller: Uuid,
    ) -> UserResult<UnreadCountResp> {
        usecase::unread_count(self, caller).await
    }

    pub async fn list_recent_mentions(
        &self,
        caller: Uuid,
        limit: usize,
    ) -> UserResult<Vec<RecentMentionView>> {
        usecase::list_recent_mentions(self, caller, limit).await
    }

    pub async fn submit_report(
        &self,
        caller: Uuid,
        cmd: SubmitReportCmd,
    ) -> UserResult<ReportView> {
        usecase::submit_report(self, caller, cmd).await
    }

    pub async fn list_my_reports(&self, caller: Uuid) -> UserResult<Vec<ReportView>> {
        usecase::list_my_reports(self, caller).await
    }

    pub async fn list_all_reports(&self) -> UserResult<Vec<ReportView>> {
        usecase::list_all_reports(self).await
    }

    pub async fn update_report(
        &self,
        report_id: Uuid,
        cmd: UpdateReportCmd,
    ) -> UserResult<ReportView> {
        usecase::update_report(self, report_id, cmd).await
    }

    pub async fn save_message(
        &self,
        caller: Uuid,
        cmd: SaveMessageCmd,
    ) -> UserResult<SavedMessageView> {
        usecase::save_message(self, caller, cmd).await
    }

    pub async fn list_saved_messages(
        &self,
        caller: Uuid,
    ) -> UserResult<Vec<SavedMessageView>> {
        usecase::list_saved(self, caller).await
    }

    pub async fn unsave_message(
        &self,
        caller: Uuid,
        message_id: Uuid,
    ) -> UserResult<()> {
        usecase::unsave_message(self, caller, message_id).await
    }

    pub async fn list_scheduled_messages(
        &self,
        caller: Uuid,
    ) -> UserResult<Vec<ScheduledMessageView>> {
        usecase::list_scheduled(self, caller).await
    }

    pub async fn cancel_scheduled_message(&self, caller: Uuid, id: Uuid) -> UserResult<()> {
        usecase::cancel_scheduled(self, caller, id).await
    }
}