local M = {
  lsp = {},
  ts = {},
  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 ========

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

  -- ensure Mason is available
  vim.cmd.packadd('mason.nvim')
  require('mason').setup()
  local registry = require('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')

    -- resolve LSP name using Mason registry
    install_spec.add(spec.lsp, 'language_servers')
    local resolved_lsps = {}
    for _, lsp in ipairs(wrap(spec.lsp)) do
      if registry.has_package(lsp) then
        local pkg = registry.get_package(lsp)
        local lspconfig = pkg.spec and pkg.spec.neovim and pkg.spec.neovim.lspconfig or lsp
        table.insert(resolved_lsps, lspconfig)
        lsp_map[lspconfig] = lsp
      else
        vim.notify('Unknown LSP: ' .. lsp, vim.log.levels.WARN)
      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 Interface ========

function M.load_or_generate(specs_raw)
  local hash = hash_spec(specs_raw)
  local cache = load_cache()
  if cache and cache.hash == hash then
    M.general = cache.spec
  else
    M.general, M.mason = M.generate_specs(specs_raw)
    save_cache({ hash = hash, spec = M.general })
  end
  return M.general, M.mason
end

function M.load_specs()
  local cache = load_cache()
  if cache then
    M.general = cache.spec
  else
    local specs_raw = require('modules.language-specs').get()
    local hash = hash_spec(specs_raw)
    M.general, M.mason = M.generate_specs(specs_raw)
    save_cache({ hash = hash, 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

-- ======== Setup Functions ========

local function on_ts_installed(parsers, cb)
  local info = require('nvim-treesitter.info')
  local timer = vim.loop.new_timer()
  timer:start(0, 500, vim.schedule_wrap(function()
    for _, lang in ipairs(parsers) do
      if not vim.tbl_contains(info.installed_parsers(), lang) then
        return
      end
    end
    timer:stop()
    timer:close()
    cb()
  end))
end

function M.ts.install()
  local install = require('nvim-treesitter.install')
  local parsers = M.general.ts_parsers or {}
  install.ensure_installed(parsers) -- async
  return parsers
end

-- ======== Orchestration ========

function M.install()
  local parsers = M.ts.install()
  on_ts_installed(parsers, function()
    M.mason_install()
  end)
end

local function ensure_registry_ready()
  local registry = require('mason-registry')
  if not registry.is_installed() then
    registry.update()
    vim.wait(10000, function()
      return registry.is_installed()
    end, 200)
  end
  return registry
end

function M.mason_install()
  vim.cmd.packadd('mason.nvim')
  require('mason').setup()
  local registry = ensure_registry_ready()
  local list = vim.list_extend(M.mason.language_servers, M.mason.code_tools)
  print(vim.inspect(list))

  local function install_and_wait(name)
    local pkg = registry.get_package(name)
    if pkg:is_installed() then
      vim.notify('Already installed ' .. name, vim.log.levels.INFO)
      return
    end

    vim.notify('Installing ' .. name, vim.log.levels.INFO)
    local done = false
    pkg:install():once('closed', function()
      done = true
    end)

    local ok = vim.wait(60 * 60 * 1000, function()
      return done or pkg:is_installed()
    end, 200)

    if not ok or not pkg:is_installed() then
      vim.notify('Install failed: ' .. name, vim.log.levels.ERROR)
    else
      vim.notify('Installed ' .. name, vim.log.levels.INFO)
    end
  end

  for _, name in ipairs(list) do
    if registry.has_package(name) then
      install_and_wait(name)
    else
      vim.notify('Package not found in registry: ' .. name, vim.log.levels.WARN)
    end
  end

  -- force event loop to process any pending Mason async teardown
  local settled = false
  vim.defer_fn(function()
    settled = true
  end, 3000)
  vim.wait(10 * 1000, function()
    return settled
  end, 100)
end

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

function M.ts.setup()
  require('nvim-treesitter.configs').setup({
    highlight = { enable = true },
    incremental_selection = { enable = true },
  })
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.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.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