// SPDX-License-Identifier: Apache-2.0

use detee_shared::app_proto::brain_app_cli_server::BrainAppCliServer;
use detee_shared::app_proto::brain_app_daemon_server::BrainAppDaemonServer;
use detee_shared::general_proto::brain_general_cli_server::BrainGeneralCliServer;
use detee_shared::vm_proto::brain_vm_cli_server::BrainVmCliServer;
use detee_shared::vm_proto::brain_vm_daemon_server::BrainVmDaemonServer;
use dotenv::dotenv;
use std::net::SocketAddr;
use std::sync::Arc;
use surreal_brain::constants::{BRAIN_GRPC_ADDR, CERT_KEY_PATH, CERT_PATH};
use surreal_brain::db;
use surreal_brain::grpc::app::{AppCliServer, AppDaemonServer};
use surreal_brain::grpc::general::GeneralCliServer;
use surreal_brain::grpc::vm::{VmCliServer, VmDaemonServer};
use tonic::transport::{Identity, Server, ServerTlsConfig};

#[tokio::main]
async fn main() {
    if dotenv::from_filename("/etc/detee/brain/config.ini").is_err() {
        dotenv().ok();
    }
    env_logger::builder()
        .filter_level(log::LevelFilter::Trace)
        .filter_module("rustls", log::LevelFilter::Debug)
        .filter_module("tungstenite", log::LevelFilter::Debug)
        .filter_module("tokio_tungstenite", log::LevelFilter::Debug)
        .init();

    let db_url = std::env::var("DB_URL").expect("the environment variable DB_URL is not set");
    let db_user = std::env::var("DB_USER").expect("the environment variable DB_USER is not set");
    let db_pass = std::env::var("DB_PASS").expect("the environment variable DB_PASS is not set");
    let db_ns = std::env::var("DB_NAMESPACE").expect("the env variable DB_NAMESPACE is not set");
    let db_name = std::env::var("DB_NAME").expect("the environment variable DB_NAME is not set");

    // To make sure env is set correctly
    std::env::var("BRAIN_PUBLIC_ENDPOINT")
        .expect("the environment variable BRAIN_PUBLIC_ENDPOINT is not set")
        .parse::<SocketAddr>()
        .expect("BRAIN_PUBLIC_ENDPOINT is not a socket address");

    let db = db::db_connection(&db_url, &db_user, &db_pass, &db_ns, &db_name).await.unwrap();
    let db_arc = Arc::new(db);

    let addr = BRAIN_GRPC_ADDR.parse().unwrap();

    let snp_daemon_server = BrainVmDaemonServer::new(VmDaemonServer::new(db_arc.clone()));
    let snp_cli_server = BrainVmCliServer::new(VmCliServer::new(db_arc.clone()));
    let general_service_server = BrainGeneralCliServer::new(GeneralCliServer::new(db_arc.clone()));
    let sgx_daemon_server = BrainAppDaemonServer::new(AppDaemonServer::new(db_arc.clone()));
    let sgx_cli_server = BrainAppCliServer::new(AppCliServer::new(db_arc.clone()));

    let cert_path = std::env::var("CERT_PATH").unwrap_or(CERT_PATH.to_string());
    let key_path = std::env::var("CERT_KEY_PATH").unwrap_or(CERT_KEY_PATH.to_string());
    let cert = std::fs::read_to_string(cert_path).unwrap();
    let key = std::fs::read_to_string(key_path).unwrap();

    let identity = Identity::from_pem(cert, key);

    Server::builder()
        .tls_config(ServerTlsConfig::new().identity(identity))
        .unwrap()
        .add_service(snp_daemon_server)
        .add_service(snp_cli_server)
        .add_service(general_service_server)
        .add_service(sgx_daemon_server)
        .add_service(sgx_cli_server)
        .serve(addr)
        .await
        .unwrap();
}