-- tiny-packupdate.nvim: minimal vim.pack updater with progress bar & results picker
-- Requires Neovim 0.12+ (vim.pack API)

local M = {}
local state = nil -- nil = idle; table = running
local cfg = { command = "PackUpdate", auto = "manual" }
local ns = vim.api.nvim_create_namespace("tiny-packupdate")
local BAR_W = 40
local LOG_FMT = "--pretty=format:commit %h%nAuthor: %an%nDate:   %cr%n%n    %s%n"

-- ── Timestamp persistence (for auto-update cadence) ───────────────────

local stamp_path = vim.fn.stdpath("data") .. "/tiny-packupdate-last"
local auto_intervals = { daily = 86400, weekly = 604800, monthly = 2592000 }

local function read_stamp()
  local f = io.open(stamp_path, "r")
  if not f then
    return 0
  end
  local t = tonumber(f:read("*a")) or 0
  f:close()
  return t
end

local function write_stamp()
  local f = io.open(stamp_path, "w")
  if f then
    f:write(tostring(os.time()))
    f:close()
  end
end

-- ── Progress bar UI ───────────────────────────────────────────────────

local function progress_draw()
  if not state or not state.buf or not vim.api.nvim_buf_is_valid(state.buf) then
    return
  end
  local elapsed = (vim.uv.hrtime() - state.t0) / 1e9
  local pct = state.complete and 1.0 or (0.9 * (1 - math.exp(-elapsed / 5)))
  local tag = state.changed > 0 and string.format(" %d new ", state.changed) or ""
  local bw = BAR_W - 2 - #tag
  local filled = math.floor(pct * bw)
  local line = " " .. string.rep("█", filled) .. string.rep("░", bw - filled) .. tag
  vim.api.nvim_buf_set_lines(state.buf, 0, -1, false, { line })
  vim.api.nvim_buf_clear_namespace(state.buf, ns, 0, -1)
  if filled > 0 then
    -- █ is 3 bytes in UTF-8
    vim.api.nvim_buf_add_highlight(state.buf, ns, "TinyPackProgress", 0, 1, 1 + filled * 3)
  end
end

local function progress_open()
  local buf = vim.api.nvim_create_buf(false, true)
  vim.bo[buf].bufhidden = "wipe"
  state.buf = buf
  state.win = vim.api.nvim_open_win(buf, false, {
    relative = "editor",
    row = math.floor(vim.o.lines / 3),
    col = math.floor((vim.o.columns - BAR_W) / 2),
    width = BAR_W,
    height = 1,
    style = "minimal",
    border = "rounded",
    title = " " .. cfg.command .. " ",
    title_pos = "center",
    noautocmd = true,
  })
  state.t0 = vim.uv.hrtime()
  state.anim = vim.uv.new_timer()
  state.anim:start(0, 16, vim.schedule_wrap(progress_draw))
end

local function progress_close()
  if not state then
    return
  end
  if state.anim then
    state.anim:stop()
    state.anim:close()
    state.anim = nil
  end
  if state.win and vim.api.nvim_win_is_valid(state.win) then
    vim.api.nvim_win_close(state.win, true)
  end
end

-- ── Results display ───────────────────────────────────────────────────

local function show_results(results)
  progress_close()
  if #results == 0 then
    vim.notify("All plugins up to date", vim.log.levels.INFO)
    state = nil
    return
  end
  local ok, snacks = pcall(require, "snacks")
  if ok and snacks.picker then
    local items = {}
    for i, r in ipairs(results) do
      items[i] = {
        idx = i,
        score = i,
        text = r.name,
        preview = { text = r.log ~= "" and r.log or "(no commits)", ft = "git" },
      }
    end
    snacks.picker({
      title = cfg.command .. " Results",
      items = items,
      preview = "preview",
      layout = { preset = "ivy" },
      format = function(item)
        return { { item.text } }
      end,
      confirm = function() end, -- viewer only, no action on select
    })
  else
    -- Fallback: floating markdown window
    local lines = { "# " .. cfg.command .. " Results", "" }
    for _, r in ipairs(results) do
      lines[#lines + 1] = "## " .. r.name
      lines[#lines + 1] = ""
      lines[#lines + 1] = "```gitlog"
      for l in (r.log or ""):gmatch("[^\n]+") do
        lines[#lines + 1] = l
      end
      lines[#lines + 1] = "```"
      lines[#lines + 1] = ""
    end
    local buf = vim.api.nvim_create_buf(false, true)
    vim.api.nvim_buf_set_lines(buf, 0, -1, false, lines)
    vim.bo[buf].bufhidden = "wipe"
    vim.bo[buf].filetype = "markdown"
    vim.bo[buf].modifiable = false
    local w = math.floor(vim.o.columns * 0.8)
    local h = math.min(#lines + 2, math.floor(vim.o.lines * 0.8))
    vim.api.nvim_open_win(buf, true, {
      relative = "editor",
      row = math.floor((vim.o.lines - h) / 2),
      col = math.floor((vim.o.columns - w) / 2),
      width = w,
      height = h,
      border = "rounded",
      title = " " .. cfg.command .. " Results ",
      title_pos = "center",
      footer = " (q) close ",
      footer_pos = "center",
    })
    vim.keymap.set("n", "q", "<cmd>close<cr>", { buffer = buf })
    vim.keymap.set("n", "<Esc>", "<cmd>close<cr>", { buffer = buf })
  end
  state = nil
end

-- ── Collect changed plugins and their commit logs ─────────────────────

local function collect_and_show()
  local current = {}
  for _, p in ipairs(vim.pack.get(nil, { info = false })) do
    if p.active then
      current[p.spec.name] = { rev = p.rev, path = p.path }
    end
  end
  local changed = {}
  for name, snap in pairs(state.snapshot) do
    local cur = current[name]
    if cur and snap.rev and cur.rev ~= snap.rev then
      changed[#changed + 1] = { name = name, path = cur.path, old = snap.rev, new = cur.rev }
    elseif cur and not snap.rev and cur.rev then
      changed[#changed + 1] = { name = name, path = cur.path }
    end
  end
  if #changed == 0 then
    return show_results({})
  end
  local pending, results = #changed, {}
  for _, c in ipairs(changed) do
    local function on_log(label, r)
      local log = vim.trim(r.stdout or "")
      if label then
        log = label .. "\n" .. log
      end
      results[#results + 1] = { name = c.name, log = log }
      pending = pending - 1
      if pending == 0 then
        table.sort(results, function(a, b)
          return a.name < b.name
        end)
        vim.schedule(function()
          show_results(results)
        end)
      end
    end
    if not c.old then
      vim.system({ "git", "-C", c.path, "log", LOG_FMT, "-20" }, {}, function(r)
        on_log("(new)", r)
      end)
    else
      -- Forward update; if empty, it's a rollback
      vim.system({ "git", "-C", c.path, "log", LOG_FMT, c.old .. ".." .. c.new }, {}, function(r)
        if vim.trim(r.stdout or "") ~= "" then
          on_log(nil, r)
        else
          vim.system(
            { "git", "-C", c.path, "log", LOG_FMT, c.new .. ".." .. c.old },
            {},
            function(r2)
              on_log("(rolled back past)", r2)
            end
          )
        end
      end)
    end
  end
end

-- ── Completion detection ──────────────────────────────────────────────

local function on_complete()
  write_stamp()
  state.complete = true
  progress_draw()
  vim.defer_fn(collect_and_show, 400)
end

-- ── Main update ───────────────────────────────────────────────────────

function M.update()
  if state then
    return vim.notify("Update already in progress", vim.log.levels.WARN)
  end
  local plugins = vim.pack.get(nil, { info = false })
  local snapshot, names = {}, {}
  for _, p in ipairs(plugins) do
    if p.active then
      snapshot[p.spec.name] = { rev = p.rev, path = p.path }
      names[#names + 1] = p.spec.name
    end
  end
  if #names == 0 then
    return vim.notify("No active plugins", vim.log.levels.INFO)
  end

  state = { snapshot = snapshot, total = #names, changed = 0 }
  progress_open()

  local timer = vim.uv.new_timer()
  local au_id
  local function reset_debounce()
    timer:stop()
    timer:start(
      2000,
      0,
      vim.schedule_wrap(function()
        pcall(vim.api.nvim_del_autocmd, au_id)
        timer:close()
        on_complete()
      end)
    )
  end

  au_id = vim.api.nvim_create_autocmd("PackChanged", {
    callback = function()
      if not state then
        return pcall(vim.api.nvim_del_autocmd, au_id)
      end
      state.changed = state.changed + 1
      progress_draw()
      reset_debounce()
    end,
  })

  reset_debounce()
  vim.pack.update(names, { force = true })
end

-- ── Setup ─────────────────────────────────────────────────────────────

function M.setup(opts)
  vim.g.tiny_packupdate_loaded = true
  cfg = vim.tbl_extend("force", cfg, opts or {})
  vim.api.nvim_set_hl(0, "TinyPackProgress", { default = true, link = "DiagnosticOk" })
  vim.api.nvim_create_user_command(cfg.command, M.update, { desc = "Update all plugins" })
  local interval = auto_intervals[cfg.auto]
  if interval and os.time() - read_stamp() >= interval then
    vim.schedule(M.update)
  end
end

return M