nvim-config/lua/plugins/language-manager.lua

local utils = require('utils')
local M = {
  ts = {},
  lsp = {},
  lint = {},
  format = {},
}

M.group = vim.api.nvim_create_augroup('language-manager', { clear = true })

-- ======== Helpers ========

local cache_path = vim.fn.stdpath('cache') .. '/language-manager.json'

local function wrap(item)
  if type(item) == 'string' then
    return { item }
  elseif type(item) == 'table' then
    return item
  else
    return {}
  end
end

local function create_set()
  local seen = {}
  return function(ref, item)
    if not seen[ref] then
      seen[ref] = {}
    end
    if item and not seen[ref][item] then
      seen[ref][item] = true
      return true
    end
    return false
  end
end

local function read_file(path)
  local f = io.open(path, 'r')
  if not f then
    return nil
  end
  local content = f:read('*a')
  f:close()
  return content
end

local function write_file(path, content)
  local f = io.open(path, 'w')
  if not f then
    return false
  end
  f:write(content)
  f:close()
  return true
end

local function to_json(tbl)
  local ok, result = pcall(vim.json.encode, tbl)
  return ok and result or nil
end

local function from_json(str)
  local ok, result = pcall(vim.json.decode, str)
  return ok and result or nil
end

local function hash_spec(tbl)
  local encoded = to_json(tbl) or ''
  if vim.fn.exists('*sha256') == 1 then
    return vim.fn.sha256(encoded)
  else
    local tmp = vim.fn.tempname()
    write_file(tmp, encoded)
    local handle = io.popen('openssl dgst -sha256 ' .. tmp)
    local result = handle and handle:read('*a') or ''
    if handle then
      handle:close()
    end
    return result:match('([a-f0-9]+)') or ''
  end
end

local function save_cache(data)
  local encoded = to_json(data)
  if encoded then
    write_file(cache_path, encoded)
  end
end

local function load_cache()
  local raw = read_file(cache_path)
  if not raw then
    return nil
  end
  return from_json(raw)
end

-- ======== Spec Builder ========

local function create_spec()
  local S = {}
  local unique = create_set()
  local specs = {}

  function S.set(item, group)
    specs[group] = item
  end

  function S.get()
    return specs
  end

  function S.add(list, ...)
    local groups = { ... }
    local ref = table.concat(groups, '.')
    local pointer = specs
    local last_i = #groups

    for i = 1, last_i do
      local group = groups[i]
      if i == last_i then
        for _, item in ipairs(wrap(list)) do
          if unique(ref, item) then
            pointer[group] = pointer[group] or {}
            table.insert(pointer[group], item)
          end
        end
      else
        pointer[group] = pointer[group] or {}
        pointer = pointer[group]
      end
    end
  end

  return S
end

-- ======== Spec Generation ========

local function get_mason_registry()
  vim.cmd.packadd('mason.nvim')
  require('mason').setup()

  local registry = require('mason-registry')
  registry.refresh()

  return registry
end

function M.generate_specs(specs_raw)
  local install_spec = create_spec()
  local specs = create_spec()
  local registry = get_mason_registry()

  local lsp_map = {}

  for _, spec in ipairs(specs_raw) do
    if type(spec) == 'string' then
      spec = { ft = spec }
    end

    spec.ts = spec.ts or spec.ft
    specs.add(spec.ts, 'ts_parsers')

    install_spec.add(spec.lsp, 'code_tools')
    local resolved_lsps = {}
    for _, language_server in ipairs(wrap(spec.lsp)) do
      if registry.has_package(language_server) then
        local pkg = registry.get_package(language_server)
        if pkg.spec and pkg.spec.neovim and pkg.spec.neovim.lspconfig then
          local lspconfig_name = pkg.spec and pkg.spec.neovim and pkg.spec.neovim.lspconfig
          lsp_map[lspconfig_name] = language_server
          table.insert(resolved_lsps, lspconfig_name)
        else
          print('Package found but not lspconfig name: ' .. language_server)
        end
      else
        print('Package not found: ' .. language_server)
      end
    end
    specs.add(resolved_lsps, 'language_servers')

    install_spec.add(spec.lint, 'code_tools')
    install_spec.add(spec.format, 'code_tools')
    for _, ft in ipairs(wrap(spec.ft)) do
      specs.add(spec.lint, 'linters_by_ft', ft)
      specs.add(spec.format, 'formatters_by_ft', ft)
    end
  end

  local result = specs.get()
  result.lsp_map = lsp_map
  return result, install_spec.get()
end

-- ======== Cache ========

function M.load_specs()
  local cache = load_cache()
  if cache then
    M.general = cache.spec
  else
    local specs_raw = require('modules.language-specs').get()
    M.general, M.mason = M.generate_specs(specs_raw)
    save_cache({ hash = hash_spec(specs_raw), spec = M.general })
  end
  return M.general, M.mason
end

function M.invalidate_cache()
  local ok = os.remove(cache_path)
  if ok then
    vim.notify('Language manager cache invalidated', vim.log.levels.INFO)
  else
    vim.notify('No cache to invalidate or failed to delete', vim.log.levels.WARN)
  end
  M.general = nil
  M.mason = nil
end

function M.ts.install()
  vim.cmd.packadd('nvim-treesitter')
  local ts_install = require('nvim-treesitter.install').ensure_installed_sync
  ts_install(M.general.ts_parsers)
end

function M.mason_install()
  local packages = M.mason.code_tools
  local registry = get_mason_registry()

  local pending = #packages

  local result = utils.await(function(resolve)
    for _, name in ipairs(packages) do
      print('Mason package installing: ' .. name)
      local pkg = registry.get_package(name)
      pkg:install({}, function(success, error)
        if success then
          print('Mason package installed: ' .. name)
        else
          print('Mason package failed: ' .. name)
          print(' > Error: ' .. vim.inspect(error))
        end

        pending = pending - 1
        if pending == 0 then
          resolve(true)
        end
      end)
    end
  end, 5 * 60 * 1000, 200)

  if not result.ok or pending ~= 0 then
    print('\n!! >> Exited timeout, possible clean up needed!')
    print(' > status: ' .. result.ok)
    print(' > pending: ' .. pending)
  end
end

-- ======== Public API ========

function M.install()
  print('\n> Starting ts parsers install')
  M.ts.install()

  print('\n> Starting mason install: lsp, lint, format')
  M.mason_install()
end

function M.ts.setup()
  require('nvim-treesitter.configs').setup({
    highlight = { enable = true },
    incremental_selection = { enable = true },
  })
end

function M.lsp.setup()
  for _, lsp_name in ipairs((M.general and M.general.language_servers) or {}) do
    vim.lsp.enable(lsp_name)
  end
end

function M.lint.setup()
  vim.api.nvim_create_autocmd({ 'BufReadPre', 'BufNewFile' }, {
    group = M.group,
    callback = function()
      local lint = require('lint')
      lint.linters_by_ft = (M.general and M.general.linters_by_ft) or {}
      vim.api.nvim_create_autocmd({ 'BufEnter', 'BufWritePost', 'InsertLeave' }, {
        group = vim.api.nvim_create_augroup('language-manager.lint', { clear = true }),
        callback = function()
          lint.try_lint()
        end,
      })
    end,
  })
end

function M.format.setup()
  vim.api.nvim_create_autocmd('BufWritePre', {
    group = M.group,
    once = true,
    callback = function()
      require('conform').setup({
        format_on_save = { timeout_ms = 500, lsp_format = 'fallback' },
        default_format_opts = { stop_after_first = true },
        formatters_by_ft = (M.general and M.general.formatters_by_ft) or {},
      })
    end,
  })
end

function M.setup()
  M.load_specs()
  M.ts.setup()
  M.lsp.setup()
  M.lint.setup()
  M.format.setup()
end

return M