use std::time::{SystemTime, UNIX_EPOCH};

use config::Config;

use database::Database;
use dotenv::dotenv;
use dns::server::DnsServer;
use tracing::{error, metadata::LevelFilter};
use tracing_subscriber::{
    filter::filter_fn, prelude::__tracing_subscriber_SubscriberExt, util::SubscriberInitExt, Layer,
};
use web::WebServer;

mod config;
mod database;
mod dns;
mod web;

type Error = Box<dyn std::error::Error>;
pub type Result<T> = std::result::Result<T, Error>;

#[tokio::main]
async fn main() {
    if let Err(err) = run().await {
        error!("{err}")
    };
}

async fn run() -> Result<()> {
    dotenv().ok();

    tracing_subscriber::registry()
        .with(
            tracing_subscriber::fmt::layer()
                .with_filter(LevelFilter::TRACE)
                .with_filter(filter_fn(|metadata| {
                    metadata.target().starts_with("wrapper")
                })),
        )
        .init();

    let config = Config::new();
    let database = Database::new(config.clone()).await?;

    let dns_server = DnsServer::new(config.clone(), database.clone()).await?;
    let (udp, tcp) = dns_server.run().await?;

    let web_server = WebServer::new(config, database).await?;
    let web = web_server.run().await?;

    tokio::join!(udp).0?;
    tokio::join!(tcp).0?;
    tokio::join!(web).0?;

    Ok(())
}

pub fn get_time() -> u64 {
    let start = SystemTime::now();
    let since_the_epoch = start
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards");
    since_the_epoch.as_millis() as u64
}