use once_cell::sync::Lazy;
use tokio::sync::broadcast;
use std::sync::Arc;

use crate::watcher::renderer::RenderCommand;

static NETWORK_EVENT_BUS: Lazy<Arc<EventBus<NetworkEvent>>> = Lazy::new(|| Arc::new(EventBus::new()));
static SYSTEM_EVENT_BUS: Lazy<Arc<EventBus<SystemEvent>>> = Lazy::new(|| Arc::new(EventBus::new()));
static RENDER_CHANNEL: Lazy<Arc<EventBus<RenderCommand>>> = Lazy::new(|| Arc::new(EventBus::new()));

pub fn publish_system_event(event: SystemEvent) {
    SYSTEM_EVENT_BUS.publish(event);
}

pub fn subscribe_system_event() -> broadcast::Receiver<SystemEvent> {
  SYSTEM_EVENT_BUS.subscribe()
}

pub fn publish_network_event(event: NetworkEvent) {
    NETWORK_EVENT_BUS.publish(event);
}

pub fn subscribe_network_event() -> broadcast::Receiver<NetworkEvent> {
  NETWORK_EVENT_BUS.subscribe()
}

pub fn publish_render_event(event: RenderCommand) {
    RENDER_CHANNEL.publish(event);
}

pub fn subscribe_render_event() -> broadcast::Receiver<RenderCommand> {
  RENDER_CHANNEL.subscribe()
}

struct EventBus<T>
where
    T: Clone + std::fmt::Debug
{
  sender: broadcast::Sender<T>,
  _receiver: broadcast::Receiver<T>
}

impl<T: Clone + std::fmt::Debug> EventBus<T> {
  pub fn new() -> Self {
    let (sender, receiver) = broadcast::channel(1000);
    Self {
      sender,
      _receiver: receiver
    }
  }

  pub fn publish(&self, event: T) {
    if let Err(e) = self.sender.send(event) {
      eprintln!("{e}")
    }
  }

  pub fn subscribe(&self) -> broadcast::Receiver<T> {
    self.sender.subscribe()
  }
}

#[derive(Clone, Debug)]
pub enum SystemEvent {
  Exit
}

#[derive(Clone, Debug)]
pub enum NetworkEvent {
    SeedConnected(String),
    SeedDisconnected(String),
    AllSeedsConnected,
    BootstrapCompleted,
    NodeReady,
}