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

use clap::Parser;
use futures::StreamExt;
use logging::setup_logger;

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

async fn error_wrap<T>(fut: impl Future<Output = std::io::Result<T>>) -> anyhow::Result<T> {
    let res = fut.await?;
    Ok(res)
}

#[tokio::main]
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 web_server = server::create(args.server.clone(), server_token)?;
    let bot_future = bot::start(args.bot.clone(), bot_token);

    let tasks = [
        tokio::task::spawn(bot_future),
        tokio::task::spawn(error_wrap(web_server)),
    ];

    let completed = tasks
        .into_iter()
        .collect::<FuturesUnordered<_>>()
        .take(1)
        .collect::<Vec<_>>()
        .await;

    if let Some(fut) = completed.into_iter().next() {
        fut?
    } else {
        Ok(())
    }
}