//! Webhooks, their delivery log, and checks (hub spec §12.2, §13.1).

use super::{now_ms, Pool};
use sqlx::FromRow;

#[derive(Clone, Debug, FromRow)]
pub struct Hook {
    pub id: i64,
    pub repo_id: Option<i64>,
    pub org_id: Option<i64>,
    pub url: String,
    pub secret: String,
    pub events: String,
    pub active: bool,
    pub created_ms: i64,
    /// `oxygenhub`, `discord` or `slack`.
    pub format: String,
}

/// The formats a webhook can be delivered in.
pub const FORMATS: [&str; 3] = ["oxygenhub", "discord", "slack"];

/// The format a URL most likely wants: Discord and Slack webhooks accept
/// only their own bodies.
pub fn format_for_url(url: &str) -> &'static str {
    let host = url.split("://").nth(1).unwrap_or("").split(['/', ':']).next().unwrap_or("").to_ascii_lowercase();
    if matches!(host.as_str(), "discord.com" | "discordapp.com" | "canary.discord.com" | "ptb.discord.com")
        && url.contains("/api/webhooks/")
    {
        "discord"
    } else if host == "hooks.slack.com" {
        "slack"
    } else {
        "oxygenhub"
    }
}

/// A URL for display: scheme, host and path, with long segments (the tokens
/// Discord and Slack keep in the path) and any query cut to a few characters.
pub fn masked_url(url: &str) -> String {
    let (scheme, rest) = url.split_once("://").unwrap_or(("", url));
    let (path, query) = rest.split_once('?').map(|(p, q)| (p, Some(q))).unwrap_or((rest, None));
    let parts: Vec<String> =
        path.split('/')
            .enumerate()
            .map(|(i, seg)| {
                if i > 0 && seg.chars().count() > 14 {
                    format!("{}…", seg.chars().take(4).collect::<String>())
                } else {
                    seg.to_string()
                }
            })
            .collect();
    let mut out = if scheme.is_empty() { parts.join("/") } else { format!("{scheme}://{}", parts.join("/")) };
    if query.is_some() {
        out.push_str("?…");
    }
    out
}

impl Hook {
    /// Whether the hook wants `event` (`*`, or a comma list of prefixes such as `push,proposal`).
    pub fn wants(&self, event: &str) -> bool {
        self.active && self.events.split(',').map(str::trim).any(|e| e == "*" || event == e || event.starts_with(&format!("{e}.")))
    }
}

#[derive(Clone, Debug, FromRow)]
pub struct Delivery {
    pub id: i64,
    pub hook_id: i64,
    pub delivery: String,
    pub event: String,
    pub payload: String,
    pub created_ms: i64,
    pub attempts: i64,
    pub next_ms: i64,
    pub status: Option<i64>,
    pub response: String,
    pub delivered_ms: Option<i64>,
}

pub async fn hooks_for_repo(pool: &Pool, repo_id: i64) -> sqlx::Result<Vec<Hook>> {
    sqlx::query_as("SELECT * FROM hooks WHERE repo_id = $1 ORDER BY id").bind(repo_id).fetch_all(pool).await
}

pub async fn hooks_for_org(pool: &Pool, org_id: i64) -> sqlx::Result<Vec<Hook>> {
    sqlx::query_as("SELECT * FROM hooks WHERE org_id = $1 ORDER BY id").bind(org_id).fetch_all(pool).await
}

/// Every hook that should hear about an event in a repository: its own
/// and its organisation's.
pub async fn hooks_hearing(pool: &Pool, repo_id: i64, owner: &str) -> sqlx::Result<Vec<Hook>> {
    let mut out = hooks_for_repo(pool, repo_id).await?;
    if let Some(org) = super::accounts::org_by_name(pool, owner).await? {
        out.extend(hooks_for_org(pool, org.id).await?);
    }
    Ok(out)
}

pub async fn hook(pool: &Pool, id: i64) -> sqlx::Result<Option<Hook>> {
    sqlx::query_as("SELECT * FROM hooks WHERE id = $1").bind(id).fetch_optional(pool).await
}

pub async fn create_hook(
    pool: &Pool,
    repo_id: Option<i64>,
    org_id: Option<i64>,
    url: &str,
    secret: &str,
    events: &str,
) -> sqlx::Result<Hook> {
    sqlx::query_as(
        "INSERT INTO hooks (repo_id, org_id, url, secret, events, created_ms, format) VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING *",
    )
    .bind(repo_id)
    .bind(org_id)
    .bind(url)
    .bind(secret)
    .bind(events)
    .bind(now_ms())
    .bind(format_for_url(url))
    .fetch_one(pool)
    .await
}

/// Change a hook; `None` keeps the URL or secret as it is.
pub async fn update_hook(
    pool: &Pool,
    id: i64,
    url: Option<&str>,
    secret: Option<&str>,
    events: &str,
    format: &str,
    active: bool,
) -> sqlx::Result<()> {
    sqlx::query(
        "UPDATE hooks SET url = COALESCE($1, url), secret = COALESCE($2, secret), events = $3, format = $4, active = $5 WHERE id = $6",
    )
    .bind(url)
    .bind(secret)
    .bind(events)
    .bind(format)
    .bind(active)
    .bind(id)
    .execute(pool)
    .await?;
    Ok(())
}

pub async fn set_hook_format(pool: &Pool, id: i64, format: &str) -> sqlx::Result<()> {
    sqlx::query("UPDATE hooks SET format = $1 WHERE id = $2").bind(format).bind(id).execute(pool).await?;
    Ok(())
}

/// The newest delivery that was attempted, for the settings table.
pub async fn last_attempt(pool: &Pool, hook_id: i64) -> sqlx::Result<Option<Delivery>> {
    sqlx::query_as("SELECT * FROM deliveries WHERE hook_id = $1 AND attempts > 0 ORDER BY id DESC LIMIT 1")
        .bind(hook_id)
        .fetch_optional(pool)
        .await
}

pub async fn set_hook_active(pool: &Pool, id: i64, active: bool) -> sqlx::Result<()> {
    sqlx::query("UPDATE hooks SET active = $1 WHERE id = $2").bind(active).bind(id).execute(pool).await?;
    Ok(())
}

pub async fn delete_hook(pool: &Pool, id: i64) -> sqlx::Result<()> {
    sqlx::query("DELETE FROM hooks WHERE id = $1").bind(id).execute(pool).await?;
    Ok(())
}

/// The most deliveries one hook may have waiting (#220): beyond it, new
/// events for that hook are dropped (and logged) until it catches up.
pub const MAX_WAITING: i64 = 1000;

/// Queue a delivery; `Ok(None)` when the hook already has
/// [`MAX_WAITING`] deliveries waiting, so nothing was queued.
pub async fn queue_delivery(pool: &Pool, hook_id: i64, delivery: &str, event: &str, payload: &str) -> sqlx::Result<Option<i64>> {
    let waiting: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM deliveries WHERE hook_id = $1 AND delivered_ms IS NULL AND next_ms < $2")
        .bind(hook_id)
        .bind(i64::MAX / 4)
        .fetch_one(pool)
        .await?;
    if waiting >= MAX_WAITING {
        return Ok(None);
    }
    let now = now_ms();
    sqlx::query_scalar(
        "INSERT INTO deliveries (hook_id, delivery, event, payload, created_ms, next_ms) VALUES ($1, $2, $3, $4, $5, $6) RETURNING id",
    )
    .bind(hook_id)
    .bind(delivery)
    .bind(event)
    .bind(payload)
    .bind(now)
    .bind(now)
    .fetch_one(pool)
    .await
    .map(Some)
}

pub async fn due_deliveries(pool: &Pool, limit: i64) -> sqlx::Result<Vec<Delivery>> {
    sqlx::query_as("SELECT * FROM deliveries WHERE delivered_ms IS NULL AND next_ms <= $1 ORDER BY next_ms LIMIT $2")
        .bind(now_ms())
        .bind(limit)
        .fetch_all(pool)
        .await
}

pub async fn deliveries_for_hook(pool: &Pool, hook_id: i64, limit: i64) -> sqlx::Result<Vec<Delivery>> {
    sqlx::query_as("SELECT * FROM deliveries WHERE hook_id = $1 ORDER BY created_ms DESC, id DESC LIMIT $2")
        .bind(hook_id)
        .bind(limit)
        .fetch_all(pool)
        .await
}

pub async fn delivery(pool: &Pool, id: i64) -> sqlx::Result<Option<Delivery>> {
    sqlx::query_as("SELECT * FROM deliveries WHERE id = $1").bind(id).fetch_optional(pool).await
}

/// Record an attempt: done on a 2xx, else retried with backoff up to a day.
pub async fn record_attempt(pool: &Pool, id: i64, attempts: i64, status: Option<i64>, response: &str) -> sqlx::Result<()> {
    let ok = status.is_some_and(|s| (200..300).contains(&s));
    let now = now_ms();
    let delivered: Option<i64> = if ok { Some(now) } else { None };
    // 1 min, 5 min, 30 min, 2 h, 6 h, then give up after a day's worth.
    let backoff_ms = [60_000i64, 300_000, 1_800_000, 7_200_000, 21_600_000];
    let next = if ok || attempts as usize >= backoff_ms.len() { i64::MAX / 4 } else { now + backoff_ms[attempts as usize] };
    sqlx::query("UPDATE deliveries SET attempts = $1, status = $2, response = $3, delivered_ms = $4, next_ms = $5 WHERE id = $6")
        .bind(attempts + 1)
        .bind(status)
        .bind(response.chars().take(2000).collect::<String>())
        .bind(delivered)
        .bind(next)
        .bind(id)
        .execute(pool)
        .await?;
    Ok(())
}

/// Requeue a delivery for an immediate retry.
pub async fn redeliver(pool: &Pool, id: i64) -> sqlx::Result<()> {
    sqlx::query("UPDATE deliveries SET delivered_ms = NULL, next_ms = $1 WHERE id = $2").bind(now_ms()).bind(id).execute(pool).await?;
    Ok(())
}

pub async fn prune_deliveries(pool: &Pool, older_than_ms: i64) -> sqlx::Result<()> {
    sqlx::query("DELETE FROM deliveries WHERE created_ms < $1").bind(older_than_ms).execute(pool).await?;
    Ok(())
}

// ------------------------------------------------------------------ checks

#[derive(Clone, Debug, FromRow)]
pub struct Check {
    pub id: i64,
    pub repo_id: i64,
    pub state: String,
    pub name: String,
    pub status: String,
    pub summary: String,
    pub url: String,
    pub reporter_id: Option<i64>,
    pub reporter: String,
    pub seal: String,
    pub started_ms: i64,
    pub finished_ms: Option<i64>,
}

impl Check {
    pub fn done(&self) -> bool {
        matches!(self.status.as_str(), "passed" | "failed" | "cancelled" | "skipped")
    }
}

pub async fn checks_for_state(pool: &Pool, repo_id: i64, state: &str) -> sqlx::Result<Vec<Check>> {
    sqlx::query_as("SELECT * FROM checks WHERE repo_id = $1 AND state = $2 ORDER BY name").bind(repo_id).bind(state).fetch_all(pool).await
}

/// Create or update a check by `(state, name)`.
/// A check as a reporter posts it.
pub struct CheckReport<'a> {
    pub state: &'a str,
    pub name: &'a str,
    pub status: &'a str,
    pub summary: &'a str,
    pub url: &'a str,
    pub reporter: Option<(i64, &'a str)>,
    pub seal: &'a str,
}

pub async fn upsert_check(pool: &Pool, repo_id: i64, c: CheckReport<'_>) -> sqlx::Result<Check> {
    let CheckReport { state, name, status, summary, url, reporter, seal } = c;
    let now = now_ms();
    let finished: Option<i64> = if matches!(status, "passed" | "failed" | "cancelled" | "skipped") { Some(now) } else { None };
    sqlx::query_as(
        "INSERT INTO checks (repo_id, state, name, status, summary, url, reporter_id, reporter, seal, started_ms, finished_ms) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) \
         ON CONFLICT (repo_id, state, name) DO UPDATE SET status = excluded.status, summary = excluded.summary, url = excluded.url, reporter_id = excluded.reporter_id, reporter = excluded.reporter, seal = CASE WHEN excluded.seal = '' THEN checks.seal ELSE excluded.seal END, finished_ms = excluded.finished_ms RETURNING *",
    )
    .bind(repo_id)
    .bind(state)
    .bind(name)
    .bind(status)
    .bind(summary)
    .bind(url)
    .bind(reporter.map(|r| r.0))
    .bind(reporter.map(|r| r.1).unwrap_or(""))
    .bind(seal)
    .bind(now)
    .bind(finished)
    .fetch_one(pool)
    .await
}

pub async fn required_checks(pool: &Pool, repo_id: i64) -> sqlx::Result<Vec<String>> {
    let s: String = sqlx::query_scalar("SELECT required_checks FROM repositories WHERE id = $1").bind(repo_id).fetch_one(pool).await?;
    Ok(s.split(',').map(str::trim).filter(|x| !x.is_empty()).map(String::from).collect())
}

pub async fn set_required_checks(pool: &Pool, repo_id: i64, names: &[String]) -> sqlx::Result<()> {
    sqlx::query("UPDATE repositories SET required_checks = $1 WHERE id = $2").bind(names.join(",")).bind(repo_id).execute(pool).await?;
    Ok(())
}