init.lua

-- Utility functions for diffusion.nvim
-- Common helper functions and utilities

local Utils = {}

-- Deep merge two tables
function Utils.deep_merge(target, source)
  target = target or {}
  source = source or {}
  
  for key, value in pairs(source) do
    if type(value) == "table" and type(target[key]) == "table" then
      target[key] = Utils.deep_merge(target[key], value)
    else
      target[key] = value
    end
  end
  
  return target
end

-- Check if table is empty
function Utils.is_empty(tbl)
  return next(tbl) == nil
end

-- Get table size (number of key-value pairs)
function Utils.table_size(tbl)
  local count = 0
  for _ in pairs(tbl) do
    count = count + 1
  end
  return count
end

-- Find available port in range
function Utils.find_available_port(start_port, end_port)
  start_port = start_port or 10000
  end_port = end_port or 65535

  local ports = {}
  for p = start_port, end_port do
    ports[#ports + 1] = p
  end

  math.randomseed(os.time() + (vim.loop and (vim.loop.hrtime() % 1e6) or 0))
  for i = #ports, 2, -1 do
    local j = math.random(1, i)
    ports[i], ports[j] = ports[j], ports[i]
  end

  for _, port in ipairs(ports) do
    if Utils.is_port_available(port) then
      return port
    end
  end

  return nil
end

-- Check if port is available
function Utils.is_port_available(host_or_port, port)
  -- Handle both single port parameter and host/port parameters
  local host, actual_port
  if port then
    host = host_or_port
    actual_port = port
  else
    host = "127.0.0.1"
    actual_port = host_or_port
  end
  
  local handle = vim.loop.new_tcp()
  if not handle then
    return false
  end
  
  local success = handle:bind(host, actual_port)
  handle:close()
  
  return success
end

-- Debounce function calls
function Utils.debounce(fn, delay)
  local timer = nil
  
  return function(...)
    local args = {...}
    
    if timer then
      timer:stop()
    end
    
    timer = vim.defer_fn(function()
      fn(unpack(args))
      timer = nil
    end, delay)
  end
end

-- Throttle function calls
function Utils.throttle(fn, interval)
  local last_call = 0
  
  return function(...)
    local now = vim.loop.hrtime() / 1000000
    if now - last_call >= interval then
      last_call = now
      fn(...)
    end
  end
end

-- Retry function with exponential backoff
function Utils.retry(fn, max_attempts, initial_delay)
  max_attempts = max_attempts or 3
  initial_delay = initial_delay or 1000
  
  local function attempt(attempt_num)
    local success, result = pcall(fn)
    
    if success or attempt_num >= max_attempts then
      return success, result
    end
    
    local delay = initial_delay * (2 ^ (attempt_num - 1))
    vim.defer_fn(function()
      return attempt(attempt_num + 1)
    end, delay)
  end
  
  return attempt(1)
end

-- Generate unique ID
function Utils.generate_id(prefix)
  prefix = prefix or "id"
  local timestamp = os.time()
  local random = math.random(1000, 9999)
  return string.format("%s_%d_%d", prefix, timestamp, random)
end

-- Validate email format (basic)
function Utils.is_valid_email(email)
  if type(email) ~= "string" then
    return false
  end
  
  local pattern = "^[%w%._%+-]+@[%w%._%+-]+%.%w+$"
  return email:match(pattern) ~= nil
end

-- Validate URL format (basic)
function Utils.is_valid_url(url)
  if type(url) ~= "string" then
    return false
  end
  
  local pattern = "^https?://[%w%._%+-]+"
  return url:match(pattern) ~= nil
end

-- Escape string for use in regex
function Utils.escape_pattern(str)
  return str:gsub("[%^%$%(%)%%%.%[%]%*%+%-%?]", "%%%1")
end

-- Split string by delimiter
function Utils.split(str, delimiter)
  if type(str) ~= "string" then
    return {}
  end
  
  delimiter = delimiter or "%s+"
  local result = {}
  
  for match in str:gmatch("([^" .. delimiter .. "]+)") do
    table.insert(result, match)
  end
  
  return result
end

-- Trim whitespace from string
function Utils.trim(str)
  if type(str) ~= "string" then
    return str
  end
  
  return str:match("^%s*(.-)%s*$")
end

-- Check if string starts with prefix
function Utils.starts_with(str, prefix)
  if type(str) ~= "string" or type(prefix) ~= "string" then
    return false
  end
  
  return str:sub(1, #prefix) == prefix
end

-- Check if string ends with suffix
function Utils.ends_with(str, suffix)
  if type(str) ~= "string" or type(suffix) ~= "string" then
    return false
  end
  
  return str:sub(-#suffix) == suffix
end

-- Convert camelCase to snake_case
function Utils.camel_to_snake(str)
  if type(str) ~= "string" then
    return str
  end
  
  return str:gsub("([a-z])([A-Z])", "%1_%2"):lower()
end

-- Convert snake_case to camelCase
function Utils.snake_to_camel(str)
  if type(str) ~= "string" then
    return str
  end
  
  return str:gsub("_([a-z])", function(letter)
    return letter:upper()
  end)
end

-- Get current timestamp in milliseconds
function Utils.now_ms()
  return vim.loop.hrtime() / 1000000
end

-- Format duration from milliseconds to human readable
function Utils.format_duration(ms)
  if ms < 1000 then
    return string.format("%dms", ms)
  elseif ms < 60000 then
    return string.format("%.1fs", ms / 1000)
  elseif ms < 3600000 then
    return string.format("%.1fm", ms / 60000)
  else
    return string.format("%.1fh", ms / 3600000)
  end
end

-- Check if process is alive by PID
-- Uses os.execute which is faster and doesn't block like io.popen
function Utils.is_process_alive(pid)
  if type(pid) ~= "number" or pid <= 0 then
    return false
  end

  -- Use os.execute with kill -0 (signal 0 checks existence without sending signal)
  -- This is faster than io.popen and doesn't block the UI thread
  local result = os.execute("kill -0 " .. pid .. " 2>/dev/null")

  -- os.execute returns different values depending on Lua version:
  -- Lua 5.1: returns exit code as number (0 = success)
  -- Lua 5.2+: returns true/false, exit type, exit code
  if type(result) == "number" then
    return result == 0
  elseif type(result) == "boolean" then
    return result
  end
  return false
end

-- Get Neovim version info
function Utils.get_nvim_version()
  local version = vim.version()
  return {
    major = version.major,
    minor = version.minor,
    patch = version.patch,
    prerelease = version.prerelease,
    string = string.format("%d.%d.%d", version.major, version.minor, version.patch)
  }
end

-- Check if Neovim version meets requirement
function Utils.check_nvim_version(required_version)
  local current = Utils.get_nvim_version()
  local required = Utils.split(required_version, ".")
  
  local major = tonumber(required[1]) or 0
  local minor = tonumber(required[2]) or 0
  local patch = tonumber(required[3]) or 0
  
  if current.major > major then
    return true
  elseif current.major == major then
    if current.minor > minor then
      return true
    elseif current.minor == minor then
      return current.patch >= patch
    end
  end
  
  return false
end

-- Create directory if it doesn't exist
function Utils.ensure_dir(path)
  if vim.fn.isdirectory(path) == 0 then
    vim.fn.mkdir(path, "p")
  end
end

-- Get operating system
function Utils.get_os()
  if vim.fn.has("win32") == 1 or vim.fn.has("win64") == 1 then
    return "windows"
  elseif vim.fn.has("mac") == 1 then
    return "macos"
  else
    return "linux"
  end
end

return Utils