mod dbus;
mod daemon;

use std::future;
use std::sync::mpsc;
use log::LevelFilter;

use std::sync::Arc;
use tokio::sync::Mutex;

use daemon::Daemon;
use dbus::endpoint::Endpoint as DbusEndpoint;
use dbus::interface;
use dbus::server_impl::ServerImpl;

fn initialize_logging() {
    env_logger::Builder::from_default_env()  
        .filter_level(LevelFilter::Info)
        .format_timestamp_secs()
        .init();
}

#[tokio::main]
async fn main() {
    initialize_logging();

    let (sender, receiver) = mpsc::channel::<daemon::Event>();

    // Create the daemon
    let daemon = Arc::new(
        Mutex::new(
            Daemon::new()
                .map_err(|e| {
                    log::error!("Failed to start daemon: {}", e);
                    std::process::exit(1);
                })
                .unwrap()
        )
    );

    // Create the server implementation
    let server = ServerImpl::new(daemon.clone(), sender);

    // Register DBus interfaces with endpoint
    let endpoint = DbusEndpoint::new(server.clone());
    endpoint.register(
        interface::NAME,
        interface::OBJECT_PATH,
        |cr| {
            vec![
                interface::register_net_buzzert_kordophone_repository(cr),
                interface::register_net_buzzert_kordophone_settings(cr)
            ]
        }
    ).await;

    tokio::spawn(async move {
        for event in receiver {
            // Important! Only lock the daemon when handling events.
            daemon.lock().await.handle_event(event).await;
        }
    });

    future::pending::<()>().await;
    unreachable!()
}