use common::prepare_test_env::{prepare_test_db, run_service_for_stream};
use common::test_utils::Key;
use common::vm_cli_utils::create_new_vm;
use common::vm_daemon_utils::{mock_vm_daemon, register_vm_node};
use detee_shared::vm_proto::brain_vm_cli_client::BrainVmCliClient;
use detee_shared::vm_proto::brain_vm_daemon_client::BrainVmDaemonClient;
use detee_shared::vm_proto::{ListVmContractsReq, NewVmReq};
use futures::StreamExt;
use std::vec;

mod common;

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

    let brain_channel = run_service_for_stream().await.unwrap();
    let daemon_key = mock_vm_daemon(&brain_channel).await.unwrap();

    let key = Key::new();

    let _ = create_new_vm(&db, &key, &daemon_key, &brain_channel).await;
}

#[tokio::test]
async fn test_vm_creation_timeout() {
    prepare_test_db().await.unwrap();
    // env_logger::builder().filter_level(log::LevelFilter::Error).init();

    let brain_channel = run_service_for_stream().await.unwrap();
    let mut daemon_client = BrainVmDaemonClient::new(brain_channel.clone());
    let daemon_key = Key::new();

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

    let key = Key::new();

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

    let mut client_vm_cli = BrainVmCliClient::new(brain_channel.clone());
    let timeout_error =
        client_vm_cli.new_vm(key.sign_request(new_vm_req).unwrap()).await.err().unwrap();

    assert_eq!(
        timeout_error.message(),
        "Request failed due to timeout. Please try again later or contact the DeTEE devs team."
    )
}

#[tokio::test]
// TODO: create vm for this user before testing this
async fn test_list_vm_contracts() {
    prepare_test_db().await.unwrap();

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

    let key = Key::new();
    let pubkey = key.pubkey.clone();

    let req_data =
        ListVmContractsReq { wallet: pubkey, uuid: String::from("uuid"), as_operator: false };

    let mut grpc_stream =
        client.list_vm_contracts(key.sign_request(req_data).unwrap()).await.unwrap().into_inner();

    let mut vm_contracts = Vec::new();
    while let Some(stream_update) = grpc_stream.next().await {
        match stream_update {
            Ok(vm_c) => {
                vm_contracts.push(vm_c);
            }
            Err(e) => {
                panic!("Received error instead of vm_contracts: {e:?}");
            }
        }
    }

    assert!(vm_contracts.is_empty())

    // verify report in db
}