use futures::{stream::FuturesUnordered, StreamExt};
use std::sync::Arc;
use tokio::sync::RwLock;

use clap::Parser;
use logging::setup_logger;

mod args;
mod bot;
mod logging;
mod server;
pub mod utils;

#[tokio::main(flavor = "current_thread")]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    let args = args::Arguments::parse();
    setup_logger(args.log_level)?;

    let token_lock = Arc::new(RwLock::new(None));

    let bot_token = token_lock.clone();
    let server_token = token_lock.clone();

    let local_set = tokio::task::LocalSet::new();
    local_set
        .run_until(async {
            let tasks = vec![
                tokio::task::spawn_local(bot::start(args.bot.clone(), bot_token)),
                tokio::task::spawn_local(server::start(args.server.clone(), server_token)),
            ];
            // Here we wait for one async task to complete.
            let completed = tasks
                .into_iter()
                .collect::<FuturesUnordered<_>>()
                .take(1)
                .collect::<Vec<_>>()
                .await;
            // Now we get all completed futures (one future),
            // and return it's result.
            if let Some(fut) = completed.into_iter().next() {
                fut?
            } else {
                Ok(())
            }
        })
        .await?;

    Ok(())
}