//! Phone alerts (oxygenhub-android#16): a phone registers its Cloud

//! Messaging token and its key with the token it signed in with; each

//! notification its account is told goes to it sealed to that key, so the

//! push service sees no title; a registration Cloud Messaging no longer

//! knows is forgotten, and one goes with its token.

use axum::body::Body;

use axum::http::{header, Request, StatusCode};

use axum::routing::{get, post};

use axum::{Json, Router};

use http_body_util::BodyExt;

use oxygenhub::config::Config;

use oxygenhub::db;

use oxygenhub::Shared;

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

use tower::ServiceExt;

type Sent = Arc<Mutex<Vec<serde_json::Value>>>;

/// Google's metadata server and Cloud Messaging, as far as the hub uses them.

async fn fake_google() -> (String, Sent) {

    let sent: Sent = Arc::default();

    let kept = sent.clone();

    let app = Router::new()

        .route(

            "/token",

            get(|h: axum::http::HeaderMap| async move {

                assert_eq!(h.get("metadata-flavor").and_then(|v| v.to_str().ok()), Some("Google"));

                Json(serde_json::json!({ "access_token": "vm-token", "expires_in": 3600 }))

            }),

        )

        .route(

            "/v1/projects/demo/messages:send",

            post(move |h: axum::http::HeaderMap, Json(body): Json<serde_json::Value>| {

                let kept = kept.clone();

                async move {

                    assert_eq!(h.get("authorization").and_then(|v| v.to_str().ok()), Some("Bearer vm-token"));

                    let gone = body["message"]["token"] == "gone";

                    kept.lock().unwrap().push(body);

                    if gone {

                        (

                            StatusCode::NOT_FOUND,

                            Json(serde_json::json!({ "error": { "status": "NOT_FOUND", "details": [{ "errorCode": "UNREGISTERED" }] } })),

                        )

                    } else {

                        (StatusCode::OK, Json(serde_json::json!({ "name": "projects/demo/messages/1" })))

                    }

                }

            }),

        );

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();

    let base = format!("http://{}", listener.local_addr().unwrap());

    tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });

    (base, sent)

}

async fn call(app: &Shared, method: &str, path: &str, token: &str, body: Option<serde_json::Value>) -> (StatusCode, String) {

    let mut req = Request::builder().method(method).uri(path).header(header::AUTHORIZATION, format!("Bearer {token}"));

    let body = match body {

        Some(b) => {

            req = req.header(header::CONTENT_TYPE, "application/json");

            Body::from(b.to_string())

        }

        None => Body::empty(),

    };

    let res = oxygenhub::router(app.clone()).oneshot(req.body(body).unwrap()).await.unwrap();

    let status = res.status();

    (status, String::from_utf8_lossy(&res.into_body().collect().await.unwrap().to_bytes()).into_owned())

}

fn b64url_decode(s: &str) -> Vec<u8> {

    let val = |c: u8| match c {

        b'A'..=b'Z' => c - b'A',

        b'a'..=b'z' => c - b'a' + 26,

        b'0'..=b'9' => c - b'0' + 52,

        b'-' => 62,

        _ => 63,

    } as u32;

    let mut out = Vec::new();

    for chunk in s.as_bytes().chunks(4) {

        let n = chunk.iter().enumerate().fold(0u32, |acc, (i, c)| acc | (val(*c) << (18 - 6 * i)));

        out.extend_from_slice(&n.to_be_bytes()[1..chunk.len()]);

    }

    out

}

async fn sent_after(sent: &Sent, n: usize) -> Vec<serde_json::Value> {

    for _ in 0..100 {

        if sent.lock().unwrap().len() >= n {

            break;

        }

        tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    }

    sent.lock().unwrap().clone()

}

#[tokio::test(flavor = "multi_thread")]

async fn a_notification_reaches_the_phone_sealed() {

    let (google, sent) = fake_google().await;

    let dir = tempfile::tempdir().unwrap();

    let mut config = Config::load(dir.path()).unwrap();

    config.push.fcm_project = "demo".into();

    config.push.fcm_url = google.clone();

    config.push.token_url = format!("{google}/token");

    let app = oxygenhub::build(config).await.unwrap();

    let bob = db::accounts::create_account(&app.db, "bob", "[email protected]", "x", "salt", false).await.unwrap();

    let (phone_token, hash) = oxygenhub::auth::new_token();

    db::accounts::create_token(&app.db, bob.id, "pixel", &hash, "repo:read", "", None).await.unwrap();

    // The phone registers its Cloud Messaging token and its key.

    let secret = flow_core::alert::new_secret();

    let key = hex::encode(flow_core::alert::public_key(&secret));

    let bad =

        call(&app, "PUT", "/api/v1/user/push", &phone_token, Some(serde_json::json!({ "fcm_token": "f1", "public_key": "abc" }))).await;

    assert_eq!(bad.0, StatusCode::BAD_REQUEST, "{}", bad.1);

    let (status, body) =

        call(&app, "PUT", "/api/v1/user/push", &phone_token, Some(serde_json::json!({ "fcm_token": "f1", "public_key": key }))).await;

    assert_eq!(status, StatusCode::OK, "{body}");

    assert!(body.contains("\"alerts\":true"), "{body}");

    // A notification for bob: his phone is sent it, sealed.

    oxygenhub::notify::tell(

        &app,

        "issue.assigned",

        "andy/demo#1: Fix it",

        "/andy/demo/issue/1",

        "andy",

        None,

        vec![(bob.id, db::notify::Reason::Participating)],

    )

    .await;

    let got = sent_after(&sent, 1).await;

    assert_eq!(got.len(), 1, "{got:?}");

    let m = &got[0]["message"];

    assert_eq!(m["token"], "f1");

    assert_eq!(m["android"]["priority"], "high");

    assert!(m.get("notification").is_none() && !got[0].to_string().contains("Fix it"), "nothing readable on the way: {got:?}");

    let opened = flow_core::alert::open(&secret, &b64url_decode(m["data"]["sealed"].as_str().unwrap())).expect("sealed to the phone");

    let alert: oxygenhub::push::Alert = serde_json::from_slice(&opened).unwrap();

    assert_eq!(alert.kind, "issue.assigned");

    assert_eq!(alert.title, "📌 Issue Assigned: andy/demo#1: Fix it");

    assert!(alert.url.ends_with("/andy/demo/issue/1") && alert.url.starts_with("http"), "{}", alert.url);

    // A registration Cloud Messaging no longer knows is forgotten.

    let (gone_token, hash) = oxygenhub::auth::new_token();

    db::accounts::create_token(&app.db, bob.id, "old phone", &hash, "repo:read", "", None).await.unwrap();

    call(&app, "PUT", "/api/v1/user/push", &gone_token, Some(serde_json::json!({ "fcm_token": "gone", "public_key": key }))).await;

    assert_eq!(oxygenhub::push::send_now(&app, bob.id, &alert).await, Ok(1));

    let left: Vec<String> = db::push::of_account(&app.db, bob.id).await.unwrap().into_iter().map(|d| d.fcm_token).collect();

    assert_eq!(left, ["f1"]);

    // Unregistering, and signing out (the token revoked), end it.

    assert_eq!(call(&app, "DELETE", "/api/v1/user/push", &phone_token, None).await.0, StatusCode::NO_CONTENT);

    assert!(db::push::of_account(&app.db, bob.id).await.unwrap().is_empty());

    call(&app, "PUT", "/api/v1/user/push", &phone_token, Some(serde_json::json!({ "fcm_token": "f1", "public_key": key }))).await;

    assert_eq!(call(&app, "DELETE", "/api/v1/user/token", &phone_token, None).await.0, StatusCode::NO_CONTENT);

    assert!(db::push::of_account(&app.db, bob.id).await.unwrap().is_empty(), "gone with its token");

}