use common::app_daemon_utils::{mock_app_daemon, register_app_node};
use common::prepare_test_env::{prepare_test_db, run_service_for_stream};
use common::test_utils::{airdrop, Key};
use detee_shared::app_proto::brain_app_cli_client::BrainAppCliClient;
use detee_shared::app_proto::brain_app_daemon_client::BrainAppDaemonClient;
use detee_shared::app_proto::{self, AppNodeResources};
use surreal_brain::constants::APP_NODE;
use surreal_brain::db::app::AppNode;
use surreal_brain::db::prelude as db;
use tokio_stream::wrappers::ReceiverStream;

mod common;

// TODO: test app registration and resource handling

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

    let channel = run_service_for_stream().await.unwrap();
    let mut client = BrainAppDaemonClient::new(channel);

    let node_key = Key::new();

    let del_app_req = register_app_node(&mut client, &node_key, &Key::new().pubkey).await.unwrap();

    assert!(del_app_req.is_empty());

    let app_node: Option<db::AppNode> = db.select((APP_NODE, node_key.pubkey)).await.unwrap();
    assert!(app_node.is_some());
}

#[tokio::test]
async fn test_brain_message() {
    env_logger::builder().filter_level(log::LevelFilter::Error).init();
    let _ = prepare_test_db().await.unwrap();

    let brain_channel = run_service_for_stream().await.unwrap();
    let daemon_key = mock_app_daemon(&brain_channel, None).await.unwrap();
    let mut cli_client = BrainAppCliClient::new(brain_channel.clone());

    let cli_key = Key::new();

    let req = app_proto::NewAppReq {
        admin_pubkey: cli_key.pubkey.clone(),
        node_pubkey: daemon_key,
        price_per_unit: 1200,
        // extra_ports: vec![8080, 8081],
        locked_nano: 100,
        ..Default::default()
    };
    airdrop(&brain_channel, &cli_key.pubkey, 10).await.unwrap();
    let new_app_resp =
        cli_client.new_app(cli_key.sign_request(req).unwrap()).await.unwrap().into_inner();

    assert!(new_app_resp.error.is_empty());
    assert!(new_app_resp.app_id.len() == 40);
}

#[tokio::test]
async fn test_app_daemon_resource_msg() {
    /*
    env_logger::builder()
        .filter_level(log::LevelFilter::Trace)
        .filter_module("tungstenite", log::LevelFilter::Debug)
        .filter_module("tokio_tungstenite", log::LevelFilter::Debug)
        .init();
    */

    let db = prepare_test_db().await.unwrap();

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

    let daemon_key = Key::new();

    register_app_node(&mut daemon_client, &daemon_key, &Key::new().pubkey).await.unwrap();

    let (tx, rx) = tokio::sync::mpsc::channel(32);

    let tx_01 = tx.clone();
    let daemon_key_01 = daemon_key.clone();

    tokio::spawn(async move {
        tx_01
            .send(app_proto::DaemonMessageApp {
                msg: Some(app_proto::daemon_message_app::Msg::Auth(
                    daemon_key_01.clone().sign_stream_auth_app(vec![]).unwrap(),
                )),
            })
            .await
            .unwrap();

        let rx_stream = ReceiverStream::new(rx);
        daemon_client.daemon_messages(rx_stream).await.unwrap();
    });

    let tx_02 = tx.clone();
    let daemon_pubkey = daemon_key.clone().pubkey;

    let req_data = AppNodeResources {
        node_pubkey: daemon_pubkey,
        avail_no_of_port: 5,
        avail_vcpus: 4,
        avail_memory_mib: 8192,
        avail_storage_mib: 10_0000,
        max_ports_per_app: 5,
    };

    let req_data_copy = req_data.clone();

    tokio::spawn(async move {
        tx_02
            .send(app_proto::DaemonMessageApp {
                msg: Some(app_proto::daemon_message_app::Msg::AppNodeResources(req_data_copy)),
            })
            .await
            .unwrap();
    });

    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;

    let app_node_opt: Option<AppNode> = db.select((APP_NODE, daemon_key.pubkey)).await.unwrap();
    assert!(app_node_opt.is_some());
    let db::AppNode {
        avail_mem_mib,
        avail_vcpus,
        avail_storage_mib,
        avail_ports,
        max_ports_per_app,
        ..
    } = app_node_opt.unwrap();

    assert_eq!(avail_mem_mib, req_data.avail_memory_mib);
    assert_eq!(avail_vcpus, req_data.avail_vcpus);
    assert_eq!(avail_storage_mib, req_data.avail_storage_mib);
    assert_eq!(avail_ports, req_data.avail_no_of_port);
    assert_eq!(max_ports_per_app, req_data.max_ports_per_app);
}