// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: Unlicense

use common::prepare_test_env::{prepare_test_db, run_service_for_stream};
use common::test_utils::{airdrop, Key};
use common::vm_daemon_utils::register_vm_node;
use detee_shared::app_proto::brain_app_cli_client::BrainAppCliClient;
use detee_shared::app_proto::brain_app_daemon_client::BrainAppDaemonClient;
use detee_shared::vm_proto::brain_vm_cli_client::BrainVmCliClient;
use detee_shared::vm_proto::brain_vm_daemon_client::BrainVmDaemonClient;
use detee_shared::{app_proto, vm_proto};

use crate::common::app_daemon_utils::register_app_node;

mod common;

#[tokio::test]
async fn test_vm_pub_sub_redirect() {
    let _ = prepare_test_db().await.unwrap();

    let brain_channel = run_service_for_stream().await.unwrap();
    let mut vm_daemon_client = BrainVmDaemonClient::new(brain_channel.clone());

    let node_key = Key::new();

    let pubsub_brain_endpoint = "192.168.1.1:31337";
    std::env::set_var("BRAIN_PUBLIC_ENDPOINT", pubsub_brain_endpoint);
    register_vm_node(&mut vm_daemon_client, &node_key, &Key::new().pubkey).await.unwrap();
    std::env::set_var("BRAIN_PUBLIC_ENDPOINT", "127.0.0.1:31337");

    let client_key = Key::new();

    let new_vm_req = vm_proto::NewVmReq {
        admin_pubkey: client_key.pubkey.clone(),
        node_pubkey: node_key.pubkey.clone(),
        price_per_unit: 1200,
        extra_ports: vec![8080, 8081],
        locked_nano: 100,
        ..Default::default()
    };

    airdrop(&brain_channel, &client_key.pubkey, 10).await.unwrap();

    std::env::set_var("BRAIN_PUBLIC_ENDPOINT", "10.0.0.1:31337");
    let mut client_vm_cli = BrainVmCliClient::new(brain_channel.clone());
    let redirect =
        client_vm_cli.new_vm(client_key.sign_request(new_vm_req).unwrap()).await.err().unwrap();
    std::env::set_var("BRAIN_PUBLIC_ENDPOINT", "127.0.0.1:31337");
    assert_eq!(redirect.code(), tonic::Code::Unavailable);
    let redirect_url =
        redirect.metadata().get("location").and_then(|v| v.to_str().ok()).unwrap_or_default();
    assert_eq!(redirect_url, pubsub_brain_endpoint);
}

#[tokio::test]
async fn test_app_pub_sub_redirect() {
    let _ = prepare_test_db().await.unwrap();

    let brain_channel = run_service_for_stream().await.unwrap();
    let mut app_daemon_client = BrainAppDaemonClient::new(brain_channel.clone());

    let node_key = Key::new();

    let pubsub_brain_endpoint = "192.168.1.1:31337";
    std::env::set_var("BRAIN_PUBLIC_ENDPOINT", pubsub_brain_endpoint);
    register_app_node(&mut app_daemon_client, &node_key, &Key::new().pubkey).await.unwrap();
    std::env::set_var("BRAIN_PUBLIC_ENDPOINT", "127.0.0.1:31337");

    let client_key = Key::new();

    let new_app_req = app_proto::NewAppReq {
        admin_pubkey: client_key.pubkey.clone(),
        node_pubkey: node_key.pubkey.clone(),
        price_per_unit: 1200,
        resource: Some(app_proto::AppResource { ports: vec![8080, 8081], ..Default::default() }),
        locked_nano: 100,
        ..Default::default()
    };

    airdrop(&brain_channel, &client_key.pubkey, 10).await.unwrap();

    std::env::set_var("BRAIN_PUBLIC_ENDPOINT", "10.0.0.1:31337");

    let mut client_app_cli = BrainAppCliClient::new(brain_channel.clone());
    let redirect = client_app_cli
        .new_app(client_key.sign_request(new_app_req.clone()).unwrap())
        .await
        .err()
        .unwrap();
    std::env::set_var("BRAIN_PUBLIC_ENDPOINT", "127.0.0.1:31337");
    assert_eq!(redirect.code(), tonic::Code::Unavailable);
    let redirect_url =
        redirect.metadata().get("location").and_then(|v| v.to_str().ok()).unwrap_or_default();
    assert_eq!(redirect_url, pubsub_brain_endpoint);
}