--[[
local lm = require('language_manager')
lm.install() or .install({'ts_parsers','language_servers','linters','formatters'})
  - treesitter.install specs.ts_parsers
  - mason.install mason-registry.get_package(name):install()
lm.generate_specs() or {use_cache=true, only_installed=true}
lm.delete_cache()
lm.enable()
--]]

local M = {}

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) -- unique()
    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 create_spec()
  local M = {}
  local unique = create_set()
  local specs = {}

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

  function M.get()
    return specs
  end

  function M.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
            if not pointer[group] then
              pointer[group] = {}
            end
            table.insert(pointer[group], item)
          end
        end
      else
        if not pointer[group] then
          pointer[group] = {}
        end
        pointer = pointer[group]
      end
    end
  end

  return M
end

function M.generate_specs(specs_raw)
  local specs = create_spec()

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

    -- Filetype = TS Parser
    if not spec.ts then
      spec.ts = spec.ft
    end

    specs.add(spec.ts, 'ts_parsers')
    specs.add(spec.lsp, 'language_servers')

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

  M.general = specs.get()
  return M.general
end

M.lsp = {}
function M.lsp.enable()
  local registry = require('mason-registry')
  local lsp_configs = {}

  for _, lsp in ipairs(M.general.language_servers) do
    if registry.has_package(lsp) then
      local pkg = registry.get_package(lsp)
      local spec = pkg.spec and pkg.spec.neovim
      local lsp_name = (spec and spec.lspconfig) or lsp
      table.insert(lsp_configs, lsp_name)

      vim.lsp.enable(lsp_name)
    else
      vim.notify('Unknown LSP: ' .. lsp, vim.log.levels.WARN)
    end
  end

  vim.notify('Enabled LSPs: ' .. table.concat(lsp_configs, ', '), vim.log.levels.INFO)
end

return M