//! Webhooks (hub spec §12.2): queueing an event for every hook that wants

//! it, signing and delivering with retries, and the payload envelope.

use crate::db::{self, hooks as hdb};

use crate::Shared;

use hub_api::WebhookEnvelope;

/// Queue `event` for the hooks of a repository (and its organisation).

pub async fn emit(app: &Shared, repo: &db::repos::RepoRow, event: &str, actor: &str, data: serde_json::Value) {

    let hooks = match hdb::hooks_hearing(&app.db, repo.id, &repo.owner).await {

        Ok(h) => h,

        Err(e) => {

            tracing::warn!("hooks: {e}");

            return;

        }

    };

    if hooks.is_empty() {

        return;

    }

    let repository = hub_api::Repository {

        owner: repo.owner.clone(),

        name: repo.name.clone(),

        description: repo.description.clone(),

        default_bookmark: repo.default_bookmark.clone(),

        visibility: repo.visibility(),

        created_ms: repo.created_ms,

        updated_ms: repo.updated_ms,

        clone_url: format!("{}/{}", app.config.base_url(), repo.slug()),

    };

    for h in hooks.into_iter().filter(|h| h.wants(event)) {

        let delivery = crate::auth::random_hex(16);

        let envelope = WebhookEnvelope {

            event: event.into(),

            delivery: delivery.clone(),

            repository: Some(repository.clone()),

            actor: actor.into(),

            at_ms: db::now_ms(),

            data: data.clone(),

        };

        let payload = serde_json::to_string(&envelope).unwrap_or_default();

        if let Err(e) = hdb::queue_delivery(&app.db, h.id, &delivery, event, &payload).await {

            tracing::warn!("queueing delivery: {e}");

        }

    }

    app.events.notify_deliveries();

}

/// `X-Oxyhub-Signature` for a body: keyed BLAKE3 with the hook's secret.

pub fn signature(secret: &str, body: &[u8]) -> String {

    let key = blake3::hash(secret.as_bytes());

    format!("blake3-keyed={}", hex::encode(blake3::keyed_hash(key.as_bytes(), body).as_bytes()))

}

/// Deliver everything that is due; returns how many were attempted.

pub async fn deliver_due(app: &Shared) -> usize {

    let due = match hdb::due_deliveries(&app.db, 50).await {

        Ok(d) => d,

        Err(_) => return 0,

    };

    let client = reqwest::Client::builder()

        .timeout(std::time::Duration::from_secs(20))

        .user_agent(format!("oxygenhub/{}", env!("CARGO_PKG_VERSION")))

        .build();

    let Ok(client) = client else { return 0 };

    let mut n = 0;

    for d in due {

        let Ok(Some(hook)) = hdb::hook(&app.db, d.hook_id).await else { continue };

        n += 1;

        let (status, response) = match client

            .post(&hook.url)

            .header("content-type", "application/json")

            .header("x-oxyhub-event", &d.event)

            .header("x-oxyhub-delivery", &d.delivery)

            .header("x-oxyhub-signature", signature(&hook.secret, d.payload.as_bytes()))

            .body(d.payload.clone())

            .send()

            .await

        {

            Ok(r) => {

                let status = r.status().as_u16() as i64;

                let text = r.text().await.unwrap_or_default();

                (Some(status), text)

            }

            Err(e) => (None, e.to_string()),

        };

        hdb::record_attempt(&app.db, d.id, d.attempts, status, &response).await.ok();

    }

    n

}

/// The background worker: delivers when nudged and every minute anyway.

pub async fn worker(app: Shared) {

    let mut rx = app.events.deliveries.subscribe();

    loop {

        deliver_due(&app).await;

        let cutoff = db::now_ms() - app.config.retention.webhook_log_days as i64 * 86_400_000;

        hdb::prune_deliveries(&app.db, cutoff).await.ok();

        tokio::select! {

            _ = rx.recv() => {}

            _ = tokio::time::sleep(std::time::Duration::from_secs(60)) => {}

        }

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn signatures_are_keyed() {

        let a = signature("s1", b"body");

        assert!(a.starts_with("blake3-keyed="));

        assert_ne!(a, signature("s2", b"body"));

        assert_ne!(a, signature("s1", b"other"));

    }

}