ls.nim

{.push raises: [], gcsafe.}

import
  std/[
    macros, strformat, os, sugar, hashes, osproc, tables, strutils, sets, uri, json,
    sequtils, setutils, times,
  ],
  with,
  chronos,
  chronos/[threadsync, asyncproc],
  chronicles,
  json_serialization,
  json_rpc/[errors, servers/socketserver],
  regex,
  stew/byteutils,
  ./protocol/[enums, types],
  ./[suggestapi, utils, nimcheck]

export RegexError

proc getVersionFromNimble(): string =
  #We should static run nimble dump instead
  const content = staticRead("nimlangserver.nimble")
  for v in content.splitLines:
    if v.startsWith("version"):
      return v.split("=")[^1].strip(chars = {' ', '"'})
  return "unknown"

const
  RESTART_COMMAND* = "nimlangserver.restart"
  RECOMPILE_COMMAND* = "nimlangserver.recompile"
  CHECK_PROJECT_COMMAND* = "nimlangserver.checkProject"
  FILE_CHECK_DELAY* = 1000
  LSPVersion* = getVersionFromNimble()
  USE_NIM_CHECK_BY_DEFAULT* = false
  NIM_EXPAND_ARC_BY_DEFAULT* = false
  NIM_EXPAND_MACRO_BY_DEFAULT* = false
  NIM_MAX_NS_PROCESSES* = 1
  MaxNimsuggestFails = 10

type
  NlsNimsuggestConfig* = ref object of RootObj
    projectFile*: string
    fileRegex*: string

  NlsWorkingDirectoryMaping* = ref object of RootObj
    projectFile*: string
    directory*: string

  NlsInlayTypeHintsConfig* = ref object of RootObj
    enable*: Option[bool]

  NlsInlayExceptionHintsConfig* = ref object of RootObj
    enable*: Option[bool]
    hintStringLeft*: Option[string]
    hintStringRight*: Option[string]

  NlsInlayParameterHintsConfig* = ref object of RootObj
    enable*: Option[bool]

  NlsInlayHintsConfig* = ref object of RootObj
    typeHints*: Option[NlsInlayTypeHintsConfig]
    exceptionHints*: Option[NlsInlayExceptionHintsConfig]
    parameterHints*: Option[NlsInlayParameterHintsConfig]

  NlsNotificationVerbosity* = enum
    nvNone = "none"
    nvError = "error"
    nvWarning = "warning"
    nvInfo = "info"

  NlsConfig* = ref object of RootObj
    projectMapping*: OptionalSeq[NlsNimsuggestConfig]
    workingDirectoryMapping*: OptionalSeq[NlsWorkingDirectoryMaping]
    checkOnSave*: Option[bool]
    nimsuggestPath*: Option[string]
    timeout*: Option[int]
    autoRestart*: Option[bool]
    autoCheckFile*: Option[bool]
    autoCheckProject*: Option[bool]
    logNimsuggest*: Option[bool]
    inlayHints*: Option[NlsInlayHintsConfig]
    notificationVerbosity*: Option[NlsNotificationVerbosity]
    formatOnSave*: Option[bool]
    nimsuggestIdleTimeout*: Option[int] #idle timeout in ms
    useNimCheck*: Option[bool]
    nimExpandArc*: Option[bool]
    nimExpandMacro*: Option[bool]
    maxNimsuggestProcesses*: Option[int]
      #max number of nimsuggest processes to keep alive. zero means unlimited
    nimsuggestTimeout*: Option[int]
      #timeout for the nimsuggest startup + initial compilation
    nimsuggestMaxMemory*: Option[int]
      #memory cap per nimsuggest process in MB. zero means unlimited
    useNimTrack*: Option[bool]

  NlsFileInfo* = ref object of RootObj
    projectFile*: Future[string].Raising([CancelledError, OSError, RegexError])
    changed*: bool
    fingerTable*: seq[seq[tuple[u16pos, offset: int]]]
    cancelFileCheck*: Future[void].Raising([CancelledError])
    checkInProgress*: bool
    needsChecking*: bool
    textDocument*: TextDocumentItem
    nimsuggestProject*: string

  CommandLineParams* = object
    mode*: Option[ServerMode]
    transport*: Option[TransportMode]
    port*: Port #only for sockets

  ServerMode* = enum
    lsp = "lsp"
    mcp = "mcp"

  TransportMode* = enum
    stdio = "stdio"
    socket = "socket"

  PendingRequestState* = enum
    prsOnGoing = "OnGoing"
    prsCancelled = "Cancelled"
    prsComplete = "Complete"

  PendingRequest* = object
    id*: uint
    name*: string
    request*: FutureBase
    projectFile*: Option[string]
    startTime*: DateTime
    endTime*: DateTime
    state*: PendingRequestState

  LanguageServer* = ref object
    case serverMode*: ServerMode
    of lsp:
      lspClientCapabilities*: LspClientCapabilities
      lspServerCapabilities*: LspServerCapabilities
      lspInitializeParams*: LspInitializeParams
    of mcp:
      mcpClientCapabilities*: McpClientCapabilities
      mcpServerCapabilities*: McpServerCapabilities
      mcpInitializeParams*: McpInitializeParams
    extensionCapabilities*: set[LspExtensionCapability]
    notifyAction*: NotifyAction
    callAction*: CallAction
    onExit*: OnExitCallback
    projectFiles*: Table[string, Project]
    nimsuggestCreations*: Table[string, Future[void].Raising([CancelledError])]
    openFiles*: Table[string, NlsFileInfo]
    workspaceConfiguration*: NlsConfig
      #What the client configured us with, or the defaults until it does.
      #Set through setWorkspaceConfiguration, read through getWorkspaceConfiguration.
    workspaceConfigurationReady*: Future[void].Raising([CancelledError])
      #Completed the first time a configuration is known, and never replaced.
    inlayHintsRefreshRequest*: Future[JsonNode].Raising([CancelledError, JsonRpcError])
    didChangeConfigurationRegistrationRequest*:
      Future[JsonNode].Raising([CancelledError, JsonRpcError])
    filesWithDiags*: HashSet[string]
    nimsuggestInit*: Future[void].Raising([CancelledError, OSError])
    lastNimsuggest*: Nimsuggest
    isShutdownNimsuggest*: bool
    initialized*: bool
      #Set once initialize has run. Until then routes can't rely on its state.
    isShutdown*: bool
    storageDir*: string
    nimDumpCache*: Table[string, NimbleDumpInfo] #path to NimbleDumpInfo
    entryPoints*: seq[string]
    testRunProcess*: Option[AsyncProcessRef]
      #There is only one test run process at a time
    srv*: RpcServer #Both modes use it to store the routes
    pendingRequests*: Table[uint, PendingRequest]
      #id to future. Each request is added here so we can cancel them later in the cancelRequest. Only requests, not notifications
    transportMode*: TransportMode
    served*: Future[void]
    projectErrors*: seq[ProjectError]
    lastStatusSent: JsonString
    failTable*: Table[string, int]
      #Project file to fail count
      #List of errors (crashes) nimsuggest has had since the lsp session started
    checkInProgress*: bool
    token: uint

  Certainty* = enum
    None
    Folder
    Cfg
    Nimble

  NimbleDumpInfo* = object
    srcDir*: string
    name*: string
    nimDir*: Option[string]
    nimblePath*: Option[string]
    entryPoints*: seq[string] #when it's empty, means the nimble version doesnt dump it.

  OnExitCallback* = proc(): Future[void] {.async: (raises: []).}
    #To be called when the server is shutting down
  NotifyAction* =
    proc(name: string, params: JsonString): Future[void] {.async: (raises: []).}
    #Send a notification to the client
  CallAction* = proc(name: string, params: JsonString): Future[JsonNode] {.
    async: (raises: [CancelledError, JsonRpcError])
  .} #Send a request to the client

macro `%*`*(t: untyped, inputStream: untyped): untyped =
  ## Typed JSON literal: `T %* {...}`. The literal is written in code, so a
  ## failing conversion is a programming error, not something to handle.
  let conv =
    newCall(bindSym("to", brOpen), newCall(bindSym("%*", brOpen), inputStream), t)
  result = quote:
    try:
      `conv`
    except ValueError:
      raiseAssert getCurrentExceptionMsg()

proc notify*[T](ls: LanguageServer, name: string, params: T) =
  asyncSpawn ls.notifyAction(name, JsonString LspJson.encode(params))

proc call*[T](
    ls: LanguageServer, name: string, params: T
): Future[JsonNode] {.async: (raw: true, raises: [CancelledError, JsonRpcError]).} =
  ls.callAction(name, JsonString LspJson.encode(params))

proc initLs*(params: CommandLineParams, storageDir: string): LanguageServer =
  LanguageServer(
    workspaceConfiguration: NlsConfig(),
    workspaceConfigurationReady: Future[void].Raising([CancelledError]).init("initLs"),
    filesWithDiags: initHashSet[string](),
    serverMode: params.mode.get(),
    transportMode: params.transport.get(stdio),
    openFiles: initTable[string, NlsFileInfo](),
    storageDir: storageDir,
    extensionCapabilities: LspExtensionCapability.items.toSet,
  )

proc createProgressToken*(ls: LanguageServer): string =
  inc ls.token
  "token-" & $ls.token

proc getNimbleEntryPoints*(
    dumpInfo: NimbleDumpInfo, nimbleProjectPath: string
): seq[string] =
  if dumpInfo.entryPoints.len > 0:
    result = dumpInfo.entryPoints.mapIt(nimbleProjectPath / it)
  else:
    #Nimble doesnt include the entry points, returning the nimble project file as the entry point
    let sourceDir = nimbleProjectPath / dumpInfo.srcDir
    result = @[sourceDir / (dumpInfo.name & ".nim")]
  result = result.filterIt(it.fileExists)

func typeHintsEnabled*(cnf: NlsConfig): bool =
  result = true
  if cnf.inlayHints.isSome and cnf.inlayHints.get.typeHints.isSome and
      cnf.inlayHints.get.typeHints.get.enable.isSome:
    result = cnf.inlayHints.get.typeHints.get.enable.get

func exceptionHintsEnabled*(cnf: NlsConfig): bool =
  result = false
  if cnf.inlayHints.isSome and cnf.inlayHints.get.exceptionHints.isSome and
      cnf.inlayHints.get.exceptionHints.get.enable.isSome:
    result = cnf.inlayHints.get.exceptionHints.get.enable.get

func parameterHintsEnabled*(cnf: NlsConfig): bool =
  result = true
  if cnf.inlayHints.isSome and cnf.inlayHints.get.parameterHints.isSome and
      cnf.inlayHints.get.parameterHints.get.enable.isSome:
    result = cnf.inlayHints.get.parameterHints.get.enable.get

func inlayHintsEnabled*(cnf: NlsConfig): bool =
  typeHintsEnabled(cnf) or exceptionHintsEnabled(cnf) or parameterHintsEnabled(cnf)

proc supportSignatureHelp*(cc: LspClientCapabilities): bool =
  if cc.isNil:
    return false
  let caps = cc.textDocument
  caps.isSome and caps.get.signatureHelp.isSome

proc getNimbleDumpInfo*(
    ls: LanguageServer, nimbleFile: string, workingDir = ""
): Future[NimbleDumpInfo] {.async: (raises: [CancelledError]).} =
  if nimbleFile in ls.nimDumpCache:
    return ls.nimDumpCache.getOrDefault(nimbleFile)
  debug "nimble dump starting",
    nimbleFile = nimbleFile, nimbleDir = getEnv("NIMBLE_DIR")
  var process: AsyncProcessRef
  try:
    process = await startProcess(
      "nimble",
      workingDir = nimbleFile.parentDir(),
      arguments = @["dump"],
      options = {UsePath},
      stderrHandle = ProcessStreamHandle(), # None => chronos doesn't
      # manage stderr, child inherits ours
      stdoutHandle = AsyncProcess.Pipe,
    )
    let info = string.fromBytes(process.stdoutStream.read().await)

    for line in info.splitLines:
      if line.startsWith("srcDir"):
        result.srcDir = line[(1 + line.find '"') ..^ 2]
      if line.startsWith("name"):
        result.name = line[(1 + line.find '"') ..^ 2]
      if line.startsWith("nimDir"):
        result.nimDir = some line[(1 + line.find '"') ..^ 2]
      if line.startsWith("nimblePath"):
        result.nimblePath = some line[(1 + line.find '"') ..^ 2]
      if line.startsWith("entryPoints"):
        result.entryPoints =
          line[(1 + line.find '"') ..^ 2].split(',').mapIt(it.strip(chars = {' ', '"'}))

    var nimbleFile = nimbleFile
    if nimbleFile == "" and result.nimblePath.isSome:
      nimbleFile = result.nimblePath.get
    if nimbleFile != "":
      ls.nimDumpCache[nimbleFile] = result

    debug "nimble dump finished",
      nimbleFile = nimbleFile, nimDir = result.nimDir.get("")
  except OSError, IOError, AsyncProcessError, AsyncStreamError:
    debug "Failed to get nimble dump info",
      nimbleFile = nimbleFile, err = getCurrentExceptionMsg()
  finally:
    if process != nil:
      await shutdownChildProcess(process)

proc parseWorkspaceConfiguration*(conf: JsonNode): NlsConfig =
  try:
    if conf.kind == JObject and conf["settings"].kind == JObject:
      let nimSettings = conf["settings"]["nim"]
      if nimSettings.kind == JNull:
        return NlsConfig() #the client has no settings for us
      return nimSettings.to(NlsConfig)
  except ValueError:
    discard
  try:
    let nlsConfig: seq[NlsConfig] = (%conf).to(seq[NlsConfig])
    result =
      if nlsConfig.len > 0 and nlsConfig[0] != nil:
        nlsConfig[0]
      else:
        NlsConfig()
  except ValueError:
    debug "Failed to parse the configuration.", error = getCurrentExceptionMsg()
    result = NlsConfig()

proc setWorkspaceConfiguration*(ls: LanguageServer, conf: JsonNode) {.raises: [].} =
  ls.workspaceConfiguration = parseWorkspaceConfiguration(conf)
  if not ls.workspaceConfigurationReady.finished:
    ls.workspaceConfigurationReady.complete()

proc getWorkspaceConfiguration*(ls: LanguageServer): NlsConfig {.raises: [].} =
  #TODO review and handle project specific confs when received instead of reliying in this func
  if ls.workspaceConfiguration.isNil:
    NlsConfig()
  else:
    ls.workspaceConfiguration

proc getAndWaitForWorkspaceConfiguration*(
    ls: LanguageServer
): Future[NlsConfig] {.async: (raises: [CancelledError]).} =
  await ls.workspaceConfigurationReady.join()
  ls.getWorkspaceConfiguration()

proc showMessage*(
    ls: LanguageServer, message: string, typ: MessageType
) {.raises: [].} =
  proc notify() =
    ls.notify(
      "window/showMessage", ShowMessageParams(`type`: typ.int, message: message)
    )

  let verbosity = ls.getWorkspaceConfiguration.notificationVerbosity.get(
    NlsNotificationVerbosity.nvInfo
  )
  debug "ShowMessage ", message = message
  case verbosity
  of nvInfo:
    notify()
  of nvWarning:
    if typ.int <= MessageType.Warning.int:
      notify()
  of nvError:
    if typ == MessageType.Error:
      notify()
  else:
    discard

proc applyEdit*(
    ls: LanguageServer, params: ApplyWorkspaceEditParams
): Future[ApplyWorkspaceEditResponse] {.
    async: (raises: [CancelledError, ValueError, JsonRpcError])
.} =
  let res = await ls.call("workspace/applyEdit", params)
  res.to(ApplyWorkspaceEditResponse)

proc toPendingRequestStatus(pr: PendingRequest): PendingRequestStatus =
  result.time =
    case pr.state
    of prsOnGoing:
      $(now() - pr.startTime)
    else:
      $(pr.endTime - pr.startTime)
  result.name = pr.name
  result.projectFile = pr.projectFile.get("")
  result.state = $pr.state

# https://microsoft.github.io/language-server-protocol/specifications/lsp/3.18/specification/#responseMessage
proc checkInitialized*(ls: LanguageServer) {.raises: [ApplicationError].} =
  if not ls.initialized:
    raise (ref ApplicationError)(
      code: ErrorCode.ServerNotInitialized.int, msg: "Server not initialized"
    )

proc filesServedBy(ls: LanguageServer, projectFile: string): seq[string] =
  for uri, file in ls.openFiles:
    if file.nimsuggestProject == projectFile:
      result.add uri

proc getLspStatus*(ls: LanguageServer): NimLangServerStatus {.raises: [].} =
  result.lspPath = getAppFilename()
  result.version = LSPVersion
  result.extensionCapabilities = ls.extensionCapabilities.toSeq
  for project in ls.projectFiles.values:
    let ns = project.ns
    if ns != nil:
      var nsStatus = NimsuggestStatus(
        projectFile: project.file,
        capabilities: ns.capabilities.toSeq,
        version: ns.version,
        path: ns.nimsuggestPath,
        port: ns.port,
      )
      nsStatus.openFiles = ls.filesServedBy(project.file)
      result.nimsuggestInstances.add nsStatus
  for openFile in ls.openFiles.keys:
    let openFilePath = openFile.uriToPath
    result.openFiles.add openFilePath

  result.pendingRequests = ls.pendingRequests.values.toSeq.map(toPendingRequestStatus)
  result.projectErrors = ls.projectErrors

proc sendStatusChanged*(ls: LanguageServer) {.raises: [].} =
  let status = JsonString LspJson.encode(ls.getLspStatus())
  if status != ls.lastStatusSent:
    ls.notify("extension/statusUpdate", status)
    ls.lastStatusSent = status

proc waitProjectFile*(
    file: NlsFileInfo
): Future[string] {.async: (raises: [CancelledError, OSError, RegexError]).} =
  ## Wait without allowing a cancelled request to cancel the shared future.
  await file.projectFile.join()
  try:
    file.projectFile.read()
  except FuturePendingError:
    raiseAssert "project file future remained pending after join"

proc addProjectFileToPendingRequest*(
    ls: LanguageServer, id: uint, uri: string
) {.async: (raises: []).} =
  try:
    if id in ls.pendingRequests:
      var projectFile = uri.uriToPath()
      if projectFile notin ls.projectFiles:
        if uri in ls.openFiles:
          projectFile = await ls.openFiles[uri].waitProjectFile()

      ls.pendingRequests[id].projectFile = some projectFile
      ls.sendStatusChanged
  except CancelledError:
    discard
  except KeyError, OSError, RegexError:
    error "addProjectFileToPendingRequest failed",
      uri = uri, msg = getCurrentExceptionMsg()

proc requiresDynamicRegistrationForDidChangeConfiguration(ls: LanguageServer): bool =
  ls.lspClientCapabilities.workspace.isSome and
    ls.lspClientCapabilities.workspace.get.didChangeConfiguration.isSome and
    ls.lspClientCapabilities.workspace.get.didChangeConfiguration.get.dynamicRegistration.get(
      false
    )

proc supportsConfigurationRequest(ls: LanguageServer): bool =
  ls.lspClientCapabilities.workspace.isSome and
    ls.lspClientCapabilities.workspace.get.configuration.get(false)

proc usePullConfigurationModel*(ls: LanguageServer): bool =
  ls.requiresDynamicRegistrationForDidChangeConfiguration and
    ls.supportsConfigurationRequest

proc inlayExceptionHintsConfigurationEquals*(a, b: NlsInlayHintsConfig): bool =
  if a.exceptionHints.isSome and b.exceptionHints.isSome:
    let
      ae = a.exceptionHints.get
      be = b.exceptionHints.get
    result =
      (ae.enable == be.enable) and (ae.hintStringLeft == be.hintStringLeft) and
      (ae.hintStringRight == be.hintStringRight)
  else:
    result = a.exceptionHints.isSome == b.exceptionHints.isSome

proc inlayExceptionHintsConfigurationEquals*(a, b: NlsConfig): bool =
  if a.inlayHints.isSome and b.inlayHints.isSome:
    result = inlayExceptionHintsConfigurationEquals(a.inlayHints.get, b.inlayHints.get)
  else:
    result = a.inlayHints.isSome == b.inlayHints.isSome

proc inlayHintsConfigurationEquals*(a, b: NlsConfig): bool =
  proc inlayTypeHintsConfigurationEquals(a, b: NlsInlayHintsConfig): bool =
    if a.typeHints.isSome and b.typeHints.isSome:
      result = a.typeHints.get.enable == b.typeHints.get.enable
    else:
      result = a.typeHints.isSome == b.typeHints.isSome

  proc inlayHintsConfigurationEquals(a, b: NlsInlayHintsConfig): bool =
    result =
      inlayTypeHintsConfigurationEquals(a, b) and
      inlayExceptionHintsConfigurationEquals(a, b)

  if a.inlayHints.isSome and b.inlayHints.isSome:
    result = inlayHintsConfigurationEquals(a.inlayHints.get, b.inlayHints.get)
  else:
    result = a.inlayHints.isSome == b.inlayHints.isSome

proc getNimVersion(nimDir: string): string {.raises: [OSError, IOError].} =
  let cmd =
    if nimDir == "":
      "nim --version"
    else:
      nimDir / "nim --version"
  let info = execProcess(cmd)
  const NimCompilerVersion = "Nim Compiler Version "
  for line in info.splitLines:
    if line.startsWith(NimCompilerVersion):
      return line

proc getNimsuggestPathAndVersion(
    ls: LanguageServer, conf: NlsConfig, workingDir: string
): Future[(string, string)] {.async: (raises: [CancelledError, OSError, IOError]).} =
  let nimbleFiles = walkFiles(workingDir / "*.nimble").toSeq

  let nimbleDumpInfo =
    if nimbleFiles.len > 0:
      await ls.getNimbleDumpInfo(nimbleFiles[0], workingDir)
    else:
      await ls.getNimbleDumpInfo("", workingDir)

  let nimDir = nimbleDumpInfo.nimDir.get ""
  var nimsuggestPath = expandTilde(conf.nimsuggestPath.get(""))
  var nimVersion = ""
  if nimsuggestPath == "":
    if nimDir != "" and nimDir.dirExists:
      nimVersion = getNimVersion(nimDir) & " from " & nimDir
      nimsuggestPath = nimDir / "nimsuggest"
    else:
      nimVersion = getNimVersion("")
      nimsuggestPath = findExe "nimsuggest"
  else:
    nimVersion = getNimVersion(nimsuggestPath.parentDir)
  # ls.showMessage(fmt "Using {nimVersion}", MessageType.Info)
  debug "Using {nimVersion}", nimVersion = nimVersion
  (nimsuggestPath, nimVersion)

proc getNimPath*(
    ls: LanguageServer, conf: NlsConfig, workingDir = ""
): Future[Option[string]] {.async: (raises: [CancelledError, OSError, IOError]).} =
  if conf.nimsuggestPath.isSome and conf.nimsuggestPath.get().fileExists():
    some(conf.nimsuggestPath.get.parentDir / "nim")
  else:
    let (nimsuggestPath, _) = await ls.getNimsuggestPathAndVersion(conf, workingDir)
    let path =
      if nimsuggestPath.fileExists():
        nimsuggestPath.parentDir / "nim"
      else:
        findExe "nim"

    if path != "":
      some(path)
    else:
      warn "Failed to find nim path"
      none(string)

proc getProjectFileAutoGuess*(
    ls: LanguageServer, fileUri: string
): Future[string] {.async: (raises: [CancelledError, OSError]).} =
  let file = fileUri.decodeUrl
  debug "Auto-guessing project file for", file = file
  result = file
  let (dir, _, _) = result.splitFile()
  var
    path = dir
    certainty = Certainty.None
    up = 0

  let conf = ls.getWorkspaceConfiguration()
  let maxNimsuggestProcesses = conf.maxNimsuggestProcesses.get(NIM_MAX_NS_PROCESSES)
  # When using only one nimsuggest process, we should not search for parent projects
  # as this will cause all files to be opened in the same nimsuggest process.
  let maxUp = if maxNimsuggestProcesses == 1: 0 else: 2
  while path.len > 0 and path != "/" and up < maxUp:
    let
      (dir, fname, ext) = path.splitFile()
      current = fname & ext
    if fileExists(path / current.addFileExt(".nim")) and certainty <= Folder:
      result = path / current.addFileExt(".nim")
      certainty = Folder
    if fileExists(path / current.addFileExt(".nim")) and (
      fileExists(path / current.addFileExt(".nim.cfg")) or
      fileExists(path / current.addFileExt(".nims"))
    ) and certainty <= Cfg:
      result = path / current.addFileExt(".nim")
      certainty = Cfg
    if certainty <= Nimble:
      for nimble in walkFiles(path / "*.nimble"):
        let dumpInfo = await ls.getNimbleDumpInfo(nimble)
        let name = dumpInfo.name
        let sourceDir = path / dumpInfo.srcDir
        let projectFile = sourceDir / (name & ".nim")
        if sourceDir.len != 0 and name.len != 0 and file.isRelTo(sourceDir) and
            fileExists(projectFile):
          debug "Found nimble project", projectFile = projectFile
          result = projectFile
          certainty = Nimble
          return
    if path == dir:
      break
    path = dir
    inc up

proc getRootPath*(ip: LspInitializeParams): string {.raises: [OSError].} =
  if ip.rootUri.isNone or ip.rootUri.get == "":
    if ip.rootPath.isSome and ip.rootPath.get != "":
      return ip.rootPath.get
    else:
      return getCurrentDir().pathToUri.uriToPath

  ip.rootUri.get.uriToPath

proc getRootPath*(ip: McpInitializeParams): string {.raises: [OSError].} =
  getCurrentDir().pathToUri.uriToPath

proc getWorkingDir*(
    ls: LanguageServer, path: string
): Future[string] {.async: (raises: [OSError]).} =
  let rootPath =
    case ls.serverMode
    of lsp: ls.lspInitializeParams.getRootPath
    of mcp: ls.mcpInitializeParams.getRootPath

  let
    pathRelativeToRoot = path.tryRelativeTo(rootPath)
    mapping = ls.getWorkspaceConfiguration().workingDirectoryMapping.get(@[])

  result = rootPath

  for m in mapping:
    if pathRelativeToRoot.isSome and m.projectFile == pathRelativeToRoot.get():
      result = rootPath / m.directory
      break

proc progressSupported(ls: LanguageServer): bool =
  result = ls.lspInitializeParams.capabilities.window
    .get(ClientCapabilities_window()).workDoneProgress
    .get(false)

proc progress*(ls: LanguageServer, token, kind: string, title = "") =
  if ls.progressSupported:
    ls.notify(
      "$/progress",
      ProgressParams(token: token, value: some %*{"kind": kind, "title": title}),
    )

proc workDoneProgressCreate*(ls: LanguageServer, token: string) =
  if ls.progressSupported:
    discard ls.call("window/workDoneProgress/create", ProgressParams(token: token))

proc cancelPendingFileChecks*(ls: LanguageServer, nimsuggest: Nimsuggest) =
  # stop all checks on file level if we are going to run checks on project
  # level.
  for uri in ls.filesServedBy(nimsuggest.project.file):
    let fileData = ls.openFiles.getOrDefault(uri)
    if fileData != nil:
      let cancelFileCheck = fileData.cancelFileCheck
      if cancelFileCheck != nil and not cancelFileCheck.finished:
        cancelFileCheck.complete()
      fileData.needsChecking = false

proc uriStorageLocation*(ls: LanguageServer, uri: string): string =
  ls.storageDir / (hash(uri).toHex & ".nim")

proc uriToStash*(ls: LanguageServer, uri: string): string =
  let file = ls.openFiles.getOrDefault(uri)
  if file != nil and file.changed:
    uriStorageLocation(ls, uri)
  else:
    ""

proc toUtf16Pos*(
    ls: LanguageServer, uri: string, line: int, utf8Pos: int
): Option[int] =
  let file = ls.openFiles.getOrDefault(uri)
  if file != nil and line in 0 ..< file.fingerTable.len:
    let utf16Pos = file.fingerTable[line].utf8to16(utf8Pos)
    return some(utf16Pos)
  else:
    return none(int)

proc toUtf16Pos*(suggest: Suggest, ls: LanguageServer): Suggest =
  result = suggest
  let uri = pathToUri(suggest.filePath)
  let pos = toUtf16Pos(ls, uri, suggest.line - 1, suggest.column)
  if pos.isSome:
    result.column = pos.get()

proc toUtf16Pos*(
    suggest: SuggestInlayHint, ls: LanguageServer, uri: string
): SuggestInlayHint =
  result = suggest
  let pos = toUtf16Pos(ls, uri, suggest.line - 1, suggest.column)
  if pos.isSome:
    result.column = pos.get()

proc toUtf16Pos*(checkResult: CheckResult, ls: LanguageServer): CheckResult =
  result = checkResult
  let uri = pathToUri(checkResult.file)
  let pos = toUtf16Pos(ls, uri, checkResult.line - 1, checkResult.column)
  if pos.isSome:
    result.column = pos.get()

  for i in 0 ..< result.stacktrace.len:
    let stPos =
      toUtf16Pos(ls, uri, result.stacktrace[i].line - 1, result.stacktrace[i].column)
    if stPos.isSome:
      result.stacktrace[i].column = stPos.get()

proc range*(startLine, startCharacter, endLine, endCharacter: int): Range =
  return
    Range %* {
      "start": {"line": startLine, "character": startCharacter},
      "end": {"line": endLine, "character": endCharacter},
    }

proc toLabelRange*(suggest: Suggest): Range =
  with suggest:
    return range(line - 1, column, line - 1, column + utf16Len(qualifiedPath[^1]))

proc toDiagnostic(suggest: Suggest): Diagnostic =
  with suggest:
    let
      textStart = doc.find('\'')
      textEnd = doc.rfind('\'')
      endColumn =
        if textStart >= 0 and textEnd > textStart:
          column + utf16Len(doc[textStart + 1 ..< textEnd])
        else:
          column + 1

    return
      Diagnostic %* {
        "uri": pathToUri(filePath),
        "range": range(line - 1, column, line - 1, endColumn),
        "severity":
          case forth
          of "Error": DiagnosticSeverity.Error.int
          of "Hint": DiagnosticSeverity.Hint.int
          of "Warning": DiagnosticSeverity.Warning.int
          else: DiagnosticSeverity.Error.int
        ,
        "message": doc,
        "source": "nim",
        "code": "nimsuggest chk",
      }

proc toDiagnostic(checkResult: CheckResult): Diagnostic =
  let
    textStart = checkResult.msg.find('\'')
    textEnd = checkResult.msg.rfind('\'')
    endColumn =
      if textStart >= 0 and textEnd >= 0 and textEnd > textStart:
        checkResult.column + utf16Len(checkResult.msg[textStart + 1 ..< textEnd])
      else:
        checkResult.column + 1

  return
    Diagnostic %* {
      "uri": pathToUri(checkResult.file),
      "range": range(
        checkResult.line - 1,
        max(0, checkResult.column),
        checkResult.line - 1,
        max(0, endColumn),
      ),
      "severity":
        case checkResult.severity
        of "Error": DiagnosticSeverity.Error.int
        of "Hint": DiagnosticSeverity.Hint.int
        of "Warning": DiagnosticSeverity.Warning.int
        else: DiagnosticSeverity.Error.int
      ,
      "message": checkResult.msg,
      "source": "nim",
      "code": "nim check",
    }

proc sendDiagnostics*(
    ls: LanguageServer, diagnostics: seq[Suggest] | seq[CheckResult], path: string
) =
  trace "Sending diagnostics", count = diagnostics.len, path = path
  let params =
    PublishDiagnosticsParams %* {
      "uri": pathToUri(path),
      "diagnostics": diagnostics.map(x => x.toUtf16Pos(ls).toDiagnostic),
    }
  ls.notify("textDocument/publishDiagnostics", params)
  if diagnostics.len != 0:
    ls.filesWithDiags.incl path
  else:
    ls.filesWithDiags.excl path

proc warnIfUnknown*(
    ls: LanguageServer, ns: Nimsuggest, uri: string, projectFile: string
): Future[void] {.async: (raises: [CancelledError]).} =
  let path = uri.uriToPath
  let isFileKnown = await ns.isKnown(path)
  if not isFileKnown and not ns.canHandleUnknown:
    ls.showMessage(
      fmt """{path} is not compiled as part of project {projectFile}.
  In orde to get the IDE features working you must either configure nim.projectMapping or import the module.""",
      MessageType.Warning,
    )

proc createOrRestartNimsuggest*(
  ls: LanguageServer, projectFile: string, uri = ""
): Future[void] {.async: (raw: true, raises: [CancelledError]).}

proc isLiveNimsuggestProject(ls: LanguageServer, projectFile: string): bool =
  projectFile in ls.projectFiles or projectFile in ls.nimsuggestCreations

proc liveNimsuggestProjects*(ls: LanguageServer): seq[string] =
  ## Running + starting instances.
  for entryPoint in ls.entryPoints:
    if ls.isLiveNimsuggestProject(entryPoint) and entryPoint notin result:
      result.add entryPoint
  for projectFile in ls.projectFiles.keys:
    if projectFile notin result:
      result.add projectFile
  for projectFile in ls.nimsuggestCreations.keys:
    if projectFile notin result:
      result.add projectFile

proc canSpawnNimsuggest(ls: LanguageServer): bool =
  let nsCount = ls.liveNimsuggestProjects.len
  let conf = ls.getWorkspaceConfiguration()
  let maxNimsuggestProcesses = conf.maxNimsuggestProcesses.get(NIM_MAX_NS_PROCESSES)
  result = maxNimsuggestProcesses == 0 or nsCount < maxNimsuggestProcesses
  debug "canSpawnNimsuggest",
    result = result, nsCount = nsCount, maxNimsuggestProcesses = maxNimsuggestProcesses

proc reuseLiveNimsuggestProject(ls: LanguageServer): string =
  let live = ls.liveNimsuggestProjects
  if live.len > 0:
    result = live[0]
    debug "Reached the maximum instances of nimsuggest, reusing the first nimsuggest instance",
      project = result

proc mappedProjectFiles(ls: LanguageServer): seq[string] {.raises: [OSError].} =
  let rootPath =
    case ls.serverMode
    of mcp:
      ls.mcpInitializeParams.getRootPath()
    of lsp:
      ls.lspInitializeParams.getRootPath()
  ls.getWorkspaceConfiguration().projectMapping.get(@[]).mapIt(
    rootPath / it.projectFile
  )

proc nimsuggestProjectFor(
    ls: LanguageServer, projectFile: string
): string {.raises: [OSError].} =
  if ls.isLiveNimsuggestProject(projectFile) or projectFile in ls.mappedProjectFiles() or
      ls.canSpawnNimsuggest():
    projectFile
  else:
    ls.reuseLiveNimsuggestProject()

proc initNimsuggestInstances*(
    ls: LanguageServer, rootPath: string
) {.async: (raises: [CancelledError, OSError]).} =
  if rootPath == "":
    return

  let nimbleFiles = walkFiles(rootPath / "*.nimble").toSeq
  if nimbleFiles.len > 0:
    let nimbleFile = nimbleFiles[0]
    let nimbleDumpInfo = await ls.getNimbleDumpInfo(nimbleFile)
    ls.entryPoints = nimbleDumpInfo.getNimbleEntryPoints(rootPath)
    for entryPoint in ls.entryPoints:
      if not ls.isLiveNimsuggestProject(entryPoint) and ls.canSpawnNimsuggest():
        debug "Starting nimsuggest for entry point ", entry = entryPoint
        await ls.createOrRestartNimsuggest(entryPoint)

proc failoverProject(ls: LanguageServer, projectFile: string): string =
  if ls.failTable.getOrDefault(projectFile, 0) < MaxNimsuggestFails:
    projectFile
  else:
    let others = ls.projectFiles.keys.toSeq.filterIt(
      it != projectFile and ls.failTable.getOrDefault(it, 0) < MaxNimsuggestFails
    )
    if others.len > 0:
      others[0]
    else:
      ""

proc hasServingNimsuggest(ls: LanguageServer, file: NlsFileInfo): bool =
  file.nimsuggestProject != "" and ls.isLiveNimsuggestProject(file.nimsuggestProject) and
    ls.failTable.getOrDefault(file.nimsuggestProject, 0) < MaxNimsuggestFails

proc getNimsuggestInner(
    ls: LanguageServer, uri: string
): Future[Nimsuggest] {.async: (raises: [CancelledError, OSError, RegexError]).} =
  let file = ls.openFiles.getOrDefault(uri)
  if file == nil:
    debug "File is no longer open", uri = uri
    return nil

  let projectFile = await file.waitProjectFile()
  if not ls.hasServingNimsuggest(file):
    let ownProject = ls.nimsuggestProjectFor(projectFile)
    file.nimsuggestProject = ls.failoverProject(ownProject)
    if file.nimsuggestProject notin ["", ownProject]:
      debug "Reusing nimsuggest instance for",
        uri = uri, projectFile = file.nimsuggestProject
  let nsProject = file.nimsuggestProject
  if nsProject == "":
    return nil
  if not ls.projectFiles.hasKey(nsProject):
    debug "Creating new nimsuggest instance", uri = uri, projectFile = nsProject
    await ls.createOrRestartNimsuggest(nsProject, uri)
    # Wait a bit to allow nimsuggest to start
    await sleepAsync(10)

  # Check multiple times with small delays
  var attempts = 0
  const maxAttempts = 10
  while attempts < maxAttempts:
    let project = ls.projectFiles.getOrDefault(nsProject)
    if project != nil:
      ls.lastNimsuggest = project.ns
      return project.ns

    inc attempts
    if attempts < maxAttempts:
      await sleepAsync(100)
      debug "Waiting for nimsuggest to initialize",
        uri = uri, projectFile = nsProject, attempt = attempts

  debug "Failed to get nimsuggest after waiting", uri = uri, projectFile = nsProject
  return nil

proc tryGetNimsuggest*(
  ls: LanguageServer, uri: string
): Future[Option[Nimsuggest]] {.
  async: (raises: [CancelledError, OSError, IOError, RegexError])
.}

proc checkFile*(
  ls: LanguageServer, file: NlsFileInfo
): Future[void] {.
  async: (
    raises: [
      CancelledError, AsyncProcessError, AsyncStreamError, OSError, IOError, RegexError,
      NimsuggestError,
    ]
  )
.}

proc didCloseFile*(
    ls: LanguageServer, uri: string
): Future[void] {.async: (raises: []).} =
  debug "Closed the following document:", uri = uri

  let file = ls.openFiles.getOrDefault(uri)
  ls.openFiles.del uri

  if file != nil and file.changed:
    # check the file if it is closed but not saved.
    traceAsyncErrors ls.checkFile(file)

proc getProjectFile*(
  fileUri: string, ls: LanguageServer
): Future[string] {.async: (raises: [CancelledError, OSError, RegexError]).}

proc getProjectFileAfterStartup(
    ls: LanguageServer, fileUri: string
): Future[string] {.async: (raises: [CancelledError, OSError, RegexError]).} =
  ## Resolve files after Nimble entry-point startup has completed. Otherwise
  ## the single-process limit can make auto-guessing fall back to the opened
  ## file while the intended entry-point nimsuggest is still compiling.
  if not ls.nimsuggestInit.isNil:
    await ls.nimsuggestInit.join()
  await getProjectFile(fileUri, ls)

proc didOpenFile*(
    ls: LanguageServer, textDocument: TextDocumentItem
): Future[void] {.async: (raises: [CancelledError, OSError, IOError, RegexError]).} =
  with textDocument:
    debug "New document opened for URI:", uri = uri
    let
      file = open(ls.uriStorageLocation(uri), fmWrite)
      projectFileFuture = ls.getProjectFileAfterStartup(uriToPath(uri))
    ls.openFiles[uri] = NlsFileInfo(
      projectFile: projectFileFuture,
      changed: false,
      fingerTable: @[],
      textDocument: textDocument,
    )

    for line in text.splitLines:
      let openFile = ls.openFiles.getOrDefault(uri)
      if openFile != nil:
        openFile.fingerTable.add line.createUTFMapping()
        file.writeLine line
    file.close()

    let openFile = ls.openFiles.getOrDefault(uri)
    if openFile == nil:
      return
    let projectFile = await openFile.waitProjectFile()
    debug "Document associated with the following projectFile",
      uri = uri, projectFile = projectFile
    let ns = await ls.tryGetNimsuggest(uri)
    if ns.isSome:
      discard ls.warnIfUnknown(ns.get(), uri, projectFile)

    let projectFileUri = projectFile.pathToUri
    if projectFileUri notin ls.openFiles:
      var textDocument = TextDocumentItem(
        uri: projectFileUri, languageId: "nim", version: 0, text: readFile(projectFile)
      )

      await didOpenFile(ls, textDocument)

      debug "Opening project file", uri = projectFile, file = uri
    ls.showMessage(fmt "Opening {uri}", MessageType.Info)

proc tryGetNimsuggest*(
    ls: LanguageServer, uri: string
): Future[Option[Nimsuggest]] {.
    async: (raises: [CancelledError, OSError, IOError, RegexError])
.} =
  if uri notin ls.openFiles:
    return none(Nimsuggest)

  var retryCount = 0
  const maxRetries = 3
  while retryCount < maxRetries:
    let ns = await getNimsuggestInner(ls, uri)
    if not ns.isNil:
      return some ns

    let file = ls.openFiles.getOrDefault(uri)
    if file == nil or file.nimsuggestProject == "":
      break

    # If nimsuggest is nil, wait a bit and retry
    inc retryCount
    if retryCount < maxRetries:
      debug "Nimsuggest not ready, retrying...", uri = uri, attempt = retryCount
      await sleepAsync(10000 * retryCount) # Exponential backoff

  debug "Nimsuggest not found after retries", uri = uri
  return none(Nimsuggest)

proc checkProject*(
    ls: LanguageServer, uri: string
): Future[void] {.
    async: (
      raises: [
        CancelledError, AsyncProcessError, AsyncStreamError, OSError, IOError,
        RegexError, NimsuggestError,
      ]
    )
.} =
  if ls.checkInProgress:
    return
  ls.checkInProgress = true
  defer:
    ls.checkInProgress = false

  if not ls.getWorkspaceConfiguration().autoCheckProject.get(true):
    return
  let conf = await ls.getAndWaitForWorkspaceConfiguration()
  let useNimCheck = conf.useNimCheck.get(USE_NIM_CHECK_BY_DEFAULT)

  let nimPath = await ls.getNimPath(conf)

  if useNimCheck and nimPath.isSome:
    proc getFilePath(c: CheckResult): string =
      c.file

    let token = ls.createProgressToken()
    ls.workDoneProgressCreate(token)
    ls.progress(token, "begin", fmt "Checking project {uri}")
    defer:
      ls.progress(token, "end")
    if uri == "":
      warn "Checking project with empty uri", uri = uri
      return
    let diagnostics = await nimCheck(uriToPath(uri), nimPath.get)
    let filesWithDiags = diagnostics.map(r => r.file).toHashSet

    debug "Found diagnostics", file = filesWithDiags
    for (path, diags) in groupBy(diagnostics, getFilePath):
      ls.sendDiagnostics(diags, path)

    # clean files with no diags
    for path in ls.filesWithDiags:
      if not filesWithDiags.contains path:
        debug "Sending zero diags", path = path
        let params =
          PublishDiagnosticsParams %* {"uri": pathToUri(path), "diagnostics": @[]}
        ls.notify("textDocument/publishDiagnostics", params)
    ls.filesWithDiags = filesWithDiags
    return

  debug "Running diagnostics", uri = uri
  let ns = await ls.tryGetNimsuggest(uri)
  if ns.isNone:
    return
  let nimsuggest = ns.get
  if nimsuggest.checkProjectInProgress:
    debug "Check project is already running", uri = uri
    nimsuggest.needsCheckProject = true
    return

  ls.cancelPendingFileChecks(nimsuggest)

  let token = ls.createProgressToken()
  ls.workDoneProgressCreate(token)
  ls.progress(token, "begin", fmt "Checking project {uri.uriToPath}")
  nimsuggest.checkProjectInProgress = true
  defer:
    nimsuggest.checkProjectInProgress = false
    ls.progress(token, "end")

  proc getFilepath(s: Suggest): string =
    s.filePath

  let
    diagnostics = nimsuggest.chk(uriToPath(uri), ls.uriToStash(uri)).await().filter(
        sug => sug.filePath != "???"
      )
    filesWithDiags = diagnostics.map(s => s.filePath).toHashSet

  debug "Found diagnostics", file = filesWithDiags
  for (path, diags) in groupBy(diagnostics, getFilepath):
    ls.sendDiagnostics(diags, path)

  # clean files with no diags
  for path in ls.filesWithDiags:
    if not filesWithDiags.contains path:
      debug "Sending zero diags", path = path
      let params =
        PublishDiagnosticsParams %* {"uri": pathToUri(path), "diagnostics": @[]}
      ls.notify("textDocument/publishDiagnostics", params)
  ls.filesWithDiags = filesWithDiags

  if nimsuggest.needsCheckProject:
    nimsuggest.needsCheckProject = false
    callSoon do(data: pointer) {.gcsafe.}:
      debug "Running delayed check project...", uri = uri
      traceAsyncErrors ls.checkProject(uri)

proc onErrorCallback(
    args: (LanguageServer, string), project: Project
): Future[void] {.async: (raises: []).} =
  let
    ls = args[0]
    uri = args[1]
  debug "Nimsuggest needed to be restarted due to an error "
  ls.failTable[project.file] = ls.failTable.getOrDefault(project.file, 0) + 1
  debug "Fail count", count = ls.failTable[project.file]
  let configuration = ls.getWorkspaceConfiguration()
  warn "Server stopped.", projectFile = project.file
  try:
    if configuration.autoRestart.get(true) and project.ns != nil and
        project.ns.successfullCall:
      await ls.createOrRestartNimsuggest(project.file, uri)
    else:
      ls.showMessage(
        fmt "Server failed with {project.errorMessage}.", MessageType.Error
      )
  except CancelledError:
    let ex = getCurrentException()
    error "An error has ocurred while handling nimsuggest err", msg = ex.msg
    writeStackTrace(ex)
  finally:
    if project.file != "":
      ls.projectErrors.add ProjectError(
        projectFile: project.file,
        errorMessage: project.errorMessage,
        lastKnownCmd: project.lastCmd,
      )
      ls.sendStatusChanged()

proc createOrRestartNimsuggestImpl(
    ls: LanguageServer, projectFile: string, uri: string
): Future[void] {.async: (raises: [CancelledError]).} =
  let projectNext =
    try:
      debug "Starting createOrRestartNimsuggest", projectFile = projectFile, uri = uri
      let
        configuration = ls.getWorkspaceConfiguration()
        workingDir = await ls.getWorkingDir(projectFile)
        (nimsuggestPath, version) =
          await ls.getNimsuggestPathAndVersion(configuration, workingDir)
        timeout = configuration.timeout.get(REQUEST_TIMEOUT)
        restartCallback = proc(
            ns: Nimsuggest
        ): Future[void] {.async: (raises: [CancelledError]).} =
          warn "Restarting the server due to requests being to slow",
            projectFile = projectFile
          ls.showMessage(
            fmt "Restarting nimsuggest for file {projectFile} due to timeout.",
            MessageType.Warning,
          )
          await ls.createOrRestartNimsuggest(projectFile, uri)
          ls.sendStatusChanged()
        errorCallback = partial(onErrorCallback, (ls, uri))

      debug "Creating new nimsuggest project", projectFile = projectFile

      let projectFut = createNimsuggest(
        projectFile,
        nimsuggestPath,
        version,
        timeout,
        restartCallback,
        errorCallback,
        workingDir,
        configuration.logNimsuggest.get(false),
        configuration.exceptionHintsEnabled,
        configuration.nimsuggestMaxMemory,
      )
      if not await chronos.withTimeout(
        projectFut,
        chronos.milliseconds(
          configuration.nimsuggestTimeout.get(NIMSUGGEST_STARTUP_TIMEOUT)
        ),
      ):
        error "Nimsuggest startup timed out", projectFile = projectFile
        nil
      else:
        await projectFut
    except CancelledError as exc:
      debug "Create/restart nimsuggest cancelled", projectFile = projectFile
      raise exc
    except ValueError, OSError, IOError, AsyncProcessError, AsyncStreamError:
      error "Failed to create/restart nimsuggest",
        projectFile = projectFile, error = getCurrentExceptionMsg()
      nil

  if projectNext != nil:
    debug "Nimsuggest initialized successfully", projectFile = projectFile
    let project = ls.projectFiles.getOrDefault(projectFile)
    if project != nil:
      project.stop()
    ls.projectFiles[projectFile] = projectNext
    ls.failTable.del(projectFile)
    ls.showMessage(fmt "Nimsuggest initialized for {projectFile}", MessageType.Info)
    traceAsyncErrors ls.checkProject(uri)
    ls.sendStatusChanged()

proc createOrRestartNimsuggestUnprotected(
    ls: LanguageServer, projectFile: string, uri: string
): Future[void] {.async: (raises: [CancelledError]).} =
  if ls.isShutdownNimsuggest:
    debug "Not starting nimsuggest, the server is shutting down",
      projectFile = projectFile
    return
  let inFlight = ls.nimsuggestCreations.getOrDefault(projectFile)
  if not inFlight.isNil and not inFlight.finished:
    await inFlight
  else:
    let creation = ls.createOrRestartNimsuggestImpl(projectFile, uri)
    ls.nimsuggestCreations[projectFile] = creation
    try:
      await creation
    finally:
      if ls.nimsuggestCreations.getOrDefault(projectFile) == creation:
        ls.nimsuggestCreations.del(projectFile)

proc createOrRestartNimsuggest*(
    ls: LanguageServer, projectFile: string, uri = ""
): Future[void] {.async: (raw: true, raises: [CancelledError]).} =
  ls.createOrRestartNimsuggestUnprotected(projectFile, uri).join()

proc restartAllNimsuggestInstances(
    ls: LanguageServer
): Future[void] {.async: (raises: [CancelledError]).} =
  debug "Restarting all nimsuggest instances"
  for projectFile in ls.projectFiles.keys.toSeq:
    await ls.createOrRestartNimsuggest(projectFile, projectFile.pathToUri)

proc maybeRegisterCapabilityDidChangeConfiguration*(ls: LanguageServer) =
  if ls.requiresDynamicRegistrationForDidChangeConfiguration:
    let registrationParams = RegistrationParams(
      registrations: some(
        @[
          Registration(
            id: "a4606617-82c1-4e22-83db-0095fecb1093",
            `method`: "workspace/didChangeConfiguration",
          )
        ]
      )
    )
    let registration = ls.call("client/registerCapability", registrationParams)
    ls.didChangeConfigurationRegistrationRequest = registration
    registration.addCallback do(data: pointer) {.gcsafe.}:
      if registration.completed:
        debug "Got response for the didChangeConfiguration registration:",
          res = $registration.read()
      else:
        warn "The didChangeConfiguration registration failed",
          err = registration.error.msg

proc handleConfigurationChanges*(
    ls: LanguageServer, oldConfiguration, newConfiguration: NlsConfig
): Future[void] {.async: (raises: [CancelledError]).} =
  if ls.lspClientCapabilities.workspace.isSome and
      ls.lspClientCapabilities.workspace.get.inlayHint.isSome and
      ls.lspClientCapabilities.workspace.get.inlayHint.get.refreshSupport.get(false) and
      not inlayHintsConfigurationEquals(oldConfiguration, newConfiguration):
    # toggling the exception hints triggers a full nimsuggest restart, since they are controlled by a nimsuggest command line option
    #   --exceptionInlayHints:on|off
    if not inlayExceptionHintsConfigurationEquals(oldConfiguration, newConfiguration):
      await ls.restartAllNimsuggestInstances()
    debug "Sending inlayHint refresh"
    #An empty object means no params at all
    ls.inlayHintsRefreshRequest = ls.call("workspace/inlayHint/refresh", JsonString"{}")

proc maybeRequestConfigurationFromClient*(
    ls: LanguageServer
): Future[void] {.async: (raises: []).} =
  if ls.supportsConfigurationRequest:
    debug "Requesting configuration from the client"
    try:
      let configurationParams = ConfigurationParams %* {"items": [{"section": "nim"}]}
      let configuration = await ls.call("workspace/configuration", configurationParams)
      debug "Received the following configuration", configuration = $configuration
      #the first configuration is not a change, so there is nothing to handle
      let
        hadConfiguration = ls.workspaceConfigurationReady.finished
        oldConfiguration = ls.getWorkspaceConfiguration()
      ls.setWorkspaceConfiguration(configuration)
      if hadConfiguration:
        await ls.handleConfigurationChanges(
          oldConfiguration, ls.getWorkspaceConfiguration()
        )
    except CancelledError:
      error "Failed to handle the client configuration",
        error = getCurrentExceptionMsg()
    except JsonRpcError as exc:
      error "Failed to request the client configuration", error = exc.msg
      ls.setWorkspaceConfiguration(newJArray())
  else:
    debug "Client does not support workspace/configuration"
    ls.setWorkspaceConfiguration(newJArray()) #the defaults, and no one waits anymore

proc getCharacter*(
    ls: LanguageServer, uri: string, line: int, character: int
): Option[int] =
  let info = ls.openFiles.getOrDefault(uri)
  if info != nil and line in 0 ..< info.fingerTable.len:
    some info.fingerTable[line].utf16to8(character)
  else:
    none(int)

proc shutdownNimsuggest*(ls: LanguageServer) {.async: (raises: []).} =
  debug "stopping child nimsuggest processes"
  ls.isShutdownNimsuggest = true
  var shutdowns: seq[Future[void].Raising([])]
  if not ls.nimsuggestInit.isNil:
    shutdowns.add ls.nimsuggestInit.cancelAndWait()
  for creation in ls.nimsuggestCreations.values:
    shutdowns.add creation.cancelAndWait()
  for project in ls.projectFiles.values:
    shutdowns.add project.stopWait()
  await noCancel allFutures(shutdowns)

proc getProjectFile*(
    fileUri: string, ls: LanguageServer
): Future[string] {.async: (raises: [CancelledError, OSError, RegexError]).} =
  let
    rootPath =
      case ls.serverMode
      of mcp:
        ls.mcpInitializeParams.getRootPath()
      of lsp:
        ls.lspInitializeParams.getRootPath()
    pathRelativeToRoot = fileUri.tryRelativeTo(rootPath)
    mappings = ls.getWorkspaceConfiguration().projectMapping.get(@[])

  for mapping in mappings:
    var m: RegexMatch2
    if pathRelativeToRoot.isSome and
        find(pathRelativeToRoot.get(), re2(mapping.fileRegex), m):
      ls.showMessage(
        fmt"RegEx matched `{mapping.fileRegex}` for file `{fileUri}`", MessageType.Info
      )
      result = rootPath / mapping.projectFile
      if fileExists(result):
        trace "getProjectFile?",
          project = result, uri = fileUri, matchedRegex = mapping.fileRegex
        return result
    else:
      trace "getProjectFile does not match",
        uri = fileUri, matchedRegex = mapping.fileRegex

  #If we reached the maximum instances of nimsuggest, we just return the first project
  if not ls.canSpawnNimsuggest():
    return ls.reuseLiveNimsuggestProject()

  result = await ls.getProjectFileAutoGuess(fileUri)
  let project = ls.projectFiles.getOrDefault(result)
  if project != nil:
    let ns = project.ns
    let isKnown = await ns.isKnown(fileUri)
    if ns.canHandleUnknown and not isKnown:
      debug "File is not known by nimsuggest", uri = fileUri, projectFile = result
      result = fileUri

  if result == "":
    result = fileUri

  debug "getProjectFile ", project = result, fileUri = fileUri

proc checkFile*(
    ls: LanguageServer, file: NlsFileInfo
): Future[void] {.
    async: (
      raises: [
        CancelledError, AsyncProcessError, AsyncStreamError, OSError, IOError,
        RegexError, NimsuggestError,
      ]
    )
.} =
  let uri = file.textDocument.uri
  let conf = await ls.getAndWaitForWorkspaceConfiguration()
  let useNimCheck = conf.useNimCheck.get(USE_NIM_CHECK_BY_DEFAULT)
  let nimPath = await ls.getNimPath(conf)
  let token = ls.createProgressToken()
  ls.workDoneProgressCreate(token)
  ls.progress(token, "begin", fmt "Checking {uri.uriToPath}")
  defer:
    ls.progress(token, "end")

  let path = uriToPath(uri)

  if useNimCheck and nimPath.isSome:
    let checkResults = await nimCheck(uriToPath(uri), nimPath.get)
    ls.sendDiagnostics(checkResults, path)
    return

  let closed = uri notin ls.openFiles
  let ns =
    if closed:
      let project = ls.projectFiles.getOrDefault(file.nimsuggestProject)
      if project != nil:
        some project.ns
      else:
        none(Nimsuggest)
    else:
      await ls.tryGetNimsuggest(uri)
  let dirtyFile =
    if closed:
      path
    else:
      ls.uriToStash(uri)
  if ns.isSome:
    let diagnostics = await ns.get().chkFile(path, dirtyFile)
    ls.sendDiagnostics(diagnostics, path)

proc removeCompletedPendingRequests(
    ls: LanguageServer, maxTimeAfterRequestWasCompleted = initDuration(seconds = 10)
) =
  var toRemove = newSeq[uint]()
  for id, pr in ls.pendingRequests:
    if pr.state != prsOnGoing:
      let passedTime = now() - pr.endTime
      if passedTime > maxTimeAfterRequestWasCompleted:
        toRemove.add id

  for id in toRemove:
    ls.pendingRequests.del id

proc removeIdleNimsuggests*(
    ls: LanguageServer
) {.async: (raises: [CancelledError, OSError]).} =
  if ls.projectFiles.len == 0:
    return
  const DefaultNimsuggestIdleTimeout = 120000
  let timeout = ls.getWorkspaceConfiguration().nimsuggestIdleTimeout.get(
      DefaultNimsuggestIdleTimeout
    )
  let mappedProjects = ls.mappedProjectFiles()
  var toStop = newSeq[Project]()
  for project in ls.projectFiles.values:
    if project.file in ls.entryPoints or project.file in mappedProjects:
      #we only remove non entry point nimsuggests
      continue
    if project.lastCmdDate.isSome:
      let passedTime = now() - project.lastCmdDate.get()
      if passedTime.inMilliseconds > timeout:
        toStop.add(project)

  for project in toStop:
    debug "Removing idle nimsuggest", project = project.file
    project.errorCallback = none(ProjectCallback)
    project.stop()
    ls.projectFiles.del(project.file)

    ls.showMessage(
      fmt"Nimsuggest for {project.file} was stopped because it was idle for too long",
      MessageType.Info,
    )

proc tick*(ls: LanguageServer): Future[void] {.async: (raises: []).} =
  # debug "Ticking at ", now = now(), prs = ls.pendingRequests.len
  try:
    ls.removeCompletedPendingRequests()
    await ls.removeIdleNimsuggests()
    ls.sendStatusChanged
  except CancelledError, OSError:
    let ex = getCurrentException()
    error "Error in tick", msg = ex.msg
    writeStackTrace(ex)