use tokio::{
    sync::{mpsc, oneshot},
    task,
};

#[derive(Debug)]
pub enum QueryAction {
    Test(String),
}
#[derive(Debug)]
pub enum QueryResponse {
    Test(String),
}
#[derive(Debug)]
pub struct Query {
    pub action: QueryAction,
    pub return_channel: oneshot::Sender<QueryResponse>,
}

#[derive(Clone)]
pub struct Sender(mpsc::Sender<Query>);
impl Sender {
    pub async fn query(&mut self, string: String) -> QueryResponse {
        let (sender, receiver) = oneshot::channel();

        let action = QueryAction::Test(string);

        println!("sending query: {:?}", action);

        self.0
            .send(Query {
                action,
                return_channel: sender,
            })
            .await
            .expect("Failed to send query");

        let result = receiver
            .await
            .expect("Failed to recieve query response from return channel");

        result
    }
}

pub struct Receiver(mpsc::Receiver<Query>);
impl Receiver {
    pub async fn handle(mut self) {
        while let Some(query) = self.0.recv().await {
            println!("got query = {:?}", query.action);

            // TODO: read to / write from file

            let result = match query.action {
                QueryAction::Test(inner) => inner.to_uppercase(),
            };

            let response = QueryResponse::Test(result);

            query
                .return_channel
                .send(response)
                .expect("Tried to send to closed return channel");
        }
    }
}

pub fn create_db() -> (Sender, Receiver) {
    let (sender, receiver): (mpsc::Sender<Query>, mpsc::Receiver<Query>) = mpsc::channel(32);

    (Sender(sender), Receiver(receiver))
}

#[macro_use]
extern crate lazy_static;
lazy_static! {
    pub static ref SENDER: Sender = {
        let (sender, receiver) = create_db();

        task::spawn(receiver.handle());

        sender
    };
}

#[tokio::main]
async fn main() {
    for i in 0..16 {
        let mut sender = SENDER.clone();
        task::spawn(async move {
            let result = sender.query(format!("Query no. {}", i)).await;

            println!("result: {:?}", result);
        });
    }
}