use std::sync::Arc;

use discord::create_discord_client;
use matrix::create_matrix_client;

mod bridgers;
mod message_ast;
mod messages;

pub mod discord;
pub mod matrix;

use bridgers::Bridgers;
use messages::SentMessage;
use tokio::sync::mpsc;

use crate::message_ast::Styled;

async fn setup_discord(
    token: String,
    bridgers: Arc<Bridgers>,
    discord_tx: mpsc::UnboundedSender<SentMessage>,
) {
    let (discord_ctx_tx, mut discord_ctx_rx) = mpsc::unbounded_channel::<discord::Context>();
    tokio::spawn(async move {
        let mut discord = create_discord_client(discord_ctx_tx, discord_tx, &token).await;
        discord.start().await.unwrap();
    });

    // Hack to grab the Context object when discord is ready
    tokio::spawn(async move {
        while let Some(discord) = discord_ctx_rx.recv().await {
            bridgers.discord.lock().unwrap().replace(Some(discord));
        }
    });
}

async fn setup_matrix(
    homeserver_url: String,
    username: String,
    password: String,
    bridgers: Arc<Bridgers>,
    message_tx: mpsc::UnboundedSender<SentMessage>,
) {
    let client = create_matrix_client(homeserver_url, username, password, message_tx).await;

    bridgers
        .matrix
        .lock()
        .unwrap()
        .replace(Some(client.clone()));

    let settings = matrix_sdk::SyncSettings::default().token(client.sync_token().await.unwrap());
    tokio::spawn(async move {
        client.sync(settings).await;
    });
}

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

    let bridgers = Arc::new(Bridgers::new());

    let (message_tx, mut message_rx) = tokio::sync::mpsc::unbounded_channel::<SentMessage>();

    #[inline]
    fn get_env_var(key: &str) -> String {
        std::env::var(key).expect("DISCORD_TOKEN not set in environment")
    }

    setup_discord(
        get_env_var("DISCORD_TOKEN"),
        Arc::clone(&bridgers),
        message_tx.clone(),
    )
    .await;

    setup_matrix(
        get_env_var("MATRIX_HOMESERVER"),
        get_env_var("MATRIX_USERNAME"),
        get_env_var("MATRIX_PASSWORD"),
        Arc::clone(&bridgers),
        message_tx.clone(),
    )
    .await;

    while let Some(message) = message_rx.recv().await {
        let mut content = message.content;
        content.insert(0, Styled::Plain(": ".to_string()));
        content.insert(
            0,
            Styled::Bold(vec![Styled::Plain(message.author.display_name.to_string())]),
        );

        let _ = bridgers.send_message(message.source, content).await;
    }
}