-- This module contains the logic responsible for building and starting
-- the Golang server. The Go server is responsible for making API calls
-- to Gitlab and returning the data
local state = require("gitlab.state")
local u = require("gitlab.utils")
local client = require("gitlab.client")
local version = require("gitlab.version")
local GitlabGroup = require("gitlab.autocmd")

local M = {}

---@type vim.SystemObj?
local server_system_obj
local kill_autocmd_created = false
-- Set when the VimLeavePre autocmd kills the server, so that the server's
-- on_exit callback skips the "server exited" error notification: it would
-- otherwise fire (and might fail to render) while nvim is tearing down.
local killed_on_exit = false

-- Builds the binary if it doesn't exist, and starts the server. If the pre-existing binary has an older
-- tag than the Lua code (exposed via the /version endpoint) then shuts down the server, rebuilds it, and
-- restarts the server again.
M.build_and_start = function(callback)
  if M.build(false) == false then
    return
  end

  -- When the user provides their own binary, skip the version check and rebuild cycle.
  -- The user is responsible for keeping their binary up to date.
  local user_provided_binary = state.settings.server.binary_provided

  M.start(function()
    if user_provided_binary then
      callback()
      return
    end
    M.get_version(function(versions)
      if versions.plugin_version ~= versions.binary_version then
        M.shutdown(function()
          if M.build(true) then
            M.start(callback)
          end
        end)
      else
        callback()
      end
    end)
  end)
end

---Starts the Go server and call the callback provided
M.start = function(callback)
  if state.settings.port ~= nil and state.settings.server.port == nil then
    state.settings.server.port = state.settings.port
    u.notify("The setting `port` has been renamed `server.port`", vim.log.levels.WARN)
  end
  local port = tonumber(state.settings.server.port) or 0
  local parsed_port = nil
  local callback_called = false

  local go_server_settings = {
    gitlab_url = state.settings.gitlab_url,
    port = port,
    auth_token = state.settings.auth_token,
    debug = state.settings.debug,
    log_path = state.settings.log_path,
    connection_settings = state.settings.connection_settings,
    chosen_mr_iid = state.chosen_mr_iid,
  }

  state.chosen_mr_iid = 0 -- Do not let this interfere with subsequent reviewer.open() calls

  local settings = vim.json.encode(go_server_settings)

  if not kill_autocmd_created then
    kill_autocmd_created = true
    vim.api.nvim_create_autocmd({ "VimLeavePre" }, {
      callback = function()
        if server_system_obj == nil then
          return
        end
        killed_on_exit = true
        -- Send SIGKILL rather than SIGTERM: the server is a stateless proxy to the
        -- Gitlab API, and a graceful shutdown would wait for in-flight requests.
        -- Use `pcall` because the handle is already closed if the process exited on
        -- its own, e.g. through the /shutdown endpoint.
        pcall(function()
          server_system_obj:kill("sigkill")
        end)
        server_system_obj = nil
      end,
      desc = "Kill the gitlab.nvim Go server process",
      group = GitlabGroup,
    })
  end

  local ok, obj = pcall(vim.system, { state.settings.server.binary, settings }, {
    -- The `stdin` param opens a pipe on the server's stdin that nvim holds open but
    -- never writes to. The server exits when it sees EOF on the pipe, which is how it
    -- notices that nvim is gone in the cases the VimLeavePre autocmd cannot cover:
    -- SIGKILL, an OOM kill, or a crash.
    stdin = true,
    stdout = function(_, data)
      if data == nil or parsed_port ~= nil then
        return
      end
      for line in data:gmatch("[^\r\n]+") do
        local matched = line:match("Server started on port:%s+(%d+)")
        if matched ~= nil then
          parsed_port = matched
          vim.schedule(function()
            state.settings.server.port = matched
            state.go_server_running = true
            if not callback_called then
              callback_called = true
              callback()
            end
          end)
          break
        end
      end
    end,
  }, function(out)
    if out.code ~= 0 and not killed_on_exit then
      vim.schedule(function()
        local msg = "Golang gitlab server exited: code: " .. out.code .. ", signal: " .. (out.signal or 0)
        if out.stderr ~= "" then
          msg = msg .. ", msg: " .. vim.trim(out.stderr)
        end
        u.notify(msg, vim.log.levels.ERROR)
      end)
    end
  end)

  if ok then
    server_system_obj = obj
  else
    u.notify("Could not start gitlab.nvim binary: " .. tostring(obj), vim.log.levels.ERROR)
  end
end

-- Builds the Go binary with the current Git tag.
M.build = function(override)
  state.settings.root_path = u.get_root_path()

  -- If the user provided a path to the server, don't build it.
  if state.settings.server.binary_provided then
    return
  end

  local version_issue = version.check_go_version()
  if version_issue ~= nil then
    return
  end

  -- If the user did not provide a path, we build it and place it in either the data path, or the
  -- first writable path we find in the runtime.
  local datapath = vim.fn.stdpath("data")
  local runtimepath = vim.api.nvim_list_runtime_paths()
  table.insert(runtimepath, 1, datapath)

  local bin_name = u.is_windows() and "server.exe" or "server"
  local bin_folder
  for _, path in ipairs(runtimepath) do
    local ok, err = vim.loop.fs_access(path, "w")
    if err == nil and ok ~= nil and ok then
      bin_folder = path .. u.path_separator .. "gitlab.nvim" .. u.path_separator .. "bin"
      if vim.fn.mkdir(bin_folder, "p") == 1 then
        state.settings.server.binary = bin_folder .. u.path_separator .. bin_name
        break
      end
    end
  end

  if state.settings.server.binary == nil then
    u.notify("Could not find a writable folder in the runtime path to save the server to.", vim.log.levels.ERROR)
    return
  end

  if not override then
    local binary_exists = vim.loop.fs_stat(state.settings.server.binary)
    if binary_exists ~= nil then
      return
    end
  end

  local version_output = vim
    .system({ "git", "describe", "--tags", "--always" }, { cwd = state.settings.root_path })
    :wait()
  local plugin_version = version_output.code == 0 and vim.trim(version_output.stdout) or "unknown"

  local ldflags = string.format("-X main.Version=%s", plugin_version)
  local res = vim
    .system(
      { "go", "build", "-buildvcs=false", "-ldflags", ldflags, "-o", state.settings.server.binary },
      { cwd = state.settings.root_path .. u.path_separator .. "cmd" }
    )
    :wait()

  if res.code ~= 0 then
    u.notify(string.format("Failed to install with status code %d:\n%s", res.code, res.stderr), vim.log.levels.ERROR)
    return false
  end

  u.notify("Installed successfully!", vim.log.levels.INFO)
  return true
end

-- Shuts down the Go server and clears out all old gitlab.nvim state
M.shutdown = function(cb)
  if not state.go_server_running then
    vim.notify("The gitlab.nvim server is not running", vim.log.levels.ERROR)
    return
  end
  client.send_request("/shutdown", "POST", { restart = false }, function(data)
    state.go_server_running = false
    state.clear_data()
    if cb then
      cb()
    else
      u.notify(data.message, vim.log.levels.INFO)
    end
  end)
end

---Restarts the Go server and clears out all gitlab.nvim state
M.restart = function(cb)
  if not state.go_server_running then
    vim.notify("The gitlab.nvim server is not running", vim.log.levels.ERROR)
    return
  end
  client.send_request("/shutdown", "POST", { restart = true }, function(data)
    state.go_server_running = false
    M.start(function()
      state.clear_data()
      if cb then
        cb()
      else
        u.notify(data.message, vim.log.levels.INFO)
      end
    end)
  end)
end

-- Runs `callback` with the version (git tag) that was baked into the binary when it was last built.
M.get_version = function(callback)
  if not state.go_server_running then
    u.notify("Gitlab server not running", vim.log.levels.ERROR)
    return
  end
  local parent_dir = u.get_root_path()

  local version_output = vim.system({ "git", "describe", "--tags", "--always" }, { cwd = parent_dir }):wait()
  local plugin_version = version_output.code == 0 and vim.trim(version_output.stdout) or "unknown"

  -- We call the "/version" endpoint here instead of through the regular send_request
  -- pattern because earlier versions of the plugin may not have the endpoint. We handle
  -- a 404 as an "unknown" version error.
  local cmd = {
    "curl",
    "--noproxy",
    "localhost",
    "-s",
    "-X",
    "GET",
    string.format("localhost:%s/version", state.settings.server.port),
  }
  local result = vim.system(cmd):wait()
  local _, data = pcall(vim.json.decode, result.stdout)
  local binary_version = data and data.version and data.version or "unknown"

  callback({ plugin_version = plugin_version, binary_version = binary_version })
end

return M