//! Phones as a second factor (oxygenhub#356): their keys, and the
//! approvals they are asked for.

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

/// A phone that approves for its account: the Keystore key of the sign-in
/// (token) it made, as an uncompressed P-256 point in hex.
#[derive(Clone, Debug, FromRow)]
pub struct Authenticator {
    pub token_id: i64,
    pub account_id: i64,
    pub name: String,
    pub public_key: String,
    pub created_ms: i64,
    pub last_used_ms: i64,
}

const AUTH_COLUMNS: &str = "token_id, account_id, name, public_key, created_ms, last_used_ms";

/// Register (or replace) the key of the phone signed in with `token_id`.
pub async fn add_authenticator(pool: &Pool, token_id: i64, account_id: i64, name: &str, public_key: &str) -> sqlx::Result<()> {
    sqlx::query(
        "INSERT INTO authenticators (token_id, account_id, name, public_key, created_ms) VALUES ($1, $2, $3, $4, $5) \
         ON CONFLICT (token_id) DO UPDATE SET name = excluded.name, public_key = excluded.public_key, created_ms = excluded.created_ms",
    )
    .bind(token_id)
    .bind(account_id)
    .bind(name)
    .bind(public_key)
    .bind(now_ms())
    .execute(pool)
    .await?;
    Ok(())
}

pub async fn authenticators(pool: &Pool, account_id: i64) -> sqlx::Result<Vec<Authenticator>> {
    sqlx::query_as(&format!("SELECT {AUTH_COLUMNS} FROM authenticators WHERE account_id = $1 ORDER BY created_ms"))
        .bind(account_id)
        .fetch_all(pool)
        .await
}

pub async fn authenticator(pool: &Pool, token_id: i64) -> sqlx::Result<Option<Authenticator>> {
    sqlx::query_as(&format!("SELECT {AUTH_COLUMNS} FROM authenticators WHERE token_id = $1")).bind(token_id).fetch_optional(pool).await
}

/// Remove one of the account's phones; false when it had none by that id.
pub async fn remove_authenticator(pool: &Pool, account_id: i64, token_id: i64) -> sqlx::Result<bool> {
    Ok(sqlx::query("DELETE FROM authenticators WHERE account_id = $1 AND token_id = $2")
        .bind(account_id)
        .bind(token_id)
        .execute(pool)
        .await?
        .rows_affected()
        > 0)
}

/// An approval asked of the account's phones: what for, the number the
/// page shows among the three the phone offers, and what became of it.
#[derive(Clone, Debug, FromRow)]
pub struct Approval {
    pub id: String,
    pub account_id: i64,
    /// `signin` or `stepup`.
    pub kind: String,
    pub what: String,
    pub number: i64,
    /// The three numbers the phone offers, comma-separated.
    pub choices: String,
    /// For a step-up: the browser session it makes fresh.
    pub session_id: Option<i64>,
    pub created_ms: i64,
    pub expires_ms: i64,
    /// `pending`, `approved`, `denied`, or `used` once a sign-in took it.
    pub state: String,
    pub decided_ms: i64,
    pub decided_by: Option<i64>,
}

const COLUMNS: &str = "id, account_id, kind, what, number, choices, session_id, created_ms, expires_ms, state, decided_ms, decided_by";

pub struct NewApproval<'a> {
    pub id: &'a str,
    pub account_id: i64,
    pub kind: &'a str,
    pub what: &'a str,
    pub number: i64,
    pub choices: &'a str,
    pub session_id: Option<i64>,
    pub expires_ms: i64,
}

pub async fn create(pool: &Pool, a: NewApproval<'_>) -> sqlx::Result<()> {
    sqlx::query(
        "INSERT INTO approvals (id, account_id, kind, what, number, choices, session_id, created_ms, expires_ms) \
         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)",
    )
    .bind(a.id)
    .bind(a.account_id)
    .bind(a.kind)
    .bind(a.what)
    .bind(a.number)
    .bind(a.choices)
    .bind(a.session_id)
    .bind(now_ms())
    .bind(a.expires_ms)
    .execute(pool)
    .await?;
    Ok(())
}

pub async fn get(pool: &Pool, id: &str) -> sqlx::Result<Option<Approval>> {
    sqlx::query_as(&format!("SELECT {COLUMNS} FROM approvals WHERE id = $1")).bind(id).fetch_optional(pool).await
}

/// The account's approvals still waiting at `now`, newest first.
pub async fn pending(pool: &Pool, account_id: i64, now: i64) -> sqlx::Result<Vec<Approval>> {
    sqlx::query_as(&format!(
        "SELECT {COLUMNS} FROM approvals WHERE account_id = $1 AND state = 'pending' AND expires_ms > $2 ORDER BY created_ms DESC"
    ))
    .bind(account_id)
    .bind(now)
    .fetch_all(pool)
    .await
}

/// Decide a pending approval, once: false when it was no longer pending
/// or had expired.
pub async fn decide(pool: &Pool, id: &str, state: &str, by: i64, now: i64) -> sqlx::Result<bool> {
    let done = sqlx::query(
        "UPDATE approvals SET state = $1, decided_ms = $2, decided_by = $3 WHERE id = $4 AND state = 'pending' AND expires_ms > $2",
    )
    .bind(state)
    .bind(now)
    .bind(by)
    .bind(id)
    .execute(pool)
    .await?
    .rows_affected()
        > 0;
    if done && state == "approved" {
        sqlx::query("UPDATE authenticators SET last_used_ms = $1 WHERE token_id = $2").bind(now).bind(by).execute(pool).await?;
    }
    Ok(done)
}

/// Take an approved sign-in approval for the sign-in it was made for,
/// once: false when it is not approved, or was taken already.
pub async fn take(pool: &Pool, id: &str, account_id: i64) -> sqlx::Result<bool> {
    Ok(sqlx::query("UPDATE approvals SET state = 'used' WHERE id = $1 AND account_id = $2 AND state = 'approved' AND kind = 'signin'")
        .bind(id)
        .bind(account_id)
        .execute(pool)
        .await?
        .rows_affected()
        > 0)
}

/// Approvals that ended a day ago or more are of no further use.
pub async fn sweep(pool: &Pool, now: i64) -> sqlx::Result<u64> {
    Ok(sqlx::query("DELETE FROM approvals WHERE expires_ms < $1").bind(now - 86_400_000).execute(pool).await?.rows_affected())
}