use std::{collections::HashMap, sync::Arc};

use tokio::sync::{mpsc, RwLock};
use warp::{ws::Message, Rejection};

pub mod app;
pub mod context;
pub mod prelude;
pub mod service;

#[derive(Debug, Clone)]
pub struct Client {
    pub user_id: usize,
    pub topics: Vec<String>,
    pub sender: Option<mpsc::UnboundedSender<std::result::Result<Message, warp::Error>>>,
}

pub type Result<T> = std::result::Result<T, Rejection>;
pub type Clients = Arc<RwLock<HashMap<String, Client>>>;

#[cfg(test)]
mod tests {
    use crate::prelude::*;
    use serde::Deserialize;

    #[test]
    fn it_works() {
        #[allow(dead_code)]
        #[derive(Deserialize)]
        struct SaveNumberService {
            number: u32,
        }

        impl Service for SaveNumberService {
            type Message = Self;
            fn on_message(_message: Self, _ctx: &Context) {}
            fn info() -> ServiceInfo {
                ServiceInfo {
                    name: "save-number",
                    version_major: 1,
                    version_minor: 0,
                }
            }
        }

        #[derive(Deserialize)]
        struct DoubleNumberService {
            number: u32,
        }

        impl Service for DoubleNumberService {
            type Message = Self;
            fn on_message(message: Self, ctx: &Context) {
                let new_number = message.number * 2;
                ctx.publish(SaveNumberService { number: new_number });
            }
            fn info() -> ServiceInfo {
                ServiceInfo {
                    name: "double-number",
                    version_major: 1,
                    version_minor: 0,
                }
            }
        }

        //App::new().add_service::<DoubleNumberService>().run();
    }
}