use std::time::Duration;
use tokio::sync::mpsc;
use tokio::time::interval;
use crate::domain::client::ClientManager;
use crate::domain::event::{Event, EventBus};
use crate::network::udp::UdpServer;
use crate::runtime::dispatcher::Dispatcher;

pub struct App {
    // Communication inter-components
    event_bus: EventBus,
    dispatcher: Dispatcher,
    event_rx: kanal::AsyncReceiver<Event>,

    // Network
    udp_server: UdpServer,

    // Clients
    client_manager: ClientManager,

}

impl App {
    pub async fn new() -> Self {
        let (event_bus, event_rx) = EventBus::new();

        let udp_server = UdpServer::new(event_bus.clone(), "0.0.0.0:5000").await;
        let client_manager = ClientManager::new();
        let dispatcher = Dispatcher::new(event_bus.clone(), udp_server.clone(), client_manager.clone()).await;


        Self {
            event_bus,
            dispatcher,
            event_rx,
            udp_server,
            client_manager
        }
    }

    pub async fn start(&mut self) {
        for i in 0..4 {
            let dispatcher = self.dispatcher.clone();
            let event_rx = self.event_rx.clone();
            tokio::spawn(async move {
                dispatcher.start(event_rx).await;
            });
        }


        let _ = self.udp_server.start().await;
        let _ = self.tick_tasks().await;
        println!("App started");
    }

    async fn tick_tasks(&self) {
        let event_bus = self.event_bus.clone();
        tokio::spawn(async move {
            let mut interval = interval(Duration::from_secs(1));
            loop {
                // println!("Tick");
                interval.tick().await;
                let _ = event_bus.emit(Event::TickSeconds).await;
            }
        });
    }

}