#!/usr/bin/env nvim -l
---@diagnostic disable: no-unknown

-- Lints C files in the Neovim source tree.
-- Based on Google "cpplint", modified for Neovim.
--
-- Test coverage: `test/functional/script/clint_spec.lua`
--
-- This can get very confused by /* and // inside strings! We do a small hack,
-- which is to ignore //'s with "'s after them on the same line, but it is far
-- from perfect (in either direction).

local vim = vim

-- Error categories used for filtering
local ERROR_CATEGORIES = {
  'build/endif_comment',
  'build/header_guard',
  'build/include_defs',
  'build/defs_header',
  'build/printf_format',
  'build/storage_class',
  'build/init_macro',
  'readability/bool',
  'readability/multiline_comment',
  -- Dropped 'readability/multiline_string' detection because it is too buggy, and uncommon.
  -- 'readability/multiline_string',
  'readability/nul',
  'readability/utf8',
  'readability/increment',
  'runtime/arrays',
  'runtime/int',
  'runtime/memset',
  'runtime/printf',
  'runtime/printf_format',
  'runtime/threadsafe_fn',
  'runtime/deprecated',
  'whitespace/indent',
  'whitespace/operators',
  'whitespace/cast',
}

-- Default filters (empty by default)
local DEFAULT_FILTERS = {}

-- Assembly state constants
local NO_ASM = 0 -- Outside of inline assembly block
local INSIDE_ASM = 1 -- Inside inline assembly block
local END_ASM = 2 -- Last line of inline assembly block
local BLOCK_ASM = 3 -- The whole block is an inline assembly block

-- Regex compilation cache
local regexp_compile_cache = {}

-- Error suppression state
local error_suppressions = {}
local error_suppressions_2 = {}

-- Configuration
local valid_extensions = { c = true, h = true }

-- Precompiled regex patterns (only the ones still used)
local RE_SUPPRESSION = vim.regex([[\<NOLINT\>]])
local RE_COMMENTLINE = vim.regex([[^\s*//]])
local RE_PATTERN_INCLUDE = vim.regex([[^\s*#\s*include\s*\([<"]\)\([^>"]*\)[>"].*$]])

-- Assembly block matching (using Lua pattern instead of vim.regex for simplicity)
local function match_asm(line)
  return line:find('^%s*asm%s*[{(]')
    or line:find('^%s*_asm%s*[{(]')
    or line:find('^%s*__asm%s*[{(]')
    or line:find('^%s*__asm__%s*[{(]')
end

-- Threading function replacements
local threading_list = {
  { 'asctime(', 'os_asctime_r(' },
  { 'ctime(', 'os_ctime_r(' },
  { 'getgrgid(', 'os_getgrgid_r(' },
  { 'getgrnam(', 'os_getgrnam_r(' },
  { 'getlogin(', 'os_getlogin_r(' },
  { 'getpwnam(', 'os_getpwnam_r(' },
  { 'getpwuid(', 'os_getpwuid_r(' },
  { 'gmtime(', 'os_gmtime_r(' },
  { 'localtime(', 'os_localtime_r(' },
  { 'strtok(', 'os_strtok_r(' },
  { 'ttyname(', 'os_ttyname_r(' },
  { 'asctime_r(', 'os_asctime_r(' },
  { 'ctime_r(', 'os_ctime_r(' },
  { 'getgrgid_r(', 'os_getgrgid_r(' },
  { 'getgrnam_r(', 'os_getgrnam_r(' },
  { 'getlogin_r(', 'os_getlogin_r(' },
  { 'getpwnam_r(', 'os_getpwnam_r(' },
  { 'getpwuid_r(', 'os_getpwuid_r(' },
  { 'gmtime_r(', 'os_gmtime_r(' },
  { 'localtime_r(', 'os_localtime_r(' },
  { 'strtok_r(', 'os_strtok_r(' },
  { 'ttyname_r(', 'os_ttyname_r(' },
}

-- Memory function replacements
local memory_functions = {
  { 'malloc(', 'xmalloc(' },
  { 'calloc(', 'xcalloc(' },
  { 'realloc(', 'xrealloc(' },
  { 'strdup(', 'xstrdup(' },
  { 'free(', 'xfree(' },
}
local memory_ignore_pattern = vim.regex([[src/nvim/memory.c$]])

-- OS function replacements
local os_functions = {
  { 'setenv(', 'os_setenv(' },
  { 'getenv(', 'os_getenv(' },
  { '_wputenv(', 'os_setenv(' },
  { '_putenv_s(', 'os_setenv(' },
  { 'putenv(', 'os_setenv(' },
  { 'unsetenv(', 'os_unsetenv(' },
}

-- CppLintState class equivalent
local CppLintState = {}
CppLintState.__index = CppLintState

function CppLintState.new()
  local self = setmetatable({}, CppLintState)
  self.verbose_level = 1
  self.error_count = 0
  self.filters = vim.deepcopy(DEFAULT_FILTERS)
  self.counting = 'total'
  self.errors_by_category = {}
  self.stdin_filename = ''
  self.output_format = 'emacs'
  self.record_errors_file = nil
  self.suppressed_errors = vim.defaulttable(function()
    return vim.defaulttable(function()
      return {}
    end)
  end)
  return self
end

function CppLintState:set_output_format(output_format)
  self.output_format = output_format
end

function CppLintState:set_verbose_level(level)
  local last_verbose_level = self.verbose_level
  self.verbose_level = level
  return last_verbose_level
end

function CppLintState:set_counting_style(counting_style)
  self.counting = counting_style
end

function CppLintState:set_filters(filters)
  self.filters = vim.deepcopy(DEFAULT_FILTERS)
  for filt in vim.gsplit(filters, ',', { trimempty = true }) do
    local clean_filt = vim.trim(filt)
    if clean_filt ~= '' then
      table.insert(self.filters, clean_filt)
    end
  end

  for _, filt in ipairs(self.filters) do
    if not (filt:sub(1, 1) == '+' or filt:sub(1, 1) == '-') then
      error('Every filter in --filters must start with + or - (' .. filt .. ' does not)')
    end
  end
end

function CppLintState:reset_error_counts()
  self.error_count = 0
  self.errors_by_category = {}
end

function CppLintState:increment_error_count(category)
  self.error_count = self.error_count + 1
  if self.counting == 'toplevel' or self.counting == 'detailed' then
    local cat = category
    if self.counting ~= 'detailed' then
      cat = category:match('([^/]+)') or category
    end
    if not self.errors_by_category[cat] then
      self.errors_by_category[cat] = 0
    end
    self.errors_by_category[cat] = self.errors_by_category[cat] + 1
  end
end

function CppLintState:print_error_counts()
  for category, count in pairs(self.errors_by_category) do
    io.write(string.format("Category '%s' errors found: %d\n", category, count))
  end
  if self.error_count > 0 then
    io.write(string.format('Total errors found: %d\n', self.error_count))
  end
end

function CppLintState:suppress_errors_from(fname)
  if not fname then
    return
  end

  local ok, content = pcall(vim.fn.readfile, fname)
  if not ok then
    return
  end

  for _, line in ipairs(content) do
    local ok2, data = pcall(vim.json.decode, line)
    if ok2 then
      local fname2, lines, category = data[1], data[2], data[3]
      local lines_tuple = vim.islist(lines) and lines or { lines }
      self.suppressed_errors[fname2][vim.inspect(lines_tuple)][category] = true
    end
  end
end

function CppLintState:record_errors_to(fname)
  if not fname then
    return
  end
  self.record_errors_file = io.open(fname, 'w')
end

-- Global state instance
local cpplint_state = CppLintState.new()

-- Utility functions
local function match(pattern, s)
  if not regexp_compile_cache[pattern] then
    regexp_compile_cache[pattern] = vim.regex(pattern)
  end
  local s_idx, e_idx = regexp_compile_cache[pattern]:match_str(s)
  if s_idx then
    local match_obj = {}
    match_obj.start = s_idx
    match_obj.finish = e_idx
    function match_obj.group(n)
      if n == 0 then
        return s:sub(s_idx + 1, e_idx)
      else
        -- For subgroups, we need to use a different approach
        -- This is a simplified version - full regex groups would need more complex handling
        return s:sub(s_idx + 1, e_idx)
      end
    end
    return match_obj
  end
  return nil
end

-- NOLINT suppression functions
local function parse_nolint_suppressions(raw_line, linenum)
  local s_idx, e_idx = RE_SUPPRESSION:match_str(raw_line)
  if not s_idx then
    return
  end

  -- Extract what comes after NOLINT, looking for optional (category)
  local after_nolint = raw_line:sub(e_idx + 1)
  local category = after_nolint:match('^%s*(%([^)]*%))')

  if not category or category == '(*)' then
    -- Suppress all errors on this line
    if not error_suppressions[vim.NIL] then
      error_suppressions[vim.NIL] = {}
    end
    table.insert(error_suppressions[vim.NIL], linenum)
  else
    -- Extract category name from parentheses
    local cat_name = category:match('^%((.-)%)$')
    if cat_name then
      for _, cat in ipairs(ERROR_CATEGORIES) do
        if cat == cat_name then
          if not error_suppressions[cat_name] then
            error_suppressions[cat_name] = {}
          end
          table.insert(error_suppressions[cat_name], linenum)
          break
        end
      end
    end
  end
end

local function reset_nolint_suppressions()
  error_suppressions = {}
end

local function reset_known_error_suppressions()
  error_suppressions_2 = {}
end

local function is_error_suppressed_by_nolint(category, linenum)
  local cat_suppressed = error_suppressions[category] or {}
  local all_suppressed = error_suppressions[vim.NIL] or {}

  for _, line in ipairs(cat_suppressed) do
    if line == linenum then
      return true
    end
  end
  for _, line in ipairs(all_suppressed) do
    if line == linenum then
      return true
    end
  end
  return false
end

local function is_error_in_suppressed_errors_list(category, linenum)
  local key = category .. ':' .. linenum
  return error_suppressions_2[key] == true
end

-- FileInfo class equivalent
local FileInfo = {}
FileInfo.__index = FileInfo

function FileInfo.new(filename)
  local self = setmetatable({}, FileInfo)
  self._filename = filename
  return self
end

function FileInfo:full_name()
  local abspath = vim.fn.fnamemodify(self._filename, ':p')
  return abspath:gsub('\\', '/')
end

function FileInfo:relative_path()
  local fullname = self:full_name()

  if vim.fn.filereadable(fullname) == 1 then
    -- Find git repository root using vim.fs.root
    local git_root = vim.fs.root(fullname, '.git')
    if git_root then
      local root_dir = vim.fs.joinpath(git_root, 'src', 'nvim')
      local relpath = vim.fs.relpath(root_dir, fullname)
      if relpath then
        return relpath
      end
    end
  end

  return fullname
end

-- Error reporting
local function should_print_error(category, confidence, linenum)
  if is_error_suppressed_by_nolint(category, linenum) then
    return false
  end
  if is_error_in_suppressed_errors_list(category, linenum) then
    return false
  end
  if confidence < cpplint_state.verbose_level then
    return false
  end

  local is_filtered = false
  for _, one_filter in ipairs(cpplint_state.filters) do
    if one_filter:sub(1, 1) == '-' then
      if category:find(one_filter:sub(2), 1, true) == 1 then
        is_filtered = true
      end
    elseif one_filter:sub(1, 1) == '+' then
      if category:find(one_filter:sub(2), 1, true) == 1 then
        is_filtered = false
      end
    end
  end

  return not is_filtered
end

local function error_func(filename, linenum, category, confidence, message)
  if should_print_error(category, confidence, linenum) then
    cpplint_state:increment_error_count(category)

    if cpplint_state.output_format == 'vs7' then
      io.write(
        string.format('%s(%s):  %s  [%s] [%d]\n', filename, linenum, message, category, confidence)
      )
    elseif cpplint_state.output_format == 'eclipse' then
      io.write(
        string.format(
          '%s:%s: warning: %s  [%s] [%d]\n',
          filename,
          linenum,
          message,
          category,
          confidence
        )
      )
    elseif cpplint_state.output_format == 'gh_action' then
      io.write(
        string.format(
          '::error file=%s,line=%s::%s  [%s] [%d]\n',
          filename,
          linenum,
          message,
          category,
          confidence
        )
      )
    else
      io.write(
        string.format('%s:%s:  %s  [%s] [%d]\n', filename, linenum, message, category, confidence)
      )
    end
  end
end

-- String processing functions
local function is_cpp_string(line)
  line = line:gsub('\\\\', 'XX')
  local quote_count = select(2, line:gsub('"', ''))
  local escaped_quote_count = select(2, line:gsub('\\"', ''))
  local combined_quote_count = select(2, line:gsub("'\"'", ''))
  return ((quote_count - escaped_quote_count - combined_quote_count) % 2) == 1
end

local function cleanse_comments(line)
  local commentpos = line:find('//')
  if commentpos and not is_cpp_string(line:sub(1, commentpos - 1)) then
    line = line:sub(1, commentpos - 1):gsub('%s+$', '')
  end
  -- Remove /* */ comments
  line = line:gsub('/%*.-%*/', '')
  return line
end

-- CleansedLines class equivalent
local CleansedLines = {}
CleansedLines.__index = CleansedLines

function CleansedLines.new(lines, init_lines)
  local self = setmetatable({}, CleansedLines)
  self.elided = {}
  self.lines = {}
  self.raw_lines = lines
  self._num_lines = #lines
  self.init_lines = init_lines
  self.lines_without_raw_strings = lines
  self.elided_with_space_strings = {}

  for linenum = 1, #self.lines_without_raw_strings do
    local line = self.lines_without_raw_strings[linenum]
    table.insert(self.lines, cleanse_comments(line))

    local elided = self:_collapse_strings(line)
    table.insert(self.elided, cleanse_comments(elided))

    local elided_spaces = self:_collapse_strings(line, true)
    table.insert(self.elided_with_space_strings, cleanse_comments(elided_spaces))
  end

  return self
end

function CleansedLines:num_lines()
  return self._num_lines
end

function CleansedLines:_collapse_strings(elided, keep_spaces)
  if not RE_PATTERN_INCLUDE:match_str(elided) then
    -- Remove escaped characters
    elided = elided:gsub('\\[abfnrtv?"\\\'\\]', keep_spaces and ' ' or '')
    elided = elided:gsub('\\%d+', keep_spaces and ' ' or '')
    elided = elided:gsub('\\x[0-9a-fA-F]+', keep_spaces and ' ' or '')

    if keep_spaces then
      elided = elided:gsub("'([^'])'", function(c)
        return "'" .. string.rep(' ', #c) .. "'"
      end)
      elided = elided:gsub('"([^"]*)"', function(c)
        return '"' .. string.rep(' ', #c) .. '"'
      end)
    else
      elided = elided:gsub("'([^'])'", "''")
      elided = elided:gsub('"([^"]*)"', '""')
    end
  end
  return elided
end

-- Helper functions for argument parsing
local function print_usage(message)
  local usage = [[
Syntax: clint.lua [--verbose=#] [--output=vs7] [--filter=-x,+y,...]
                 [--counting=total|toplevel|detailed] [--root=subdir]
                 [--linelength=digits] [--record-errors=file]
                 [--suppress-errors=file] [--stdin-filename=filename]
        <file> [file] ...

  The style guidelines this tries to follow are those in
    https://neovim.io/doc/user/dev_style.html#dev-style

  Note: This is Google's https://github.com/cpplint/cpplint modified for use
  with the Neovim project.

  Every problem is given a confidence score from 1-5, with 5 meaning we are
  certain of the problem, and 1 meaning it could be a legitimate construct.
  This will miss some errors, and is not a substitute for a code review.

  To suppress false-positive errors of a certain category, add a
  'NOLINT(category)' comment to the line.  NOLINT or NOLINT(*)
  suppresses errors of all categories on that line.

  The files passed in will be linted; at least one file must be provided.
  Default linted extensions are .cc, .cpp, .cu, .cuh and .h.  Change the
  extensions with the --extensions flag.

  Flags:

    output=vs7
      By default, the output is formatted to ease emacs parsing.  Visual Studio
      compatible output (vs7) may also be used.  Other formats are unsupported.

    verbose=#
      Specify a number 0-5 to restrict errors to certain verbosity levels.

    filter=-x,+y,...
      Specify a comma-separated list of category-filters to apply: only
      error messages whose category names pass the filters will be printed.
      (Category names are printed with the message and look like
      "[whitespace/indent]".)  Filters are evaluated left to right.
      "-FOO" and "FOO" means "do not print categories that start with FOO".
      "+FOO" means "do print categories that start with FOO".

      Examples: --filter=-whitespace,+whitespace/braces
                --filter=whitespace,runtime/printf,+runtime/printf_format
                --filter=-,+build/include_what_you_use

      To see a list of all the categories used in cpplint, pass no arg:
         --filter=

    counting=total|toplevel|detailed
      The total number of errors found is always printed. If
      'toplevel' is provided, then the count of errors in each of
      the top-level categories like 'build' and 'whitespace' will
      also be printed. If 'detailed' is provided, then a count
      is provided for each category.

    root=subdir
      The root directory used for deriving header guard CPP variable.
      By default, the header guard CPP variable is calculated as the relative
      path to the directory that contains .git, .hg, or .svn.  When this flag
      is specified, the relative path is calculated from the specified
      directory. If the specified directory does not exist, this flag is
      ignored.

      Examples:
        Assuing that src/.git exists, the header guard CPP variables for
        src/chrome/browser/ui/browser.h are:

        No flag => CHROME_BROWSER_UI_BROWSER_H_
        --root=chrome => BROWSER_UI_BROWSER_H_
        --root=chrome/browser => UI_BROWSER_H_

    linelength=digits
      This is the allowed line length for the project. The default value is
      80 characters.

      Examples:
        --linelength=120

    extensions=extension,extension,...
      The allowed file extensions that cpplint will check

      Examples:
        --extensions=hpp,cpp

    record-errors=file
      Record errors to the given location. This file may later be used for error
      suppression using suppress-errors flag.

    suppress-errors=file
      Errors listed in the given file will not be reported.

    stdin-filename=filename
      Use specified filename when reading from stdin (file "-").
]]

  if message then
    io.stderr:write(usage .. '\nFATAL ERROR: ' .. message .. '\n')
    os.exit(1)
  else
    io.write(usage)
    os.exit(0)
  end
end

local function print_categories()
  for _, cat in ipairs(ERROR_CATEGORIES) do
    io.write('  ' .. cat .. '\n')
  end
  os.exit(0)
end

-- Argument parsing
local function parse_arguments(args)
  local filenames = {}
  local opts = {
    output_format = 'emacs',
    verbose_level = 1,
    filters = '',
    counting_style = 'total',
    extensions = { 'c', 'h' },
    record_errors_file = nil,
    suppress_errors_file = nil,
    stdin_filename = '',
  }

  local i = 1
  while i <= #args do
    local arg = args[i]

    if arg == '--help' then
      print_usage()
    elseif arg:sub(1, 9) == '--output=' then
      local format = arg:sub(10)
      if
        format ~= 'emacs'
        and format ~= 'vs7'
        and format ~= 'eclipse'
        and format ~= 'gh_action'
      then
        print_usage('The only allowed output formats are emacs, vs7 and eclipse.')
      end
      opts.output_format = format
    elseif arg:sub(1, 10) == '--verbose=' then
      opts.verbose_level = tonumber(arg:sub(11))
    elseif arg:sub(1, 9) == '--filter=' then
      opts.filters = arg:sub(10)
      if opts.filters == '' then
        print_categories()
      end
    elseif arg:sub(1, 12) == '--counting=' then
      local style = arg:sub(13)
      if style ~= 'total' and style ~= 'toplevel' and style ~= 'detailed' then
        print_usage('Valid counting options are total, toplevel, and detailed')
      end
      opts.counting_style = style
    elseif arg:sub(1, 13) == '--extensions=' then
      local exts = arg:sub(14)
      opts.extensions = {}
      for ext in vim.gsplit(exts, ',', { trimempty = true }) do
        table.insert(opts.extensions, vim.trim(ext))
      end
    elseif arg:sub(1, 16) == '--record-errors=' then
      opts.record_errors_file = arg:sub(17)
    elseif arg:sub(1, 18) == '--suppress-errors=' then
      opts.suppress_errors_file = arg:sub(19)
    elseif arg:sub(1, 17) == '--stdin-filename=' then
      opts.stdin_filename = arg:sub(18)
    elseif arg:sub(1, 2) == '--' then
      print_usage('Unknown option: ' .. arg)
    else
      table.insert(filenames, arg)
    end

    i = i + 1
  end

  if #filenames == 0 then
    print_usage('No files were specified.')
  end

  return filenames, opts
end

-- Lint checking functions

local function find_next_multiline_comment_start(lines, lineix)
  while lineix <= #lines do
    if lines[lineix]:find('^%s*/%*') then
      if not lines[lineix]:find('%*/', 1, true) then
        -- Check if this line ends with backslash (line continuation)
        -- If so, don't treat it as a multiline comment start
        local line = lines[lineix]
        if not line:find('\\%s*$') then
          return lineix
        end
      end
    end
    lineix = lineix + 1
  end
  return #lines + 1
end

local function find_next_multiline_comment_end(lines, lineix)
  while lineix <= #lines do
    if lines[lineix]:find('%*/%s*$') then
      return lineix
    end
    lineix = lineix + 1
  end
  return #lines + 1
end

local function remove_multiline_comments_from_range(lines, begin, finish)
  for i = begin, finish do
    lines[i] = '// dummy'
  end
end

local function remove_multiline_comments(filename, lines, error)
  local lineix = 1
  while lineix <= #lines do
    local lineix_begin = find_next_multiline_comment_start(lines, lineix)
    if lineix_begin > #lines then
      return
    end
    local lineix_end = find_next_multiline_comment_end(lines, lineix_begin)
    if lineix_end > #lines then
      error(
        filename,
        lineix_begin,
        'readability/multiline_comment',
        5,
        'Could not find end of multi-line comment'
      )
      return
    end
    remove_multiline_comments_from_range(lines, lineix_begin, lineix_end)
    lineix = lineix_end + 1
  end
end

local function check_for_header_guard(filename, lines, error)
  if filename:match('%.c%.h$') or FileInfo.new(filename):relative_path() == 'func_attr.h' then
    return
  end

  local found_pragma = false
  for _, line in ipairs(lines) do
    if line:find('#pragma%s+once') then
      found_pragma = true
      break
    end
  end

  if not found_pragma then
    error(filename, 1, 'build/header_guard', 5, 'No "#pragma once" found in header')
  end
end

local function check_includes(filename, lines, error)
  if
    filename:match('%.c%.h$')
    or filename:match('%.in%.h$')
    or FileInfo.new(filename):relative_path() == 'func_attr.h'
    or FileInfo.new(filename):relative_path() == 'os/pty_proc.h'
  then
    return
  end

  local check_includes_ignore = {
    'src/nvim/api/private/validate.h',
    'src/nvim/assert_defs.h',
    'src/nvim/channel.h',
    'src/nvim/charset.h',
    'src/nvim/eval/typval.h',
    'src/nvim/event/multiqueue.h',
    'src/nvim/garray.h',
    'src/nvim/globals.h',
    'src/nvim/highlight.h',
    'src/nvim/lua/executor.h',
    'src/nvim/main.h',
    'src/nvim/mark.h',
    'src/nvim/msgpack_rpc/channel_defs.h',
    'src/nvim/msgpack_rpc/unpacker.h',
    'src/nvim/option.h',
    'src/nvim/os/pty_conpty_win.h',
    'src/nvim/os/pty_proc_win.h',
  }

  local skip_headers = {
    'auto/config.h',
    'klib/klist.h',
    'klib/kvec.h',
    'mpack/mpack_core.h',
    'mpack/object.h',
    'nvim/func_attr.h',
    'termkey/termkey.h',
    'vterm/vterm.h',
    'xdiff/xdiff.h',
  }

  for _, ignore in ipairs(check_includes_ignore) do
    if filename:match(ignore .. '$') then
      return
    end
  end

  for i, line in ipairs(lines) do
    local matched = match('#\\s*include\\s*"([^"]*)"', line)
    if matched then
      local name = line:match('#\\s*include\\s*"([^"]*)"')
      local should_skip = false
      for _, skip in ipairs(skip_headers) do
        if name == skip then
          should_skip = true
          break
        end
      end

      if
        not should_skip
        and not name:match('%.h%.generated%.h$')
        and not name:match('/defs%.h$')
        and not name:match('_defs%.h$')
        and not name:match('%.h%.inline%.generated%.h$')
        and not name:match('_defs%.generated%.h$')
        and not name:match('_enum%.generated%.h$')
      then
        error(
          filename,
          i - 1,
          'build/include_defs',
          5,
          'Headers should not include non-"_defs" headers'
        )
      end
    end
  end
end

local function check_non_symbols(filename, lines, error)
  for i, line in ipairs(lines) do
    if line:match('^EXTERN ') or line:match('^extern ') then
      error(
        filename,
        i - 1,
        'build/defs_header',
        5,
        '"_defs" headers should not contain extern variables'
      )
    end
  end
end

local function check_for_bad_characters(filename, lines, error)
  for linenum, line in ipairs(lines) do
    if line:find('\239\187\191') then -- UTF-8 BOM
      error(
        filename,
        linenum - 1,
        'readability/utf8',
        5,
        'Line contains invalid UTF-8 (or Unicode replacement character).'
      )
    end
    if line:find('\0') then
      error(filename, linenum - 1, 'readability/nul', 5, 'Line contains NUL byte.')
    end
  end
end

local function check_for_multiline_comments_and_strings(filename, clean_lines, linenum, error)
  -- Use elided line (with strings collapsed) to avoid false positives from /* */ in strings
  local line = clean_lines.elided[linenum + 1]
  if not line then
    return
  end

  -- Remove all \\ (escaped backslashes) from the line. They are OK, and the
  -- second (escaped) slash may trigger later \" detection erroneously.
  line = line:gsub('\\\\', '')

  local comment_count = select(2, line:gsub('/%*', ''))
  local comment_end_count = select(2, line:gsub('%*/', ''))
  -- Only warn if there are actually more opening than closing comments
  -- (accounting for the possibility that this is a multi-line comment that continues)
  if comment_count > comment_end_count and comment_count > 0 then
    error(
      filename,
      linenum,
      'readability/multiline_comment',
      5,
      'Complex multi-line /*...*/-style comment found. '
        .. 'Lint may give bogus warnings.  '
        .. 'Consider replacing these with //-style comments, '
        .. 'with #if 0...#endif, '
        .. 'or with more clearly structured multi-line comments.'
    )
  end

  -- Dropped 'readability/multiline_string' detection because it produces too many false positives
  -- with escaped quotes in C strings and character literals.
end

local function check_for_old_style_comments(filename, line, linenum, error)
  if line:find('/%*') and line:sub(-1) ~= '\\' and not RE_COMMENTLINE:match_str(line) then
    error(
      filename,
      linenum,
      'readability/old_style_comment',
      5,
      '/*-style comment found, it should be replaced with //-style.  '
        .. '/*-style comments are only allowed inside macros.  '
        .. 'Note that you should not use /*-style comments to document '
        .. 'macros itself, use doxygen-style comments for this.'
    )
  end
end

local function check_posix_threading(filename, clean_lines, linenum, error)
  local line = clean_lines.elided[linenum + 1]

  for _, pair in ipairs(threading_list) do
    local single_thread_function, multithread_safe_function = pair[1], pair[2]
    local start_pos = line:find(single_thread_function, 1, true)

    if start_pos then
      local prev_char = start_pos > 1 and line:sub(start_pos - 1, start_pos - 1) or ''
      if
        start_pos == 1
        or (
          not prev_char:match('%w')
          and prev_char ~= '_'
          and prev_char ~= '.'
          and prev_char ~= '>'
        )
      then
        error(
          filename,
          linenum,
          'runtime/threadsafe_fn',
          2,
          'Use '
            .. multithread_safe_function
            .. '...) instead of '
            .. single_thread_function
            .. '...). If it is missing, consider implementing it;'
            .. ' see os_localtime_r for an example.'
        )
      end
    end
  end
end

local function check_memory_functions(filename, clean_lines, linenum, error)
  if memory_ignore_pattern:match_str(filename) then
    return
  end

  local line = clean_lines.elided[linenum + 1]

  for _, pair in ipairs(memory_functions) do
    local func, suggested_func = pair[1], pair[2]
    local start_pos = line:find(func, 1, true)

    if start_pos then
      local prev_char = start_pos > 1 and line:sub(start_pos - 1, start_pos - 1) or ''
      if
        start_pos == 1
        or (
          not prev_char:match('%w')
          and prev_char ~= '_'
          and prev_char ~= '.'
          and prev_char ~= '>'
        )
      then
        error(
          filename,
          linenum,
          'runtime/memory_fn',
          2,
          'Use ' .. suggested_func .. '...) instead of ' .. func .. '...).'
        )
      end
    end
  end
end

local function check_os_functions(filename, clean_lines, linenum, error)
  local line = clean_lines.elided[linenum + 1]

  for _, pair in ipairs(os_functions) do
    local func, suggested_func = pair[1], pair[2]
    local start_pos = line:find(func, 1, true)

    if start_pos then
      local prev_char = start_pos > 1 and line:sub(start_pos - 1, start_pos - 1) or ''
      if
        start_pos == 1
        or (
          not prev_char:match('%w')
          and prev_char ~= '_'
          and prev_char ~= '.'
          and prev_char ~= '>'
        )
      then
        error(
          filename,
          linenum,
          'runtime/os_fn',
          2,
          'Use ' .. suggested_func .. '...) instead of ' .. func .. '...).'
        )
      end
    end
  end
end

local function check_language(filename, clean_lines, linenum, error)
  local line = clean_lines.elided[linenum + 1]
  if not line or line == '' then
    return
  end

  -- Check for verboten C basic types
  local short_regex = vim.regex([[\<short\>]])
  local long_long_regex = vim.regex([[\<long\> \+\<long\>]])

  if short_regex:match_str(line) then
    error(
      filename,
      linenum,
      'runtime/int',
      4,
      'Use int16_t/int64_t/etc, rather than the C type short'
    )
  elseif long_long_regex:match_str(line) then
    error(
      filename,
      linenum,
      'runtime/int',
      4,
      'Use int16_t/int64_t/etc, rather than the C type long long'
    )
  end

  -- Check for snprintf with non-zero literal size
  local snprintf_match = line:match('snprintf%s*%([^,]*,%s*([0-9]+)%s*,')
  if snprintf_match and snprintf_match ~= '0' then
    error(
      filename,
      linenum,
      'runtime/printf',
      3,
      'If you can, use sizeof(...) instead of ' .. snprintf_match .. ' as the 2nd arg to snprintf.'
    )
  end

  -- Check for sprintf (use vim.regex for proper word boundaries)
  local sprintf_regex = vim.regex([[\<sprintf\>]])
  if sprintf_regex:match_str(line) then
    error(filename, linenum, 'runtime/printf', 5, 'Use snprintf instead of sprintf.')
  end

  -- Check for strncpy (use vim.regex for proper word boundaries)
  local strncpy_regex = vim.regex([[\<strncpy\>]])
  local strncpy_upper_regex = vim.regex([[\<STRNCPY\>]])
  if strncpy_regex:match_str(line) then
    error(
      filename,
      linenum,
      'runtime/printf',
      4,
      'Use xstrlcpy, xmemcpyz or snprintf instead of strncpy (unless this is from Vim)'
    )
  elseif strncpy_upper_regex:match_str(line) then
    error(
      filename,
      linenum,
      'runtime/printf',
      4,
      'Use xstrlcpy, xmemcpyz or snprintf instead of STRNCPY (unless this is from Vim)'
    )
  end

  -- Check for strcpy (use vim.regex for proper word boundaries)
  local strcpy_regex = vim.regex([[\<strcpy\>]])
  if strcpy_regex:match_str(line) then
    error(
      filename,
      linenum,
      'runtime/printf',
      4,
      'Use xstrlcpy, xmemcpyz or snprintf instead of strcpy'
    )
  end

  -- Check for memset with wrong argument order: memset(buf, sizeof(buf), 0)
  -- Pattern: memset(arg1, arg2, 0) where arg2 is NOT a valid fill value
  local memset_start = line:find('memset%s*%([^)]*,%s*[^,]*,%s*0%s*%)')
  if memset_start then
    -- Extract the full memset call
    local memset_part = line:sub(memset_start)
    local first_comma = memset_part:find(',')
    if first_comma then
      local after_first = memset_part:sub(first_comma + 1)
      local second_comma = after_first:find(',')
      if second_comma then
        local second_arg = vim.trim(after_first:sub(1, second_comma - 1))
        local first_arg = vim.trim(memset_part:match('memset%s*%(%s*([^,]*)%s*,'))

        -- Check if second_arg is NOT a simple literal value
        if
          second_arg ~= ''
          and second_arg ~= "''"
          and not second_arg:match('^%-?%d+$')
          and not second_arg:match('^0x[0-9a-fA-F]+$')
        then
          error(
            filename,
            linenum,
            'runtime/memset',
            4,
            'Did you mean "memset(' .. first_arg .. ', 0, ' .. second_arg .. ')"?'
          )
        end
      end
    end
  end

  -- Detect variable-length arrays
  -- Pattern: type varname[size]; where type is an identifier and varname starts with lowercase
  local var_type = line:match('%s*(%w+)%s+')
  if var_type and var_type ~= 'return' and var_type ~= 'delete' then
    -- Look for array declaration pattern
    local array_size = line:match('%w+%s+[a-z]%w*%s*%[([^%]]+)%]')
    if array_size and not array_size:find('%]') then -- Ensure no nested brackets (multidimensional arrays)
      -- Check if size is a compile-time constant
      local is_const = true

      -- Split on common operators (space, +, -, *, /, <<, >>)
      local tokens = vim.split(array_size, '[%s%+%-%*%/%>%<]+')

      for _, tok in ipairs(tokens) do
        tok = vim.trim(tok)
        if tok ~= '' then
          -- Check for sizeof(...) and arraysize(...) or ARRAY_SIZE(...) patterns (before stripping parens)
          local is_valid = tok:find('sizeof%(.+%)')
            or tok:find('arraysize%(%w+%)')
            or tok:find('ARRAY_SIZE%(.+%)')

          if not is_valid then
            -- Strip leading and trailing parentheses for other checks
            tok = tok:gsub('^%(*', ''):gsub('%)*$', '')
            tok = vim.trim(tok)

            if tok ~= '' then
              -- Allow: numeric literals, hex, k-prefixed constants, SCREAMING_CASE, sizeof, arraysize
              is_valid = (
                tok:match('^%d+$') -- decimal number
                or tok:match('^0x[0-9a-fA-F]+$') -- hex number
                or tok:match('^k[A-Z0-9]') -- k-prefixed constant
                or tok:match('^[A-Z][A-Z0-9_]*$') -- SCREAMING_CASE
                or tok:match('^sizeof') -- sizeof(...)
                or tok:match('^arraysize')
              ) -- arraysize(...)
            end
          end

          if not is_valid then
            is_const = false
            break
          end
        end
      end

      if not is_const then
        error(
          filename,
          linenum,
          'runtime/arrays',
          1,
          "Do not use variable-length arrays.  Use an appropriately named ('k' followed by CamelCase) compile-time constant for the size."
        )
      end
    end
  end

  -- Check for TRUE/FALSE (use vim.regex for proper word boundaries)
  local true_regex = vim.regex([[\<TRUE\>]])
  local false_regex = vim.regex([[\<FALSE\>]])
  local maybe_regex = vim.regex([[\<MAYBE\>]])

  if true_regex:match_str(line) then
    error(filename, linenum, 'readability/bool', 4, 'Use true instead of TRUE.')
  end

  if false_regex:match_str(line) then
    error(filename, linenum, 'readability/bool', 4, 'Use false instead of FALSE.')
  end

  -- Check for MAYBE
  if maybe_regex:match_str(line) then
    error(filename, linenum, 'readability/bool', 4, 'Use kNone from TriState instead of MAYBE.')
  end

  -- Detect preincrement/predecrement at start of line
  if line:match('^%s*%+%+') or line:match('^%s*%-%-') then
    error(
      filename,
      linenum,
      'readability/increment',
      5,
      'Do not use preincrement in statements, use postincrement instead'
    )
  end

  -- Detect preincrement/predecrement in for(;; preincrement)
  -- Look for pattern like ";  ++var" or "; --var"
  local last_semi_pos = 0
  for i = 1, #line do
    if line:sub(i, i) == ';' then
      last_semi_pos = i
    end
  end

  if last_semi_pos > 0 then
    -- Check if there's a preincrement/predecrement after the last semicolon
    local after_semi = line:sub(last_semi_pos + 1)
    local op_pos = after_semi:find('%+%+')
    if not op_pos then
      op_pos = after_semi:find('%-%-')
    end
    if op_pos then
      -- Found preincrement/predecrement after last semicolon
      local expr_start = after_semi:sub(1, op_pos - 1):match('^%s*(.*)')
      if not expr_start or expr_start == '' then
        -- Nothing but whitespace before operator, check the expression
        local expr_text = after_semi:sub(op_pos)
        if not expr_text:find(';') and not expr_text:find(' = ') then
          error(
            filename,
            linenum,
            'readability/increment',
            4,
            'Do not use preincrement in statements, including for(;; action)'
          )
        end
      end
    end
  end
end

local function check_for_non_standard_constructs(filename, clean_lines, linenum, error)
  local line = clean_lines.lines[linenum + 1]

  -- Check for printf format issues with %q and %N$ in quoted strings
  -- Extract all quoted strings and check their format specifiers
  for str in line:gmatch('"([^"]*)"') do
    -- Check for %q format (deprecated)
    if str:find('%%%-?%+?%s?%d*q') then
      error(
        filename,
        linenum,
        'runtime/printf_format',
        3,
        '"%q" in format strings is deprecated.  Use "%" PRId64 instead.'
      )
    end

    -- Check for %N$ format (unconventional positional specifier)
    if str:find('%%%d+%$') then
      error(
        filename,
        linenum,
        'runtime/printf_format',
        2,
        '%N$ formats are unconventional.  Try rewriting to avoid them.'
      )
    end
  end

  -- Check for storage class order (type before storage class modifier)
  -- Match type keywords followed by storage class keywords
  local type_keywords = {
    'const',
    'volatile',
    'void',
    'char',
    'short',
    'int',
    'long',
    'float',
    'double',
    'signed',
    'unsigned',
  }
  local storage_keywords = { 'register', 'static', 'extern', 'typedef' }

  for _, type_kw in ipairs(type_keywords) do
    for _, storage_kw in ipairs(storage_keywords) do
      local pattern = '\\<' .. type_kw .. '\\>\\s\\+\\<' .. storage_kw .. '\\>'
      if vim.regex(pattern):match_str(line) then
        error(
          filename,
          linenum,
          'build/storage_class',
          5,
          'Storage class (static, extern, typedef, etc) should be first.'
        )
        return
      end
    end
  end

  -- Check for endif comments
  if line:match('^%s*#%s*endif%s*[^/\\s]+') then
    error(
      filename,
      linenum,
      'build/endif_comment',
      5,
      'Uncommented text after #endif is non-standard.  Use a comment.'
    )
  end
end

-- Nesting state classes
local BlockInfo = {}
BlockInfo.__index = BlockInfo

function BlockInfo.new(seen_open_brace)
  local self = setmetatable({}, BlockInfo)
  self.seen_open_brace = seen_open_brace
  self.open_parentheses = 0
  self.inline_asm = NO_ASM
  return self
end

local PreprocessorInfo = {}
PreprocessorInfo.__index = PreprocessorInfo

function PreprocessorInfo.new(stack_before_if)
  local self = setmetatable({}, PreprocessorInfo)
  self.stack_before_if = stack_before_if
  self.stack_before_else = {}
  self.seen_else = false
  return self
end

local NestingState = {}
NestingState.__index = NestingState

function NestingState.new()
  local self = setmetatable({}, NestingState)
  self.stack = {}
  self.pp_stack = {}
  return self
end

function NestingState:seen_open_brace()
  return #self.stack == 0 or self.stack[#self.stack].seen_open_brace
end

function NestingState:update_preprocessor(line)
  if line:match('^%s*#%s*(if|ifdef|ifndef)') then
    table.insert(self.pp_stack, PreprocessorInfo.new(vim.deepcopy(self.stack)))
  elseif line:match('^%s*#%s*(else|elif)') then
    if #self.pp_stack > 0 then
      if not self.pp_stack[#self.pp_stack].seen_else then
        self.pp_stack[#self.pp_stack].seen_else = true
        self.pp_stack[#self.pp_stack].stack_before_else = vim.deepcopy(self.stack)
      end
      self.stack = vim.deepcopy(self.pp_stack[#self.pp_stack].stack_before_if)
    end
  elseif line:match('^%s*#%s*endif') then
    if #self.pp_stack > 0 then
      if self.pp_stack[#self.pp_stack].seen_else then
        self.stack = self.pp_stack[#self.pp_stack].stack_before_else
      end
      table.remove(self.pp_stack)
    end
  end
end

function NestingState:update(clean_lines, linenum)
  local line = clean_lines.elided[linenum + 1]

  self:update_preprocessor(line)

  if #self.stack > 0 then
    local inner_block = self.stack[#self.stack]
    local depth_change = select(2, line:gsub('%(', '')) - select(2, line:gsub('%)', ''))
    inner_block.open_parentheses = inner_block.open_parentheses + depth_change

    if inner_block.inline_asm == NO_ASM or inner_block.inline_asm == END_ASM then
      if depth_change ~= 0 and inner_block.open_parentheses == 1 and match_asm(line) then
        inner_block.inline_asm = INSIDE_ASM
      else
        inner_block.inline_asm = NO_ASM
      end
    elseif inner_block.inline_asm == INSIDE_ASM and inner_block.open_parentheses == 0 then
      inner_block.inline_asm = END_ASM
    end
  end

  while true do
    local matched = line:match('^[^{;)}]*([{;)}])(.*)$')
    if not matched then
      break
    end

    local token = matched:sub(1, 1)
    if token == '{' then
      if not self:seen_open_brace() then
        self.stack[#self.stack].seen_open_brace = true
      else
        table.insert(self.stack, BlockInfo.new(true))
        if match_asm(line) then
          self.stack[#self.stack].inline_asm = BLOCK_ASM
        end
      end
    elseif token == ';' or token == ')' then
      if not self:seen_open_brace() then
        table.remove(self.stack)
      end
    else -- token == '}'
      if #self.stack > 0 then
        table.remove(self.stack)
      end
    end
    line = matched:sub(2)
  end
end

-- Main processing functions
local function process_line(
  filename,
  clean_lines,
  line,
  nesting_state,
  error,
  extra_check_functions
)
  local raw_lines = clean_lines.raw_lines
  local init_lines = clean_lines.init_lines

  parse_nolint_suppressions(raw_lines[line + 1], line)
  nesting_state:update(clean_lines, line)

  if
    #nesting_state.stack > 0 and nesting_state.stack[#nesting_state.stack].inline_asm ~= NO_ASM
  then
    return
  end

  check_for_multiline_comments_and_strings(filename, clean_lines, line, error)
  check_for_old_style_comments(filename, init_lines[line + 1], line, error)
  check_language(filename, clean_lines, line, error)
  check_for_non_standard_constructs(filename, clean_lines, line, error)
  check_posix_threading(filename, clean_lines, line, error)
  check_memory_functions(filename, clean_lines, line, error)
  check_os_functions(filename, clean_lines, line, error)

  for _, check_fn in ipairs(extra_check_functions or {}) do
    check_fn(filename, clean_lines, line, error)
  end
end

local function process_file_data(filename, file_extension, lines, error, extra_check_functions)
  -- Add marker lines
  table.insert(lines, 1, '// marker so line numbers and indices both start at 1')
  table.insert(lines, '// marker so line numbers end in a known way')

  local nesting_state = NestingState.new()

  reset_nolint_suppressions()
  reset_known_error_suppressions()

  local init_lines = vim.deepcopy(lines)

  if cpplint_state.record_errors_file then
    local function recorded_error(filename_, linenum, category, confidence, message)
      if not is_error_suppressed_by_nolint(category, linenum) then
        local key_start = math.max(1, linenum)
        local key_end = math.min(#lines, linenum + 2)
        local key_lines = {}
        for i = key_start, key_end do
          table.insert(key_lines, lines[i])
        end
        local err = { filename_, key_lines, category }
        cpplint_state.record_errors_file:write(vim.json.encode(err) .. '\n')
      end
      error(filename_, linenum, category, confidence, message)
    end
    error = recorded_error
  end

  remove_multiline_comments(filename, lines, error)
  local clean_lines = CleansedLines.new(lines, init_lines)

  for line = 0, clean_lines:num_lines() - 1 do
    process_line(filename, clean_lines, line, nesting_state, error, extra_check_functions)
  end

  if file_extension == 'h' then
    check_for_header_guard(filename, lines, error)
    check_includes(filename, lines, error)
    if filename:match('/defs%.h$') or filename:match('_defs%.h$') then
      check_non_symbols(filename, lines, error)
    end
  end

  check_for_bad_characters(filename, lines, error)
end

local function process_file(filename, vlevel, extra_check_functions)
  cpplint_state:set_verbose_level(vlevel)

  local lines

  if filename == '-' then
    local stdin = io.read('*all')
    lines = vim.split(stdin, '\n')
    if cpplint_state.stdin_filename ~= '' then
      filename = cpplint_state.stdin_filename
    end
  else
    local ok, content = pcall(vim.fn.readfile, filename)
    if not ok then
      io.stderr:write("Skipping input '" .. filename .. "': Can't open for reading\n")
      return
    end
    lines = content
  end

  -- Remove trailing '\r'
  for i, line in ipairs(lines) do
    if line:sub(-1) == '\r' then
      lines[i] = line:sub(1, -2)
    end
  end

  local file_extension = filename:match('^.+%.(.+)$') or ''

  if filename ~= '-' and not valid_extensions[file_extension] then
    local ext_list = {}
    for ext, _ in pairs(valid_extensions) do
      table.insert(ext_list, '.' .. ext)
    end
    io.stderr:write(
      'Ignoring ' .. filename .. '; only linting ' .. table.concat(ext_list, ', ') .. ' files\n'
    )
  else
    process_file_data(filename, file_extension, lines, error_func, extra_check_functions)
  end
end

-- Main function
local function main(args)
  local filenames, opts = parse_arguments(args)

  cpplint_state:set_output_format(opts.output_format)
  cpplint_state:set_verbose_level(opts.verbose_level)
  cpplint_state:set_filters(opts.filters)
  cpplint_state:set_counting_style(opts.counting_style)
  valid_extensions = {}
  for _, ext in ipairs(opts.extensions) do
    valid_extensions[ext] = true
  end

  cpplint_state:suppress_errors_from(opts.suppress_errors_file)
  cpplint_state:record_errors_to(opts.record_errors_file)
  cpplint_state.stdin_filename = opts.stdin_filename

  cpplint_state:reset_error_counts()

  for _, filename in ipairs(filenames) do
    process_file(filename, cpplint_state.verbose_level)
  end

  cpplint_state:print_error_counts()

  if cpplint_state.record_errors_file then
    cpplint_state.record_errors_file:close()
  end

  vim.cmd.cquit(cpplint_state.error_count > 0 and 1 or 0)
end

-- Export main function
main(_G.arg)
