mod data;
mod grpc;
mod http_server;

use data::BrainData;
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 grpc::snp_proto::brain_vm_cli_server::BrainVmCliServer;
use grpc::snp_proto::brain_vm_daemon_server::BrainVmDaemonServer;
use grpc::BrainAppCliMock;
use grpc::BrainAppDaemonMock;
use grpc::BrainGeneraClilMock;
use grpc::BrainVmCliMock;
use grpc::BrainVmDaemonMock;
use http_server::http_metrics_server;
use std::sync::Arc;
use tonic::transport::Identity;
use tonic::transport::Server;
use tonic::transport::ServerTlsConfig;

#[tokio::main]
async fn main() {
    env_logger::builder()
        .filter_level(log::LevelFilter::Debug)
        .init();
    let data = Arc::new(BrainData::new());
    let data_clone = data.clone();
    tokio::spawn(async move {
        loop {
            tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
            data_clone.vm_nodes_cron().await;
            data_clone.vm_contracts_cron().await;
            data_clone.app_nodes_cron().await;
            data_clone.app_contracts_cron().await;
            if let Err(e) = data_clone.save_to_disk() {
                log::error!("Could not save data to disk due to error: {e}")
            }
        }
    });
    let addr = "0.0.0.0:31337".parse().unwrap();
    let http_addr = "0.0.0.0:51337".parse().unwrap();
    let _ = tokio::spawn(http_metrics_server(http_addr, data.clone()));

    let snp_daemon_server = BrainVmDaemonServer::new(BrainVmDaemonMock::new(data.clone()));
    let snp_cli_server = BrainVmCliServer::new(BrainVmCliMock::new(data.clone()));

    let sgx_cli_server = BrainAppCliServer::new(BrainAppCliMock::new(data.clone()));
    let sgx_daemon_server = BrainAppDaemonServer::new(BrainAppDaemonMock::new(data.clone()));

    let general_service_server = BrainGeneralCliServer::new(BrainGeneraClilMock::new(data.clone()));

    let cert = std::fs::read_to_string("/etc/detee/brain-mock/brain-crt.pem").unwrap();
    let key = std::fs::read_to_string("/etc/detee/brain-mock/brain-key.pem").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(sgx_cli_server)
        .add_service(sgx_daemon_server)
        .add_service(general_service_server)
        .serve(addr)
        .await
        .unwrap();
}