use crate::errors::ChatError;
use api::users::UserDto;
use auth::Accounts;
use std::collections::HashMap;

#[derive(Clone)]
pub struct Audience {
    pub(crate) accounts: Accounts,
    pub(crate) notifications: push::notify::Notifications,
    mail: Option<email::MailPublisher>,
    pub(crate) realtime: crate::share::realtime::Realtime,
    pub(crate) default_locale: i18n::UiLocale,
}
impl Audience {
    pub fn new(
        accounts: Accounts,
        notifications: push::notify::Notifications,
        mail: Option<email::MailPublisher>,
        realtime: crate::share::realtime::Realtime,
        default_locale: i18n::UiLocale,
    ) -> Self {
        Self {
            accounts,
            notifications,
            mail,
            realtime,
            default_locale,
        }
    }

    pub async fn load_user_briefs(&self, uids: &[i64]) -> Result<HashMap<i64, UserDto>, ChatError> {
        Ok(auth::users::load_user_briefs(&self.accounts, uids).await?)
    }

    pub(crate) async fn recipient_locale(&self, uid: i64) -> i18n::UiLocale {
        let fallback = self.default_locale;
        i18n::resolve_user_locale(self.accounts.db().read(), uid, fallback).await
    }

    pub(crate) async fn primary_emails(
        &self,
        uids: &[i64],
    ) -> Result<HashMap<i64, String>, ChatError> {
        if uids.is_empty() {
            return Ok(HashMap::new());
        }
        let users = auth::users::load_public_users(&self.accounts, uids).await?;
        Ok(users
            .into_iter()
            .filter(|(_, user)| user.email_verified && !user.email.trim().is_empty())
            .map(|(uid, user)| (uid, user.email.to_lowercase()))
            .collect())
    }

    pub(crate) async fn send_email(
        &self,
        to: &str,
        subject: &str,
        text: &str,
        html: &str,
    ) -> Result<(), ChatError> {
        let request_id = api::middleware::request_id();
        email::send_optional(
            self.mail.as_ref(),
            to,
            subject,
            text,
            html,
            request_id.as_deref(),
        )
        .await
        .map_err(|error| ChatError::Internal(format!("email send failed: {error}")))
    }
}