mascarpone/src/web/home.rs

use axum::extract::State;
use axum::response::IntoResponse;
use cache_bust::asset;
use jiff::{Timestamp, Unit, Zoned, civil, tz::TimeZone};
use maud::{Markup, html};
use sqlx::sqlite::SqlitePool;

use super::Layout;
use crate::db::DbId;
use crate::models::user::AuthSession;
use crate::models::{Birthday, HydratedContact, JournalEntry};
use crate::{AppError, AppState};

#[derive(Debug, Clone)]
struct ContactFreshness {
    contact_id: DbId,
    display: String,
    fresh_date: civil::Date,
    fresh_str: String,
    elapsed_str: String,
}

fn freshness_section(freshens: &Vec<ContactFreshness>) -> Result<Markup, AppError> {
    Ok(html! {
        div id="freshness" {
            h2 { "Stale Contacts" }
            div class="grid" {
                span .th { "name" }
                span .th { "freshened" }
                span .th { "elapsed" }
                @for contact in &freshens[0..std::cmp::min(5, freshens.len())] {
                    span {
                        a href=(format!("/contact/{}", contact.contact_id)) {
                            (contact.display)
                        }
                    }
                    span { (contact.fresh_str) }
                    span { (contact.elapsed_str) }
                }
            }
        }
    })
}

#[derive(Debug, Clone)]
struct KnownBirthdayContact {
    contact_id: i64,
    display: String,
    prev_birthday: civil::Date,
    next_birthday: civil::Date,
}
fn birthdays_section(
    prev_birthdays: &Vec<KnownBirthdayContact>,
    upcoming_birthdays: &Vec<KnownBirthdayContact>,
) -> Result<Markup, AppError> {
    Ok(html! {
        div id="birthdays" {
            h2 { "Birthdays" }
            #birthday-sections {
                .datelist {
                    h3 { "upcoming" }
                    @for contact in &upcoming_birthdays[0..std::cmp::min(3, upcoming_birthdays.len())] {
                        a href=(format!("/contact/{}", contact.contact_id)) {
                            (contact.display)
                        }
                        span {
                            (contact.next_birthday.strftime("%m-%d"))
                        }
                    }
                }
                .datelist {
                    h3 { "recent" }
                    @for contact in &prev_birthdays[0..std::cmp::min(3, prev_birthdays.len())] {
                        a href=(format!("/contact/{}", contact.contact_id)) {
                            (contact.display)
                        }
                        span {
                            (contact.prev_birthday.strftime("%m-%d"))
                        }
                    }
                }
            }
        }
    })
}

#[tracing::instrument(level = "info")]
pub async fn journal_section(
    pool: &SqlitePool,
    entries: &Vec<JournalEntry>,
) -> Result<Markup, AppError> {
    Ok(html! {
        div id="journal" x-data="{ edit: false }" {
            header {
                h2 { "Journal" }
                input id="journal-edit-mode" type="checkbox" x-model="edit" {
                    label for="journal-edit-mode" { "Edit" }
                }
            }
            .disclaimer {
                "Leave off year or year and month in the date field to default to what they
                    are now, or leave everything blank to default to 'today'. Entries will be
                    added to the top of the list regardless of date; refresh the page to re-sort."
            }
            form hx-post="/journal_entry" hx-target="next .entries" hx-target-error="#journal-error" hx-swap="afterbegin" hx-on::after-request="if(event.detail.successful) this.reset()" {
                input name="date" placeholder=(Zoned::now().date().to_string());
                textarea name="value" placeholder="New entry..." autofocus {}
                input type="submit" value="Add Entry";
            }

            #journal-error {}

            .entries {
                @for entry in entries {
                    (entry.to_html(pool).await?)
                }
            }
        }
    })
}

pub mod get {
    use super::*;

    pub async fn home(
        auth_session: AuthSession,
        State(state): State<AppState>,
        layout: Layout,
    ) -> Result<impl IntoResponse, AppError> {
        let user = auth_session.user.unwrap();
        let pool = &state.db(&user).pool;

        let contacts = HydratedContact::all(&pool).await?;
        let mut freshens: Vec<ContactFreshness> = contacts
            .clone()
            .into_iter()
            .filter_map(|contact| {
                if !contact.can_stale || !contact.active {
                    return None;
                }

                let zero = jiff::civil::Date::ZERO;
                let fresh_date = std::cmp::max(
                    contact
                        .manually_freshened_at
                        .map(|ts| ts.to_zoned(TimeZone::UTC).date())
                        .unwrap_or(zero),
                    contact.last_mention_date.unwrap_or(zero),
                );
                if fresh_date == zero {
                    Some(ContactFreshness {
                        contact_id: contact.id,
                        display: contact.display_name(),
                        fresh_date,
                        fresh_str: "never".to_string(),
                        elapsed_str: "".to_string(),
                    })
                } else {
                    let utc = TimeZone::UTC;
                    let todate = Timestamp::now().to_zoned(utc.clone()).date();
                    let elapsed = todate
                        .since(&fresh_date.to_zoned(utc).unwrap())
                        .unwrap()
                        .round(
                            jiff::SpanRound::new()
                                .largest(Unit::Year)
                                .smallest(Unit::Day)
                                .relative(todate),
                        )
                        .unwrap();

                    if let Some(cmp) = elapsed.compare((contact.periodicity, todate)).ok() {
                        if cmp == std::cmp::Ordering::Less {
                            return None;
                        }
                    }

                    let elapsed_str = if elapsed.is_zero() {
                        "today".to_string()
                    } else {
                        format!("{:#}", elapsed)
                    };

                    Some(ContactFreshness {
                        contact_id: contact.id,
                        display: contact.display_name(),
                        fresh_date,
                        fresh_str: fresh_date.to_string(),
                        elapsed_str,
                    })
                }
            })
            .collect();
        freshens.sort_by_key(|x| x.fresh_date);

        let birthdays = contacts
            .into_iter()
            .map(|contact| {
                if let Some(Birthday::Date(date)) = &contact.birthday {
                    Some(KnownBirthdayContact {
                        contact_id: contact.id,
                        display: contact.display_name(),
                        prev_birthday: date.prev_month_day_occurrence()?,
                        next_birthday: date.next_month_day_occurrence()?,
                    })
                } else {
                    None
                }
            })
            .filter(|x| x.is_some())
            .map(|x| x.unwrap())
            .collect::<Vec<KnownBirthdayContact>>();

        let mut prev_birthdays = birthdays.clone();
        prev_birthdays.sort_by_key(|x| x.prev_birthday);
        prev_birthdays.reverse();

        let mut upcoming_birthdays = birthdays;
        upcoming_birthdays.sort_by_key(|x| x.next_birthday);

        // I'm writing this as an n+1 query pattern deliberately
        // since I *think* the overhead of string_agg+split might
        // be worse than that of the n+1 since we're in sqlite.
        let entries: Vec<JournalEntry> =
            sqlx::query_as("select id,value,date from journal_entries order by date desc")
                .fetch_all(pool)
                .await?;
        Ok(layout.render(
            "Home",
            Some(vec![asset!("home.css"), asset!("journal.css")]),
            html! {
                    (freshness_section(&freshens)?)
                    (birthdays_section(&prev_birthdays, &upcoming_birthdays)?)
                    (journal_section(pool, &entries).await?)
            },
        ))
    }
}