use anyhow::Result as AHResult;

use futures::prelude::*;
use lapin::{options::*, types::FieldTable, BasicProperties, Connection, ConnectionProperties};

use tokio_amqp::*;

#[tokio::main]
async fn main() -> AHResult<()> {
    let amqp_url = std::env::var("AMQP_URL").expect("expected AMQP_URL env variabe");
    let conn = Connection::connect(&amqp_url, ConnectionProperties::default().with_tokio()).await?;

    let pub_channel = conn.create_channel().await?;
    let sub_channel = conn.create_channel().await?;

    let queue = sub_channel
        .queue_declare(
            &"",
            QueueDeclareOptions {
                exclusive: true,
                auto_delete: true,
                ..QueueDeclareOptions::default()
            },
            FieldTable::default(),
        )
        .await?;

    sub_channel
        .queue_bind(
            queue.name().as_str(),
            "irc",
            "*.hedgewars",
            QueueBindOptions::default(),
            FieldTable::default(),
        )
        .await?;

    let mut subscriber = sub_channel
        .basic_consume(
            queue.name().as_str(),
            &"",
            BasicConsumeOptions::default(),
            FieldTable::default(),
        )
        .await?;

    let mut last_joined = None;
    let mut talking_to = None;

    while let Some(amqp_message) = subscriber.next().await {
        let (_, delivery) = amqp_message.expect("error in consumer");
        delivery.ack(BasicAckOptions::default()).await?;

        match delivery.routing_key.as_str() {
            "msg.hedgewars" => {
                let chat_message = String::from_utf8_lossy(&delivery.data);
                if let Some((who, _)) = chat_message.split_once('\n') {
                    let who = Some(who.to_owned());
                    if talking_to == who || last_joined == who {
                        talking_to = who;
                        pub_channel
                            .basic_publish(
                                "irc",
                                "cmd.say.hedgewars",
                                BasicPublishOptions::default(),
                                vec![],
                                BasicProperties::default(),
                            )
                            .await?;
                    } else {
                        last_joined = None;
                        talking_to = None;
                    }
                }
            }
            "join.hedgewars" => {
                last_joined = Some(String::from_utf8_lossy(&delivery.data).to_string());
            }
            _ => (),
        }
    }

    Ok(())
}