smokesignal / src / http / handle_manage_event_content.rs

use anyhow::Result;
use axum::{extract::Path, response::IntoResponse};
use axum_extra::extract::Form;
use axum_template::RenderHtml;
use http::StatusCode;
use minijinja::context as template_context;
use serde::Deserialize;

use crate::{
    contextual_error,
    http::cache_countries::{other_countries, popular_countries},
    http::context::UserRequestContext,
    http::errors::{CommonError, WebError},
    select_template,
    storage::{
        event::{count_event_rsvps, event_get, get_event_rsvps_for_export},
        identity_profile::{handle_for_did, handle_for_handle},
    },
};
use atproto_record::lexicon::community::lexicon::calendar::event::NSID as LexiconCommunityEventNSID;

#[derive(Debug, Deserialize)]
pub struct PrivateContentForm {
    private_content: Option<String>,
    private_content_criteria_going_confirmed: Option<bool>,
    private_content_criteria_going: Option<bool>,
    private_content_criteria_interested: Option<bool>,
    send_notifications: Option<bool>,
}

pub(crate) async fn handle_manage_event_content_save(
    ctx: UserRequestContext,
    Path((handle_slug, event_rkey)): Path<(String, String)>,
    Form(form): Form<PrivateContentForm>,
) -> Result<impl IntoResponse, WebError> {
    let current_handle = ctx
        .auth
        .require(&format!("/{}/{}/manage/content", handle_slug, event_rkey))?;

    let default_context = template_context! {
        current_handle,
        language => ctx.language.to_string(),
    };

    let error_template = select_template!(false, false, ctx.language);

    // Lookup the event
    let profile = if handle_slug.starts_with("did:") {
        handle_for_did(&ctx.web_context.pool, &handle_slug)
            .await
            .map_err(WebError::from)
    } else {
        let handle = if let Some(handle) = handle_slug.strip_prefix('@') {
            handle
        } else {
            &handle_slug
        };
        handle_for_handle(&ctx.web_context.pool, handle)
            .await
            .map_err(WebError::from)
    }?;

    let lookup_aturi = format!(
        "at://{}/{}/{}",
        profile.did, LexiconCommunityEventNSID, event_rkey
    );

    // Check if the user is authorized to manage this event (must be the creator)
    if profile.did != current_handle.did {
        return contextual_error!(
            ctx.web_context,
            ctx.language,
            error_template,
            default_context,
            CommonError::NotAuthorized,
            StatusCode::FORBIDDEN
        );
    }

    let event = event_get(&ctx.web_context.pool, &lookup_aturi).await;
    if let Err(err) = event {
        return contextual_error!(
            ctx.web_context,
            ctx.language,
            error_template,
            default_context,
            err,
            StatusCode::NOT_FOUND
        );
    }

    let event = event.unwrap();

    // Build display criteria array from checkboxes
    let mut display_criteria = Vec::new();
    if form
        .private_content_criteria_going_confirmed
        .unwrap_or(false)
    {
        display_criteria.push("going_confirmed".to_string());
    }
    if form.private_content_criteria_going.unwrap_or(false) {
        display_criteria.push("going".to_string());
    }
    if form.private_content_criteria_interested.unwrap_or(false) {
        display_criteria.push("interested".to_string());
    }

    let private_content = form.private_content.as_deref().unwrap_or("");
    let has_content = !private_content.is_empty() || !display_criteria.is_empty();

    // Only save if there's content or criteria, otherwise delete
    if has_content {
        if let Err(err) = crate::storage::private_event_content::private_event_content_upsert(
            &ctx.web_context.pool,
            &lookup_aturi,
            &display_criteria,
            private_content,
        )
        .await
        {
            tracing::error!("Failed to save private event content: {:?}", err);
            return contextual_error!(
                ctx.web_context,
                ctx.language,
                error_template,
                default_context,
                err,
                StatusCode::INTERNAL_SERVER_ERROR
            );
        }
    } else {
        // Delete private content if both content and criteria are empty
        if let Err(err) = crate::storage::private_event_content::private_event_content_delete(
            &ctx.web_context.pool,
            &lookup_aturi,
        )
        .await
        {
            tracing::error!("Failed to delete private event content: {:?}", err);
        }
    }

    // Send notifications if requested and there's content with criteria
    if form.send_notifications.unwrap_or(false) && has_content && !display_criteria.is_empty() {
        // Only send notifications if emailer is available
        if let Some(ref emailer) = ctx.web_context.emailer {
            // Get all RSVPs with validation status
            match crate::storage::event::get_event_rsvps_with_validation(
                &ctx.web_context.pool,
                &lookup_aturi,
                None, // Get all statuses
            )
            .await
            {
                Ok(rsvps) => {
                    let total_rsvps = rsvps.len();

                    // Filter RSVPs to only those who meet the display criteria
                    let eligible_rsvps: Vec<_> = rsvps
                        .into_iter()
                        .filter(|(_, status, validated_at)| {
                            // Check if this RSVP meets any of the display criteria
                            display_criteria
                                .iter()
                                .any(|criterion| match criterion.as_str() {
                                    "going_confirmed" => {
                                        status == "going" && validated_at.is_some()
                                    }
                                    "going" => status == "going",
                                    "interested" => status == "interested",
                                    _ => false,
                                })
                        })
                        .collect();

                    tracing::info!(
                        event_aturi = %lookup_aturi,
                        total_rsvps,
                        eligible_rsvps = eligible_rsvps.len(),
                        "Sending private content notifications to eligible RSVPs"
                    );

                    // Get event URL for the notification
                    let event_url = format!(
                        "https://{}/{}/{}",
                        ctx.web_context.config.external_base, handle_slug, event_rkey
                    );

                    // Send notification to each eligible RSVP
                    for (rsvp_did, _, _) in eligible_rsvps {
                        // Get confirmed email for this DID
                        match crate::storage::notification::notification_get_confirmed_email(
                            &ctx.web_context.pool,
                            &rsvp_did,
                        )
                        .await
                        {
                            Ok(Some(email)) => {
                                // Send the notification (errors are logged but don't fail the request)
                                if let Err(err) = emailer
                                    .notify_event_changed(
                                        &email,
                                        &rsvp_did,
                                        &current_handle.did,
                                        &event.name,
                                        &event_url,
                                    )
                                    .await
                                {
                                    tracing::warn!(
                                        ?err,
                                        rsvp_did = %rsvp_did,
                                        "Failed to send private content notification"
                                    );
                                }
                            }
                            Ok(None) => {
                                tracing::debug!(
                                    rsvp_did = %rsvp_did,
                                    "No confirmed email for RSVP, skipping notification"
                                );
                            }
                            Err(err) => {
                                tracing::warn!(
                                    ?err,
                                    rsvp_did = %rsvp_did,
                                    "Failed to get email for RSVP"
                                );
                            }
                        }
                    }
                }
                Err(err) => {
                    tracing::warn!(
                        ?err,
                        event_aturi = %lookup_aturi,
                        "Failed to get RSVPs for private content notifications"
                    );
                }
            }
        } else {
            tracing::debug!("Emailer not configured, skipping private content notifications");
        }
    }

    // Fetch data needed for rendering
    let going_count = count_event_rsvps(&ctx.web_context.pool, &lookup_aturi, "going")
        .await
        .unwrap_or_default();
    let interested_count = count_event_rsvps(&ctx.web_context.pool, &lookup_aturi, "interested")
        .await
        .unwrap_or_default();
    let notgoing_count = count_event_rsvps(&ctx.web_context.pool, &lookup_aturi, "notgoing")
        .await
        .unwrap_or_default();

    #[derive(serde::Serialize)]
    struct RsvpCounts {
        going: u32,
        interested: u32,
        notgoing: u32,
    }

    let rsvp_counts = RsvpCounts {
        going: going_count,
        interested: interested_count,
        notgoing: notgoing_count,
    };

    let rsvps = get_event_rsvps_for_export(&ctx.web_context.pool, &lookup_aturi)
        .await
        .unwrap_or_default();

    let delete_event_url = format!(
        "https://{}/{}/{}/delete",
        ctx.web_context.config.external_base, handle_slug, event_rkey
    );

    let is_development = cfg!(debug_assertions);

    // Prepare private content form data for the template
    let private_content_form = crate::http::event_form::PrivateContentFormData {
        private_content: form.private_content.clone(),
        private_content_criteria_going_confirmed: Some(
            form.private_content_criteria_going_confirmed
                .unwrap_or(false),
        ),
        private_content_criteria_going: Some(form.private_content_criteria_going.unwrap_or(false)),
        private_content_criteria_interested: Some(
            form.private_content_criteria_interested.unwrap_or(false),
        ),
    };

    let submit_url = format!("/{}/{}/edit", handle_slug, event_rkey);
    let cancel_url = format!("/{}/{}/manage", handle_slug, event_rkey);

    // Get country lists for location form dropdown
    let popular = popular_countries().unwrap_or_default();
    let others = other_countries().unwrap_or_default();

    // Render tabs + content together with success message
    Ok((
        StatusCode::OK,
        RenderHtml(
            "en-us/manage_event_tabs_and_content.partial.html",
            ctx.web_context.engine.clone(),
            template_context! {
                current_handle => ctx.current_handle,
                language => ctx.language.to_string(),
                handle_slug,
                event_rkey,
                event,
                rsvps,
                rsvp_counts,
                private_content_form,
                popular_countries => popular,
                other_countries => others,
                locations_editable => true,
                location_edit_reason => None::<String>,
                delete_event_url,
                is_development,
                active_tab => "content",
                tab_template => "en-us/manage_event_content_tab.html",
                submit_url,
                cancel_url,
                create_event => false,
                content_saved => true,
            },
        ),
    )
        .into_response())
}