events.lua

-- Event system for diffusion.nvim
-- Provides pub/sub pattern for component communication

local Events = {}

function Events:new()
  local instance = {
    listeners = {},
    once_listeners = {},
    _stats = {
      events_emitted = 0,
      listeners_registered = 0
    }
  }
  setmetatable(instance, { __index = self })
  return instance
end

-- Register an event listener
function Events:on(event_type, callback)
  if type(callback) ~= "function" then
    error("Event callback must be a function")
  end
  
  self.listeners[event_type] = self.listeners[event_type] or {}
  table.insert(self.listeners[event_type], callback)
  self._stats.listeners_registered = self._stats.listeners_registered + 1
  
  -- Return unsubscribe function
  return function()
    self:off(event_type, callback)
  end
end

-- Register a one-time event listener
function Events:once(event_type, callback)
  if type(callback) ~= "function" then
    error("Event callback must be a function")
  end
  
  self.once_listeners[event_type] = self.once_listeners[event_type] or {}
  table.insert(self.once_listeners[event_type], callback)
  self._stats.listeners_registered = self._stats.listeners_registered + 1
  
  -- Return unsubscribe function
  return function()
    self:off_once(event_type, callback)
  end
end

-- Remove an event listener
function Events:off(event_type, callback)
  local listeners = self.listeners[event_type]
  if not listeners then return end
  
  for i = #listeners, 1, -1 do
    if listeners[i] == callback then
      table.remove(listeners, i)
      break
    end
  end
end

-- Remove a one-time event listener
function Events:off_once(event_type, callback)
  local listeners = self.once_listeners[event_type]
  if not listeners then return end
  
  for i = #listeners, 1, -1 do
    if listeners[i] == callback then
      table.remove(listeners, i)
      break
    end
  end
end

-- Internal helper to call listeners with error handling
function Events:_call_listeners(event_type, data, listeners, once_listeners)
  -- Call regular listeners
  for _, listener in ipairs(listeners) do
    local success, err = pcall(listener, data)
    if not success then
      local Logger = require('diffusion.utils.logger')
      local logger = Logger.get()
      -- Selection events can be noisy; log at DEBUG to avoid user spam
      if event_type == 'selection_changed' or event_type == 'ui:selection_changed' then
        logger:debug("Event listener error", { event = event_type, error = err })
      else
        logger:error("Event listener error", { event = event_type, error = err })
      end
    end
  end

  -- Call one-time listeners
  for _, listener in ipairs(once_listeners) do
    local success, err = pcall(listener, data)
    if not success then
      local Logger = require('diffusion.utils.logger')
      local logger = Logger.get()
      if event_type == 'selection_changed' or event_type == 'ui:selection_changed' then
        logger:debug("One-time event listener error", { event = event_type, error = err })
      else
        logger:error("One-time event listener error", { event = event_type, error = err })
      end
    end
  end
end

-- Emit an event (synchronous - fast, use for most events)
-- This is the default and recommended method for internal plugin events
function Events:emit(event_type, data)
  self._stats.events_emitted = self._stats.events_emitted + 1

  -- Collect listeners
  local listeners = self.listeners[event_type] or {}
  local once_listeners = self.once_listeners[event_type] or {}

  -- Clear once listeners before calling (in case they re-register)
  if #once_listeners > 0 then
    self.once_listeners[event_type] = {}
  end

  -- Call all listeners synchronously (no vim.schedule overhead)
  self:_call_listeners(event_type, data, listeners, once_listeners)
end

-- Emit event with deferred execution (single vim.schedule for ALL listeners)
-- Use this when emitting from libuv callbacks or when you need async execution
function Events:emit_async(event_type, data)
  self._stats.events_emitted = self._stats.events_emitted + 1

  -- Collect listeners
  local listeners = self.listeners[event_type] or {}
  local once_listeners = self.once_listeners[event_type] or {}

  -- Clear once listeners before calling
  if #once_listeners > 0 then
    self.once_listeners[event_type] = {}
  end

  -- Skip if no listeners
  if #listeners == 0 and #once_listeners == 0 then
    return
  end

  -- Single vim.schedule wrapping ALL listeners (not one per listener)
  vim.schedule(function()
    self:_call_listeners(event_type, data, listeners, once_listeners)
  end)
end

-- Alias for backwards compatibility
function Events:emit_sync(event_type, data)
  return self:emit(event_type, data)
end

-- Remove all listeners for an event type
function Events:clear(event_type)
  if event_type then
    self.listeners[event_type] = nil
    self.once_listeners[event_type] = nil
  else
    -- Clear all listeners
    self.listeners = {}
    self.once_listeners = {}
  end
end

-- Get listener count for an event type
function Events:count(event_type)
  local regular_count = self.listeners[event_type] and #self.listeners[event_type] or 0
  local once_count = self.once_listeners[event_type] and #self.once_listeners[event_type] or 0
  return regular_count + once_count
end

-- Get all registered event types
function Events:types()
  local types = {}
  
  for event_type, _ in pairs(self.listeners) do
    if not vim.tbl_contains(types, event_type) then
      table.insert(types, event_type)
    end
  end
  
  for event_type, _ in pairs(self.once_listeners) do
    if not vim.tbl_contains(types, event_type) then
      table.insert(types, event_type)
    end
  end
  
  table.sort(types)
  return types
end

-- Get event system statistics
function Events:stats()
  return vim.deepcopy(self._stats)
end

-- Create a namespaced event emitter
function Events:namespace(namespace)
  local namespaced = {
    _parent = self,
    _namespace = namespace
  }
  
  function namespaced:on(event_type, callback)
    return self._parent:on(self._namespace .. ":" .. event_type, callback)
  end
  
  function namespaced:once(event_type, callback)
    return self._parent:once(self._namespace .. ":" .. event_type, callback)
  end
  
  function namespaced:off(event_type, callback)
    return self._parent:off(self._namespace .. ":" .. event_type, callback)
  end
  
  function namespaced:emit(event_type, data)
    return self._parent:emit(self._namespace .. ":" .. event_type, data)
  end

  function namespaced:emit_async(event_type, data)
    return self._parent:emit_async(self._namespace .. ":" .. event_type, data)
  end

  function namespaced:emit_sync(event_type, data)
    return self._parent:emit_sync(self._namespace .. ":" .. event_type, data)
  end

  return namespaced
end

return Events