//! Phone alerts (oxygenhub-android#16, oxygenhub-gcp decision 0008): each
//! notification an account is told also goes to its phones through Firebase
//! Cloud Messaging, sealed to each phone's key (`flow_core::alert`), so the
//! push service carries only ciphertext and a wake-up.
//!
//! The hub sends as the service account its VM runs as: the metadata
//! server's token, kept until a minute before it expires. Off while
//! `[push] fcm_project` is empty.

use crate::db::push as pdb;
use crate::Shared;
use std::sync::Mutex;
use std::time::{Duration, Instant};

/// Most phones one account's alert goes to.
const MOST_DEVICES: usize = 20;

static TOKEN: Mutex<Option<(String, Instant)>> = Mutex::new(None);

/// What a phone is told, before it is sealed: small, as a message's data
/// is at most 4 KB.
#[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
pub struct Alert {
    pub kind: String,
    pub title: String,
    pub url: String,
}

/// Whether alerts are on.
pub fn enabled(app: &Shared) -> bool {
    !app.config.push.fcm_project.is_empty()
}

/// Send `alert` to every phone of `account_id`, in the background.
pub fn send(app: &Shared, account_id: i64, alert: Alert) {
    if !enabled(app) {
        return;
    }
    let app = app.clone();
    tokio::spawn(async move {
        if let Err(e) = send_now(&app, account_id, &alert).await {
            tracing::warn!("push: alert for account {account_id}: {e}");
        }
    });
}

async fn access_token(app: &Shared, client: &reqwest::Client) -> Result<String, String> {
    if let Some((t, until)) = TOKEN.lock().unwrap().clone() {
        if Instant::now() < until {
            return Ok(t);
        }
    }
    #[derive(serde::Deserialize)]
    struct Got {
        access_token: String,
        expires_in: u64,
    }
    let got: Got = client
        .get(&app.config.push.token_url)
        .header("Metadata-Flavor", "Google")
        .send()
        .await
        .and_then(|r| r.error_for_status())
        .map_err(|e| format!("the metadata server's token: {e}"))?
        .json()
        .await
        .map_err(|e| format!("the metadata server's token: {e}"))?;
    let until = Instant::now() + Duration::from_secs(got.expires_in.saturating_sub(60));
    *TOKEN.lock().unwrap() = Some((got.access_token.clone(), until));
    Ok(got.access_token)
}

/// Send `alert` to each of the account's phones now; a phone Cloud
/// Messaging no longer knows is forgotten.
pub async fn send_now(app: &Shared, account_id: i64, alert: &Alert) -> Result<usize, String> {
    let devices = pdb::of_account(&app.db, account_id).await.map_err(|e| e.to_string())?;
    if devices.is_empty() {
        return Ok(0);
    }
    let client = reqwest::Client::builder().timeout(Duration::from_secs(20)).build().map_err(|e| e.to_string())?;
    let token = access_token(app, &client).await?;
    let plain = serde_json::to_vec(alert).map_err(|e| e.to_string())?;
    let url = format!("{}/v1/projects/{}/messages:send", app.config.push.fcm_url.trim_end_matches('/'), app.config.push.fcm_project);
    let mut sent = 0;
    for d in devices.iter().take(MOST_DEVICES) {
        let Some(key) = hex::decode(&d.public_key).ok().and_then(|k| <[u8; 32]>::try_from(k).ok()) else { continue };
        let Some(sealed) = flow_core::alert::seal(&key, &plain) else { continue };
        // Data only, high priority: the app wakes, opens it and shows it;
        // the push service has no title or body to show or read.
        let body = serde_json::json!({ "message": {
            "token": d.fcm_token,
            "data": { "sealed": crate::oidc::b64url(&sealed) },
            "android": { "priority": "high" },
        }});
        let r = client.post(&url).bearer_auth(&token).json(&body).send().await.map_err(|e| e.to_string())?;
        let status = r.status();
        if status.is_success() {
            sent += 1;
        } else {
            let text = r.text().await.unwrap_or_default();
            if status == reqwest::StatusCode::NOT_FOUND || text.contains("UNREGISTERED") {
                pdb::forget_fcm(&app.db, &d.fcm_token).await.ok();
            } else {
                tracing::warn!("push: Cloud Messaging said {status}: {}", text.chars().take(200).collect::<String>());
            }
        }
    }
    Ok(sent)
}