ALL='["cellar","sipp","feeds","parcels","jotts","og","shrink","backup","posts","library","bookmarks","easel"]'

          for app in cellar sipp feeds parcels jotts og shrink backup posts library bookmarks easel; do

          ALL='["cellar","sipp","feeds","parcels","jotts","og","shrink","backup","posts","library","bookmarks","easel"]'

          for app in cellar sipp feeds parcels jotts og shrink backup posts library bookmarks easel; do

name = "chrono-tz"

version = "0.10.4"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3"

dependencies = [

 "chrono",

 "phf 0.12.1",

]

[[package]]

 "phf 0.11.3",

 "phf 0.11.3",

[[package]]

name = "easel"

version = "0.1.0"

dependencies = [

 "andromeda-darkmatter-css",

 "askama 0.13.1",

 "axum",

 "chrono",

 "chrono-tz",

 "dotenvy",

 "mime_guess",

 "rand 0.8.5",

 "reqwest 0.12.28",

 "rusqlite",

 "rust-embed",

 "serde",

 "serde_json",

 "tokio",

 "tracing",

 "tracing-subscriber",

 "urlencoding",

]

 "phf 0.11.3",

 "phf_shared 0.11.3",

]

[[package]]

name = "phf"

version = "0.12.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7"

dependencies = [

 "phf_shared 0.12.1",

 "phf_shared 0.11.3",

 "phf_shared 0.11.3",

 "phf_shared 0.11.3",

name = "phf_shared"

version = "0.12.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981"

dependencies = [

 "siphasher",

]

[[package]]

 "phf 0.11.3",

 "phf_shared 0.11.3",

 "phf_shared 0.11.3",

 "phf 0.11.3",

 "phf 0.11.3",

    "apps/easel",

# Bind / port

HOST=127.0.0.1

PORT=4242

# SQLite file path

EASEL_DB_PATH=easel.sqlite

# IANA timezone for day boundary (e.g. America/Chicago, Europe/London)

EASEL_TIMEZONE=UTC

# Comma-separated AIC classification_title filters (lowercased, e.g. painting,drawing,print)

EASEL_CLASSIFICATIONS=painting

# On startup, fill any missing day in the last N days. 0 disables backfill.

EASEL_BACKFILL_DAYS=0

# Max retries when picking a non-duplicate artwork

EASEL_MAX_DEDUP_RETRIES=10

[package]

name = "easel"

version = "0.1.0"

edition = "2024"

description = "A daily painting from the Art Institute of Chicago"

license = "MIT"

repository = "https://github.com/stevedylandev/andromeda"

homepage = "https://github.com/stevedylandev/andromeda"

[dependencies]

axum = { workspace = true }

tokio = { workspace = true }

serde = { workspace = true }

serde_json = { workspace = true }

dotenvy = { workspace = true }

rust-embed = { workspace = true }

rusqlite = { workspace = true }

rand = { workspace = true }

tracing = { workspace = true }

tracing-subscriber = { workspace = true, features = ["env-filter"] }

andromeda-darkmatter-css = { workspace = true }

askama = "0.13"

reqwest = { version = "0.12", features = ["json"] }

chrono = "0.4"

chrono-tz = "0.10"

urlencoding = "2"

mime_guess = "2"

# Build from repo root: docker build -t easel -f apps/easel/Dockerfile .

FROM lukemathwalker/cargo-chef:latest-rust-1-slim-bookworm AS chef

WORKDIR /app

FROM chef AS planner

COPY . .

RUN cargo chef prepare --recipe-path recipe.json

FROM chef AS builder

RUN apt-get update && apt-get install -y pkg-config libssl-dev && rm -rf /var/lib/apt/lists/*

COPY --from=planner /app/recipe.json recipe.json

RUN cargo chef cook --release --recipe-path recipe.json -p easel

COPY . .

RUN cargo build --release -p easel

FROM debian:bookworm-slim

RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*

COPY --from=builder /app/target/release/easel /usr/local/bin/easel

WORKDIR /data

EXPOSE 3000

ENV HOST=0.0.0.0

ENV PORT=3000

ENV EASEL_DB_PATH=/data/easel.sqlite

CMD ["easel"]

# Easel

A daily painting from the [Art Institute of Chicago](https://api.artic.edu/docs/). One public-domain artwork per calendar day, persisted to SQLite. Past days browsable; future days unavailable until populated.

## Run locally

```bash

cargo run -p easel

```

Visit `http://localhost:4242`.

## Configuration

| Var | Default | Purpose |

|---|---|---|

| `HOST` | `127.0.0.1` | Bind address |

| `PORT` | `4242` | Listen port |

| `EASEL_DB_PATH` | `easel.sqlite` | SQLite file |

| `EASEL_TIMEZONE` | `UTC` | IANA TZ for day boundary |

| `EASEL_CLASSIFICATIONS` | `painting` | Comma-separated `classification_title` filter |

| `EASEL_BACKFILL_DAYS` | `0` | On boot, fill missing past N days |

| `EASEL_MAX_DEDUP_RETRIES` | `10` | Retries when picking a non-duplicate page |

## Routes

- `GET /` — today's artwork

- `GET /day/{YYYY-MM-DD}` — specific past day

- `GET /archive` — full archive

- `GET /api/today` — JSON of today

- `GET /api/day/{YYYY-MM-DD}` — JSON of specific day

- `GET /api/archive` — JSON list

## Image source

Images served from AIC's IIIF endpoint:

`https://www.artic.edu/iiif/2/{image_id}/full/843,/0/default.jpg`

services:

  app:

    build:

      context: ../..

      dockerfile: apps/easel/Dockerfile

    ports:

      - "${PORT:-4242}:3000"

    environment:

      - EASEL_DB_PATH=/data/easel.sqlite

      - EASEL_TIMEZONE=${EASEL_TIMEZONE:-UTC}

      - EASEL_CLASSIFICATIONS=${EASEL_CLASSIFICATIONS:-painting}

      - EASEL_BACKFILL_DAYS=${EASEL_BACKFILL_DAYS:-0}

      - EASEL_MAX_DEDUP_RETRIES=${EASEL_MAX_DEDUP_RETRIES:-10}

      - HOST=0.0.0.0

      - PORT=3000

    volumes:

      - easel-data:/data

    restart: unless-stopped

volumes:

  easel-data:

use rand::Rng;

use serde::Deserialize;

use std::time::Duration;

use crate::db::{self, DailyArtwork, Db};

const SEARCH_URL: &str = "https://api.artic.edu/api/v1/artworks/search";

const FIELDS: &str = "id,title,artist_display,artist_title,date_display,medium_display,dimensions,place_of_origin,credit_line,description,short_description,image_id";

pub fn build_client() -> reqwest::Client {

    reqwest::Client::builder()

        .timeout(Duration::from_secs(20))

        .user_agent("andromeda-easel/0.1 (+https://github.com/stevedylandev/andromeda)")

        .build()

        .expect("Failed to build HTTP client")

}

#[derive(Debug, Deserialize)]

pub struct RawArtwork {

    pub id: i64,

    pub title: Option<String>,

    pub artist_display: Option<String>,

    pub artist_title: Option<String>,

    pub date_display: Option<String>,

    pub medium_display: Option<String>,

    pub dimensions: Option<String>,

    pub place_of_origin: Option<String>,

    pub credit_line: Option<String>,

    pub description: Option<String>,

    pub short_description: Option<String>,

    pub image_id: Option<String>,

}

#[derive(Debug, Deserialize)]

struct Pagination {

    total: u64,

}

#[derive(Debug, Deserialize)]

struct SearchResponse<T> {

    pagination: Pagination,

    data: Vec<T>,

}

#[derive(Debug, Deserialize)]

struct IdOnly {

    #[allow(dead_code)]

    id: i64,

}

fn build_params(classifications: &[String]) -> String {

    let terms: Vec<serde_json::Value> = classifications

        .iter()

        .map(|c| serde_json::Value::String(c.to_lowercase()))

        .collect();

    let body = serde_json::json!({

        "query": {

            "bool": {

                "must": [

                    { "term": { "is_public_domain": true } },

                    { "terms": { "classification_title.keyword": terms } },

                    { "exists": { "field": "image_id" } }

                ]

            }

        }

    });

    body.to_string()

}

pub async fn total_matching(

    client: &reqwest::Client,

    classifications: &[String],

) -> Result<u64, String> {

    let params = build_params(classifications);

    let url = format!(

        "{SEARCH_URL}?params={}&limit=1&fields=id",

        urlencoding::encode(&params)

    );

    let resp = client

        .get(&url)

        .send()

        .await

        .map_err(|e| format!("count fetch failed: {e}"))?;

    if !resp.status().is_success() {

        return Err(format!("count returned status {}", resp.status()));

    }

    let body: SearchResponse<IdOnly> = resp

        .json()

        .await

        .map_err(|e| format!("count parse failed: {e}"))?;

    Ok(body.pagination.total)

}

pub async fn fetch_artwork_at(

    client: &reqwest::Client,

    classifications: &[String],

    page: u64,

) -> Result<Option<RawArtwork>, String> {

    let params = build_params(classifications);

    let url = format!(

        "{SEARCH_URL}?params={}&limit=1&page={page}&fields={FIELDS}",

        urlencoding::encode(&params)

    );

    let resp = client

        .get(&url)

        .send()

        .await

        .map_err(|e| format!("artwork fetch failed: {e}"))?;

    if !resp.status().is_success() {

        return Err(format!("artwork returned status {}", resp.status()));

    }

    let mut body: SearchResponse<RawArtwork> = resp

        .json()

        .await

        .map_err(|e| format!("artwork parse failed: {e}"))?;

    Ok(body.data.pop())

}

pub async fn pick_unique(

    client: &reqwest::Client,

    db: &Db,

    classifications: &[String],

    max_retries: u32,

) -> Result<RawArtwork, String> {

    let total = total_matching(client, classifications).await?;

    if total == 0 {

        return Err("AIC search returned zero matches for given classifications".to_string());

    }

    for attempt in 0..=max_retries {

        let page = {

            let mut rng = rand::thread_rng();

            rng.gen_range(1..=total)

        };

        let art = match fetch_artwork_at(client, classifications, page).await? {

            Some(a) => a,

            None => continue,

        };

        if art.image_id.is_none() || art.image_id.as_deref() == Some("") {

            tracing::warn!("artwork {} has no image_id, retrying", art.id);

            continue;

        }

        match db::artwork_id_exists(db, art.id) {

            Ok(true) => {

                tracing::info!(

                    "duplicate artwork {} on attempt {}, retrying",

                    art.id,

                    attempt + 1

                );

                continue;

            }

            Ok(false) => return Ok(art),

            Err(e) => return Err(format!("dedup check failed: {e}")),

        }

    }

    Err(format!(

        "failed to pick a non-duplicate artwork after {} retries",

        max_retries + 1

    ))

}

pub fn raw_to_daily(raw: RawArtwork, date: String, fetched_at: String) -> Option<DailyArtwork> {

    let image_id = raw.image_id?;

    if image_id.is_empty() {

        return None;

    }

    Some(DailyArtwork {

        date,

        artwork_id: raw.id,

        title: raw.title.unwrap_or_else(|| "Untitled".to_string()),

        artist_display: raw.artist_display,

        artist_title: raw.artist_title,

        date_display: raw.date_display,

        medium_display: raw.medium_display,

        dimensions: raw.dimensions,

        place_of_origin: raw.place_of_origin,

        credit_line: raw.credit_line,

        description: raw.description,

        short_description: raw.short_description,

        image_id,

        fetched_at,

    })

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn build_params_lowercases_classifications() {

        let p = build_params(&["Painting".to_string(), "DRAWING".to_string()]);

        assert!(p.contains("\"painting\""));

        assert!(p.contains("\"drawing\""));

        assert!(p.contains("is_public_domain"));

        assert!(p.contains("image_id"));

    }

}

use rusqlite::{params, Connection, OptionalExtension};

use serde::{Deserialize, Serialize};

use std::fmt;

use std::sync::{Arc, Mutex};

pub type Db = Arc<Mutex<Connection>>;

#[derive(Debug)]

pub enum DbError {

    Sqlite(rusqlite::Error),

    LockPoisoned,

}

impl fmt::Display for DbError {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        match self {

            DbError::Sqlite(e) => write!(f, "Database error: {}", e),

            DbError::LockPoisoned => write!(f, "Database lock poisoned"),

        }

    }

}

impl std::error::Error for DbError {}

impl From<rusqlite::Error> for DbError {

    fn from(e: rusqlite::Error) -> Self {

        DbError::Sqlite(e)

    }

}

#[derive(Debug, Clone, Serialize, Deserialize)]

pub struct DailyArtwork {

    pub date: String,

    pub artwork_id: i64,

    pub title: String,

    pub artist_display: Option<String>,

    pub artist_title: Option<String>,

    pub date_display: Option<String>,

    pub medium_display: Option<String>,

    pub dimensions: Option<String>,

    pub place_of_origin: Option<String>,

    pub credit_line: Option<String>,

    pub description: Option<String>,

    pub short_description: Option<String>,

    pub image_id: String,

    pub fetched_at: String,

}

const SCHEMA: &str = "

    CREATE TABLE IF NOT EXISTS daily_artworks (

        date              TEXT PRIMARY KEY,

        artwork_id        INTEGER NOT NULL,

        title             TEXT NOT NULL,

        artist_display    TEXT,

        artist_title      TEXT,

        date_display      TEXT,

        medium_display    TEXT,

        dimensions        TEXT,

        place_of_origin   TEXT,

        credit_line       TEXT,

        description       TEXT,

        short_description TEXT,

        image_id          TEXT NOT NULL,

        fetched_at        TEXT NOT NULL DEFAULT (datetime('now'))

    );

    CREATE INDEX IF NOT EXISTS idx_daily_artworks_artwork_id ON daily_artworks(artwork_id);

";

pub fn init_db(path: &str) -> Db {

    let conn = Connection::open(path).expect("Failed to open easel database");

    conn.execute_batch(SCHEMA).expect("Failed to apply schema");

    Arc::new(Mutex::new(conn))

}

const COLS: &str = "date, artwork_id, title, artist_display, artist_title, date_display, medium_display, dimensions, place_of_origin, credit_line, description, short_description, image_id, fetched_at";

fn from_row(row: &rusqlite::Row) -> rusqlite::Result<DailyArtwork> {

    Ok(DailyArtwork {

        date: row.get(0)?,

        artwork_id: row.get(1)?,

        title: row.get(2)?,

        artist_display: row.get(3)?,

        artist_title: row.get(4)?,

        date_display: row.get(5)?,

        medium_display: row.get(6)?,

        dimensions: row.get(7)?,

        place_of_origin: row.get(8)?,

        credit_line: row.get(9)?,

        description: row.get(10)?,

        short_description: row.get(11)?,

        image_id: row.get(12)?,

        fetched_at: row.get(13)?,

    })

}

pub fn insert_daily(db: &Db, art: &DailyArtwork) -> Result<bool, DbError> {

    let conn = db.lock().map_err(|_| DbError::LockPoisoned)?;

    let rows = conn.execute(

        "INSERT OR IGNORE INTO daily_artworks

         (date, artwork_id, title, artist_display, artist_title, date_display, medium_display,

          dimensions, place_of_origin, credit_line, description, short_description, image_id, fetched_at)

         VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14)",

        params![

            art.date,

            art.artwork_id,

            art.title,

            art.artist_display,

            art.artist_title,

            art.date_display,

            art.medium_display,

            art.dimensions,

            art.place_of_origin,

            art.credit_line,

            art.description,

            art.short_description,

            art.image_id,

            art.fetched_at,

        ],

    )?;

    Ok(rows > 0)

}

pub fn get_daily(db: &Db, date: &str) -> Result<Option<DailyArtwork>, DbError> {

    let conn = db.lock().map_err(|_| DbError::LockPoisoned)?;

    let row = conn

        .query_row(

            &format!("SELECT {COLS} FROM daily_artworks WHERE date = ?1"),

            params![date],

            from_row,

        )

        .optional()?;

    Ok(row)

}

pub fn list_daily(db: &Db, limit: i64) -> Result<Vec<DailyArtwork>, DbError> {

    let conn = db.lock().map_err(|_| DbError::LockPoisoned)?;

    let mut stmt = conn.prepare(&format!(

        "SELECT {COLS} FROM daily_artworks ORDER BY date DESC LIMIT ?1"

    ))?;

    let rows = stmt

        .query_map(params![limit], from_row)?

        .collect::<Result<Vec<_>, _>>()?;

    Ok(rows)

}

pub fn artwork_id_exists(db: &Db, artwork_id: i64) -> Result<bool, DbError> {

    let conn = db.lock().map_err(|_| DbError::LockPoisoned)?;

    let count: i64 = conn.query_row(

        "SELECT COUNT(*) FROM daily_artworks WHERE artwork_id = ?1",

        params![artwork_id],

        |row| row.get(0),

    )?;

    Ok(count > 0)

}

pub fn missing_dates(db: &Db, dates: &[String]) -> Result<Vec<String>, DbError> {

    let conn = db.lock().map_err(|_| DbError::LockPoisoned)?;

    let mut missing = Vec::new();

    for d in dates {

        let exists: i64 = conn.query_row(

            "SELECT COUNT(*) FROM daily_artworks WHERE date = ?1",

            params![d],

            |row| row.get(0),

        )?;

        if exists == 0 {

            missing.push(d.clone());

        }

    }

    Ok(missing)

}

#[cfg(test)]

mod tests {

    use super::*;

    fn test_db() -> Db {

        let conn = Connection::open_in_memory().unwrap();

        conn.execute_batch(SCHEMA).unwrap();

        Arc::new(Mutex::new(conn))

    }

    fn sample(date: &str, artwork_id: i64) -> DailyArtwork {

        DailyArtwork {

            date: date.to_string(),

            artwork_id,

            title: "Test".to_string(),

            artist_display: Some("An Artist".to_string()),

            artist_title: None,

            date_display: None,

            medium_display: None,

            dimensions: None,

            place_of_origin: None,

            credit_line: None,

            description: None,

            short_description: None,

            image_id: "abc-123".to_string(),

            fetched_at: "2024-01-01T00:00:00Z".to_string(),

        }

    }

    #[test]

    fn insert_and_get() {

        let db = test_db();

        assert!(insert_daily(&db, &sample("2024-01-01", 1)).unwrap());

        let got = get_daily(&db, "2024-01-01").unwrap().unwrap();

        assert_eq!(got.artwork_id, 1);

    }

    #[test]

    fn duplicate_date_ignored() {

        let db = test_db();

        assert!(insert_daily(&db, &sample("2024-01-01", 1)).unwrap());

        assert!(!insert_daily(&db, &sample("2024-01-01", 2)).unwrap());

        assert_eq!(get_daily(&db, "2024-01-01").unwrap().unwrap().artwork_id, 1);

    }

    #[test]

    fn artwork_id_exists_works() {

        let db = test_db();

        insert_daily(&db, &sample("2024-01-01", 42)).unwrap();

        assert!(artwork_id_exists(&db, 42).unwrap());

        assert!(!artwork_id_exists(&db, 99).unwrap());

    }

    #[test]

    fn missing_dates_filter() {

        let db = test_db();

        insert_daily(&db, &sample("2024-01-01", 1)).unwrap();

        let dates = vec![

            "2024-01-01".to_string(),

            "2024-01-02".to_string(),

            "2024-01-03".to_string(),

        ];

        let missing = missing_dates(&db, &dates).unwrap();

        assert_eq!(missing, vec!["2024-01-02", "2024-01-03"]);

    }

    #[test]

    fn list_daily_desc() {

        let db = test_db();

        insert_daily(&db, &sample("2024-01-01", 1)).unwrap();

        insert_daily(&db, &sample("2024-01-03", 3)).unwrap();

        insert_daily(&db, &sample("2024-01-02", 2)).unwrap();

        let list = list_daily(&db, 10).unwrap();

        assert_eq!(list.len(), 3);

        assert_eq!(list[0].date, "2024-01-03");

        assert_eq!(list[2].date, "2024-01-01");

    }

}

mod aic;

mod db;

mod scheduler;

mod server;

#[tokio::main]

async fn main() {

    dotenvy::dotenv().ok();

    tracing_subscriber::fmt()

        .with_env_filter(

            tracing_subscriber::EnvFilter::try_from_default_env()

                .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info,easel=info")),

        )

        .init();

    server::run().await;

}

use std::sync::Arc;

use std::time::Duration;

use chrono::{Duration as ChronoDuration, NaiveDate, TimeZone, Utc};

use chrono_tz::Tz;

use crate::aic;

use crate::db::{self, DailyArtwork};

use crate::server::AppState;

pub async fn run(state: Arc<AppState>) {

    if let Err(e) = ensure_day(&state, &today_in_tz(&state.tz)).await {

        tracing::warn!("startup ensure_day failed: {e}");

    }

    if state.backfill_days > 0 {

        let dates = past_n_dates(&state.tz, state.backfill_days);

        match db::missing_dates(&state.db, &dates) {

            Ok(missing) => {

                tracing::info!(

                    "backfill: {} of last {} days missing",

                    missing.len(),

                    state.backfill_days

                );

                for d in missing {

                    if let Err(e) = ensure_day(&state, &d).await {

                        tracing::warn!("backfill {d} failed: {e}");

                    }

                }

            }

            Err(e) => tracing::error!("backfill missing_dates failed: {e}"),

        }

    }

    loop {

        let dur = duration_until_next_midnight(&state.tz);

        tracing::info!(

            "scheduler sleeping for {}s until next midnight in {}",

            dur.as_secs(),

            state.tz.name()

        );

        tokio::time::sleep(dur).await;

        let date = today_in_tz(&state.tz);

        if let Err(e) = ensure_day(&state, &date).await {

            tracing::warn!("scheduled ensure_day {date} failed: {e}");

        }

    }

}

pub async fn ensure_day(state: &AppState, date: &str) -> Result<(), String> {

    if db::get_daily(&state.db, date)

        .map_err(|e| e.to_string())?

        .is_some()

    {

        return Ok(());

    }

    let raw = aic::pick_unique(

        &state.http,

        &state.db,

        &state.classifications,

        state.max_dedup_retries,

    )

    .await?;

    let now = Utc::now().to_rfc3339();

    let daily: DailyArtwork = aic::raw_to_daily(raw, date.to_string(), now)

        .ok_or_else(|| "missing image_id on selected artwork".to_string())?;

    db::insert_daily(&state.db, &daily).map_err(|e| e.to_string())?;

    tracing::info!(

        "stored artwork {} for {} (image_id={})",

        daily.artwork_id,

        date,

        daily.image_id

    );

    Ok(())

}

pub fn today_in_tz(tz: &Tz) -> String {

    Utc::now()

        .with_timezone(tz)

        .date_naive()

        .format("%Y-%m-%d")

        .to_string()

}

pub fn past_n_dates(tz: &Tz, n: u32) -> Vec<String> {

    let today = Utc::now().with_timezone(tz).date_naive();

    (1..=n as i64)

        .filter_map(|i| today.checked_sub_signed(ChronoDuration::days(i)))

        .map(|d| d.format("%Y-%m-%d").to_string())

        .collect()

}

pub fn parse_date(s: &str) -> Option<NaiveDate> {

    NaiveDate::parse_from_str(s, "%Y-%m-%d").ok()

}

fn duration_until_next_midnight(tz: &Tz) -> Duration {

    let now = Utc::now().with_timezone(tz);

    let next_day = now.date_naive() + ChronoDuration::days(1);

    let next_midnight = tz

        .from_local_datetime(&next_day.and_hms_opt(0, 0, 1).expect("valid time"))

        .single()

        .or_else(|| {

            tz.from_local_datetime(&next_day.and_hms_opt(0, 0, 1).expect("valid time"))

                .earliest()

        })

        .unwrap_or_else(|| now + ChronoDuration::days(1));

    let delta = next_midnight.signed_duration_since(now);

    delta

        .to_std()

        .unwrap_or_else(|_| Duration::from_secs(60 * 60))

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn past_n_dates_count() {

        let tz: Tz = "UTC".parse().unwrap();

        let dates = past_n_dates(&tz, 5);

        assert_eq!(dates.len(), 5);

    }

    #[test]

    fn past_n_dates_excludes_today() {

        let tz: Tz = "UTC".parse().unwrap();

        let today = today_in_tz(&tz);

        let dates = past_n_dates(&tz, 3);

        assert!(!dates.contains(&today));

    }

    #[test]

    fn parse_date_valid_invalid() {

        assert!(parse_date("2024-05-01").is_some());

        assert!(parse_date("2024-13-01").is_none());

        assert!(parse_date("notadate").is_none());

    }

}

use std::sync::Arc;

use askama::Template;

use axum::{

    extract::{Path, State},

    http::{header, StatusCode},

    response::{Html, IntoResponse, Json, Response},

    routing::get,

    Router,

};

use chrono::Utc;

use rust_embed::Embed;

use serde::Serialize;

use crate::db::{self, DailyArtwork, Db};

use crate::scheduler;

#[derive(Embed)]

#[folder = "static/"]

struct Static;

pub struct AppState {

    pub db: Db,

    pub http: reqwest::Client,

    pub tz: chrono_tz::Tz,

    pub classifications: Vec<String>,

    pub backfill_days: u32,

    pub max_dedup_retries: u32,

}

#[derive(Template)]

#[template(path = "index.html")]

struct IndexTemplate {

    today_date: String,

    artwork: Option<ArtworkView>,

    archive: Vec<ArchiveRow>,

}

#[derive(Template)]

#[template(path = "day.html")]

struct DayTemplate {

    date: String,

    artwork: ArtworkView,

    archive: Vec<ArchiveRow>,

}

#[derive(Template)]

#[template(path = "archive.html")]

struct ArchiveTemplate {

    archive: Vec<ArchiveRow>,

}

#[derive(Template)]

#[template(path = "error.html")]

struct ErrorTemplate {

    title: String,

    message: String,

}

struct ArtworkView {

    date: String,

    title: String,

    artist_display: String,

    date_display: String,

    medium_display: String,

    dimensions: String,

    place_of_origin: String,

    credit_line: String,

    short_description: String,

    image_url: String,

    source_url: String,

}

struct ArchiveRow {

    date: String,

    title: String,

    artist: String,

}

fn iiif_url(image_id: &str) -> String {

    format!("https://www.artic.edu/iiif/2/{image_id}/full/843,/0/default.jpg")

}

fn source_url(artwork_id: i64) -> String {

    format!("https://www.artic.edu/artworks/{artwork_id}")

}

fn to_view(a: DailyArtwork) -> ArtworkView {

    ArtworkView {

        date: a.date,

        title: a.title,

        artist_display: a.artist_display.unwrap_or_default(),

        date_display: a.date_display.unwrap_or_default(),

        medium_display: a.medium_display.unwrap_or_default(),

        dimensions: a.dimensions.unwrap_or_default(),

        place_of_origin: a.place_of_origin.unwrap_or_default(),

        credit_line: a.credit_line.unwrap_or_default(),

        short_description: a.short_description.unwrap_or_default(),

        image_url: iiif_url(&a.image_id),

        source_url: source_url(a.artwork_id),

    }

}

fn to_archive_row(a: &DailyArtwork) -> ArchiveRow {

    ArchiveRow {

        date: a.date.clone(),

        title: a.title.clone(),

        artist: a

            .artist_title

            .clone()

            .or_else(|| a.artist_display.clone())

            .unwrap_or_default(),

    }

}

fn render<T: Template>(t: T) -> Response {

    match t.render() {

        Ok(body) => Html(body).into_response(),

        Err(e) => {

            tracing::error!("render failed: {e}");

            (StatusCode::INTERNAL_SERVER_ERROR, "render error").into_response()

        }

    }

}

async fn index_handler(State(state): State<Arc<AppState>>) -> Response {

    let today = scheduler::today_in_tz(&state.tz);

    let artwork = match db::get_daily(&state.db, &today) {

        Ok(Some(a)) => Some(to_view(a)),

        Ok(None) => None,

        Err(e) => {

            tracing::error!("index db error: {e}");

            return render(ErrorTemplate {

                title: "Error".to_string(),

                message: "Could not load today's artwork.".to_string(),

            });

        }

    };

    let archive = db::list_daily(&state.db, 30)

        .unwrap_or_default()

        .iter()

        .map(to_archive_row)

        .collect();

    render(IndexTemplate {

        today_date: today,

        artwork,

        archive,

    })

}

async fn day_handler(

    State(state): State<Arc<AppState>>,

    Path(date): Path<String>,

) -> Response {

    let parsed = match scheduler::parse_date(&date) {

        Some(d) => d,

        None => {

            return (

                StatusCode::BAD_REQUEST,

                render(ErrorTemplate {

                    title: "Invalid date".to_string(),

                    message: format!("'{date}' is not a valid YYYY-MM-DD date."),

                }),

            )

                .into_response();

        }

    };

    let today = scheduler::today_in_tz(&state.tz);

    if date.as_str() > today.as_str() {

        return (

            StatusCode::NOT_FOUND,

            render(ErrorTemplate {

                title: "Not yet".to_string(),

                message: format!(

                    "{} is in the future. The next day's artwork is not available until midnight {}.",

                    parsed, state.tz.name()

                ),

            }),

        )

            .into_response();

    }

    let artwork = match db::get_daily(&state.db, &date) {

        Ok(Some(a)) => to_view(a),

        Ok(None) => {

            return (

                StatusCode::NOT_FOUND,

                render(ErrorTemplate {

                    title: "Not found".to_string(),

                    message: format!("No artwork stored for {date}."),

                }),

            )

                .into_response();

        }

        Err(e) => {

            tracing::error!("day db error: {e}");

            return (

                StatusCode::INTERNAL_SERVER_ERROR,

                render(ErrorTemplate {

                    title: "Error".to_string(),

                    message: "Database error.".to_string(),

                }),

            )

                .into_response();

        }

    };

    let archive = db::list_daily(&state.db, 30)

        .unwrap_or_default()

        .iter()

        .map(to_archive_row)

        .collect();

    render(DayTemplate {

        date,

        artwork,

        archive,

    })

}

async fn archive_handler(State(state): State<Arc<AppState>>) -> Response {

    let archive = db::list_daily(&state.db, 1000)

        .unwrap_or_default()

        .iter()

        .map(to_archive_row)

        .collect();

    render(ArchiveTemplate { archive })

}

#[derive(Serialize)]

struct ApiArtwork<'a> {

    date: &'a str,

    artwork_id: i64,

    title: &'a str,

    artist_display: Option<&'a str>,

    date_display: Option<&'a str>,

    medium_display: Option<&'a str>,

    dimensions: Option<&'a str>,

    place_of_origin: Option<&'a str>,

    credit_line: Option<&'a str>,

    short_description: Option<&'a str>,

    image_id: &'a str,

    image_url: String,

    source_url: String,

}

fn to_api<'a>(a: &'a DailyArtwork) -> ApiArtwork<'a> {

    ApiArtwork {

        date: &a.date,

        artwork_id: a.artwork_id,

        title: &a.title,

        artist_display: a.artist_display.as_deref(),

        date_display: a.date_display.as_deref(),

        medium_display: a.medium_display.as_deref(),

        dimensions: a.dimensions.as_deref(),

        place_of_origin: a.place_of_origin.as_deref(),

        credit_line: a.credit_line.as_deref(),

        short_description: a.short_description.as_deref(),

        image_id: &a.image_id,

        image_url: iiif_url(&a.image_id),

        source_url: source_url(a.artwork_id),

    }

}

async fn api_today(State(state): State<Arc<AppState>>) -> Response {

    let today = scheduler::today_in_tz(&state.tz);

    match db::get_daily(&state.db, &today) {

        Ok(Some(a)) => Json(to_api(&a)).into_response(),

        Ok(None) => (

            StatusCode::NOT_FOUND,

            Json(serde_json::json!({"error": "today not yet populated"})),

        )

            .into_response(),

        Err(e) => {

            tracing::error!("api_today db error: {e}");

            StatusCode::INTERNAL_SERVER_ERROR.into_response()

        }

    }

}

async fn api_day(

    State(state): State<Arc<AppState>>,

    Path(date): Path<String>,

) -> Response {

    if scheduler::parse_date(&date).is_none() {

        return (

            StatusCode::BAD_REQUEST,

            Json(serde_json::json!({"error": "invalid date format"})),

        )

            .into_response();

    }

    let today = scheduler::today_in_tz(&state.tz);

    if date.as_str() > today.as_str() {

        return (

            StatusCode::NOT_FOUND,

            Json(serde_json::json!({"error": "future date"})),

        )

            .into_response();

    }

    match db::get_daily(&state.db, &date) {

        Ok(Some(a)) => Json(to_api(&a)).into_response(),

        Ok(None) => (

            StatusCode::NOT_FOUND,

            Json(serde_json::json!({"error": "no record for date"})),

        )

            .into_response(),

        Err(e) => {

            tracing::error!("api_day db error: {e}");

            StatusCode::INTERNAL_SERVER_ERROR.into_response()

        }

    }

}

async fn api_archive(State(state): State<Arc<AppState>>) -> Response {

    match db::list_daily(&state.db, 1000) {

        Ok(items) => {

            let out: Vec<ApiArtwork> = items.iter().map(to_api).collect();

            Json(out).into_response()

        }

        Err(e) => {

            tracing::error!("api_archive db error: {e}");

            StatusCode::INTERNAL_SERVER_ERROR.into_response()

        }

    }

}

async fn static_handler(Path(path): Path<String>) -> Response {

    match Static::get(&path) {

        Some(file) => {

            let mime = mime_guess::from_path(&path).first_or_octet_stream();

            (

                [(header::CONTENT_TYPE, mime.as_ref())],

                file.data.to_vec(),

            )

                .into_response()

        }

        None => StatusCode::NOT_FOUND.into_response(),

    }

}

pub async fn run() {

    let db_path = std::env::var("EASEL_DB_PATH").unwrap_or_else(|_| "easel.sqlite".to_string());

    let tz_name = std::env::var("EASEL_TIMEZONE").unwrap_or_else(|_| "UTC".to_string());

    let tz: chrono_tz::Tz = tz_name.parse().unwrap_or_else(|_| {

        tracing::warn!("invalid EASEL_TIMEZONE={tz_name}, falling back to UTC");

        chrono_tz::UTC

    });

    let classifications: Vec<String> = std::env::var("EASEL_CLASSIFICATIONS")

        .unwrap_or_else(|_| "painting".to_string())

        .split(',')

        .map(|s| s.trim().to_string())

        .filter(|s| !s.is_empty())

        .collect();

    if classifications.is_empty() {

        panic!("EASEL_CLASSIFICATIONS resolved to empty list");

    }

    let backfill_days: u32 = std::env::var("EASEL_BACKFILL_DAYS")

        .ok()

        .and_then(|v| v.parse().ok())

        .unwrap_or(0);

    let max_dedup_retries: u32 = std::env::var("EASEL_MAX_DEDUP_RETRIES")

        .ok()

        .and_then(|v| v.parse().ok())

        .unwrap_or(10);

    let db = db::init_db(&db_path);

    let http = crate::aic::build_client();

    let state = Arc::new(AppState {

        db,

        http,

        tz,

        classifications: classifications.clone(),

        backfill_days,

        max_dedup_retries,

    });