init.lua

require("utils")

-- [[ Paths ]]
Paths = {
  bin_dirs = {
    vim.env.HOME .. "/.local/bin",
    vim.env.HOME .. "/.cargo/bin",
  },

  no_project_dirs = {
    "/mnt/c/WINDOWS/system32",
    "C:\\Program Files\\Neovide",
  },

  lazy = vim.fn.stdpath("data") .. "/lazy/lazy.nvim",
  spellfile = vim.fn.stdpath("config") .. "/spell/en.utf-8.add",
  windows_shell = "C:\\Users\\eveti\\scoop\\apps\\git\\current\\bin\\bash.exe",
  windows_query_driver = "C:/Users/eveti/scoop/apps/mingw/**/bin/gcc.exe",
}

-- [[ Command Shortcuts ]]
Paths.commands = IsWindows() and {
  Programming = "~/Programming/learn/",
  Shada       = "~/AppData/Local/nvim-data/shada/",
  Config      = "~/AppData/Local/nvim/",
  Learn       = "~/Programming/learn/",
  Ideas       = "~/programming/ideas/",
  Videos      = "~/programming/videos/",
  AppData     = "~/AppData/",
  Bashrc      = "~/.bashrc",
} or {
  Programming = "~/programming/learn/",
  Shada       = "~/.local/state/nvim/shada/",
  Config      = "~/.config/nvim/",
  Learn       = "~/programming/learn/",
  Ideas       = "~/programming/ideas/",
  Kernel      = "~/programming/learn/kernel/",
  VM          = "~/programming/learn/qemu-kernel-vm/",
  Bashrc      = "~/.bashrc",
}

local function prepend_path(dir)
  if vim.fn.isdirectory(dir) == 1 and not vim.env.PATH:find(dir, 1, true) then
    vim.env.PATH = dir .. ":" .. vim.env.PATH
  end
end

if vim.fn.has("unix") == 1 then
  for _, dir in ipairs(Paths.bin_dirs) do
    prepend_path(dir)
  end
end

if vim.tbl_contains(Paths.no_project_dirs, vim.fn.getcwd()) then
  vim.cmd("cd " .. vim.fn.expand("~"))
end

---@diagnostic disable-next-line: undefined-field
if not vim.loop.fs_stat(Paths.lazy) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    Paths.lazy,
  })
end
vim.opt.rtp:prepend(Paths.lazy)

require("config")
require("keymaps")
require("lazy").setup({
  {
    "neovim/nvim-lspconfig",
    version = "v2.5.0",
    event = { "BufReadPre", "BufNewFile" },
    dependencies = {
      "williamboman/mason.nvim",
      "williamboman/mason-lspconfig.nvim",
      "hrsh7th/nvim-cmp",
      "hrsh7th/cmp-buffer",
      "hrsh7th/cmp-path",
      "hrsh7th/cmp-nvim-lua",
      "hrsh7th/cmp-nvim-lsp",
      "hrsh7th/cmp-cmdline",
      "L3MON4D3/LuaSnip",
      "saadparwaiz1/cmp_luasnip",
      "stevearc/conform.nvim",
    },
    config = function()
      require("mason").setup()
      local capabilities = require("cmp_nvim_lsp").default_capabilities()

      require("mason-lspconfig").setup({
        ensure_installed = { "lua_ls", "clangd", "glsl_analyzer",
                             "tsserver", "svelte", "biome", "gopls", "pyright" },
      })

      local mason_registry = require("mason-registry")
      if not mason_registry.is_installed("clang-format") then
        vim.cmd("MasonInstall clang-format")
      end

      vim.lsp.config("lua_ls", {
        capabilities = capabilities,
      })

      local clangd_cmd = {
        "clangd",
        "--background-index",
        "--clang-tidy",
        "--header-insertion=never",
      }

      if IsWindows() then
        table.insert(clangd_cmd, "--query-driver=" .. Paths.windows_query_driver)
      else
        table.insert(clangd_cmd, "--query-driver=**")
      end

      vim.lsp.config("clangd", {
        filetypes = { "c", "cpp" },
        capabilities = capabilities,
        cmd = clangd_cmd,
      })

      vim.lsp.config("glsl_analyzer", {
        filetypes = { "glsl", "vert", "frag" },
        capabilities = capabilities,
      })

      vim.lsp.config("ts_ls", {
        filetypes = { "javascript", "javascriptreact", "typescript", "typescriptreact" },
        capabilities = capabilities,
        cmd = { "typescript-language-server", "--stdio" },
      })

      vim.lsp.config("biome", {
        filetypes = { "css", "html", "json", "jsonc" },
        capabilities = capabilities,
      })

      vim.lsp.config("svelte", {
        filetypes = { "svelte" },
        capabilities = capabilities,
      })

      vim.lsp.config("gopls", {
        filetypes = { "go", "gomod", "gowork", "gotmpl" },
        capabilities = capabilities,
        settings = {
          gopls = {
            analyses = {
              unusedparams = true,
            },
            staticcheck = true,
            gofumpt = true,
          },
        },
      })

      vim.lsp.config("pyright", {
        filetypes = { "python" },
        capabilities = capabilities,
      })

      vim.lsp.enable({ "lua_ls", "clangd", "glsl_analyzer",
                       "ts_ls", "biome", "svelte", "gopls", "pyright" })

      --[[ Conform ]]
      local conform = require("conform")
      conform.setup({
        formatters_by_ft = {
          -- C/CPP
          c = { "clang_format" },
          cpp = { "clang_format" },
          h = { "clang_format" },
          hpp = { "clang_format" },
          glsl = { "clang_format" },

          -- JavaScript
          javascript = { "biome" },
          javascriptreact = { "biome" },
          typescript = { "biome" },
          typescriptreact = { "biome" },
          svelte = { "biome" },
        },
      })

      vim.keymap.set("n", "<C-f>", function()
        local line = vim.fn.line(".")
        conform.format({
          lsp_fallback = true,
          async = true,
          range = { start = { line, 0 }, ["end"] = { line, 0 } },
        })
      end)

      local escape_key = vim.api.nvim_replace_termcodes("<Esc>", true, false, true)
      vim.keymap.set("v", "<C-f>", function()
        conform.format({ lsp_fallback = true, async = true })
        vim.api.nvim_feedkeys(escape_key, "n", false)
      end)

      vim.api.nvim_create_autocmd("LspAttach", {
        group = vim.api.nvim_create_augroup("UserLspConfig", {}),
        callback = function(args)
          local client = vim.lsp.get_client_by_id(args.data.client_id)
          if not client then
            return
          end

          local opts = { buffer = args.buf }
          vim.keymap.set("n", "gd", vim.lsp.buf.definition, opts)
          vim.keymap.set("n", "gh", vim.lsp.buf.hover, opts)
          vim.keymap.set("n", "gm", vim.diagnostic.open_float, opts)
          vim.keymap.set("n", "<leader>r", vim.lsp.buf.rename, opts)
        end,
      })

      --[[ LuaSnip ]]
      local ls = require("luasnip")
      ls.config.set_config({
        history = true,
        update_events = "TextChanged,TextChangedI",
        enable_autosnippets = true,
      })

      --[[ CMP ]]
      local cmp = require("cmp")
      cmp.setup({
        performance = {
          debounce = 60,
          throttle = 30,
          async_budget = 1,
          fetching_timeout = 500,
          confirm_resolve_timeout = 80,
          max_view_entries = 10,
        },
        snippet = {
          expand = function(args)
            ls.lsp_expand(args.body)
          end,
        },
        mapping = cmp.mapping.preset.insert({
          ["<C-Space>"] = cmp.mapping.complete(),
          ["<C-e>"] = cmp.mapping.abort(),
          ["<CR>"] = cmp.mapping.confirm({ select = true }),
          ["<C-n>"] = cmp.mapping.select_next_item(),
          ["<C-p>"] = cmp.mapping.select_prev_item(),
        }),
        sources = cmp.config.sources({
          { name = "luasnip" },
          { name = "nvim_lua" },
          { name = "nvim_lsp" },
          { name = "buffer" },
          { name = "path" },
        }),
      })
    end,
  },
  {
    "akinsho/toggleterm.nvim",
    version = "*",
    opts = {
      direction = "float",
      close_on_exit = true,
      float_opts = {
        border = "curved",
        winblend = 0,
        highlights = {
          border = "Normal",
          background = "Normal",
        },
      },
    },
    event = "VeryLazy",
    config = function(_, opts)
      local toggleterm = require("toggleterm")

      if IsWindows() then
        -- INFO: Config for Gitbash:
        opts.shell = Paths.windows_shell
      end

      local harpoon = require("harpoon")
      local function close_harpoon_menu()
        if harpoon.ui.win_id and vim.api.nvim_win_is_valid(harpoon.ui.win_id) then
          harpoon.ui:close_menu()
        end
      end

      local current_term = nil
      local function switch_terminal(target_term)
        return function()
          close_harpoon_menu()

          if current_term == target_term then
            vim.cmd("q")
            current_term = nil
            return
          end

          if target_term == 0 then
            vim.cmd("q!")
            current_term = nil
            return
          end

          if current_term ~= nil then
            vim.cmd("q")
          end

          local term_cmd = target_term .. "ToggleTerm"
          vim.cmd(string.format("%s dir=%s", term_cmd, Cwd()))
          current_term = target_term
        end
      end

      vim.keymap.set("n", "<C-1>", switch_terminal(1))
      vim.keymap.set("n", "<C-2>", switch_terminal(2))
      vim.keymap.set("n", "<C-3>", switch_terminal(3))

      function _G.set_terminal_keymaps()
        vim.keymap.set("t", "<C-d>", "<Nop>")
        vim.keymap.set("t", "<C-S-v>", [[<C-\><C-n>"+pa]])
        vim.keymap.set("t", "<C-S-d>", switch_terminal(0))
        vim.keymap.set("t", "<C-1>", switch_terminal(1))
        vim.keymap.set("t", "<C-2>", switch_terminal(2))
        vim.keymap.set("t", "<C-3>", switch_terminal(3))
        vim.keymap.set("t", "<esc>", [[<C-\><C-n>]])
      end

      opts.on_open = set_terminal_keymaps
      toggleterm.setup(opts)
    end,
  },
  {
    "nvim-telescope/telescope.nvim",
    dependencies = {
      { "nvim-lua/plenary.nvim" },
      { "nvim-telescope/telescope-fzf-native.nvim", build = "make" }
    },
    config = function()
      local telescope_builtin = require("telescope.builtin")
      local telescope_state = require("telescope.state")
      local telescope_prev_utils = require("telescope.previewers.utils")

      local function resume_or_open(title, open)
        local root = GetRootDir()
        local cached = telescope_state.get_global_key("cached_pickers") or {}
        for i, picker in ipairs(cached) do
          if picker.prompt_title == title and picker.cwd == root then
            telescope_builtin.resume({ cache_index = i })
            return
          end
        end
        open()
      end

      vim.keymap.set("n", "<Leader>f", function()
        telescope_builtin.find_files({ cwd = GetRootDir() })
      end)
      vim.keymap.set("n", "<Leader>g", function()
        telescope_builtin.live_grep({ cwd = GetRootDir() })
      end)

      vim.keymap.set("n", "<Leader>F", function()
        resume_or_open("Find Files", function()
          telescope_builtin.find_files({ cwd = GetRootDir() })
        end)
      end)
      vim.keymap.set("n", "<Leader>G", function()
        resume_or_open("Live Grep", function()
          telescope_builtin.live_grep({ cwd = GetRootDir() })
        end)
      end)

      local telescope = require("telescope")
      telescope.setup({
        defaults = {
          cache_picker = {
            num_pickers = 10,
          },
          file_ignore_patterns = { "^.git/", "node_modules", "%.meta$" },
          vimgrep_arguments = {
            "rg",
            "--color=never",
            "--no-heading",
            "--with-filename",
            "--line-number",
            "--column",
            "--smart-case",
            "--hidden",
            "--fixed-strings",
            "--trim",
          },
        },
        extensions = {
          fzf = {
            fuzzy = true,
            override_generic_sorter = true,
            override_file_sorter = true,
            case_mode = "smart_case",
          }
        }
      })
      telescope.load_extension("fzf")

      ---@diagnostic disable-next-line: duplicate-set-field
      telescope_prev_utils.ts_highlighter = function(bufnr, ft)
        if not ft or ft == "" then
          return false
        end

        local lang = vim.treesitter.language.get_lang(ft)
        if lang and vim.treesitter.language.add(lang) then
          return false
        end
        return (pcall(vim.treesitter.start, bufnr, lang))
      end
    end
  },
  {
    "nvim-treesitter/nvim-treesitter",
    branch = "main",
    build = ":TSUpdate",
    config = function()
      vim.filetype.add({
        extension = { glsl = "glsl", vert = "glsl", frag = "glsl" },
      })

      require("nvim-treesitter").setup()
      require("nvim-treesitter").install({
        "c", "cpp", "rust", "glsl",
        "markdown", "markdown_inline", "latex",
        "javascript", "typescript", "lua", "python",
        "jsx", "tsx", "svelte", "html", "css",
        "json", "yaml", "bash",
        "query", "dockerfile",
      })

      vim.api.nvim_create_autocmd("FileType", {
        group = vim.api.nvim_create_augroup("treesitter_highlight", { clear = true }),
        callback = function(ev)
          if vim.bo[ev.buf].filetype == "oil" then
            return
          end

          pcall(vim.treesitter.start, ev.buf)
        end,
      })
    end,
  },
  {
    "stevearc/oil.nvim",
    lazy = false,
    dependencies = { "nvim-tree/nvim-web-devicons" },
    config = function()
      require("oil").setup({
        view_options = {
          show_hidden = true,
          is_always_hidden = function(name)
            return vim.endswith(name, ".uid")
          end,
        },
        use_default_keymaps = false,
        keymaps = {
          ["<CR>"] = "actions.select",
          ["<leader>r"] = "actions.refresh",
        },
      })

      local cmp = require("cmp")
      vim.api.nvim_create_autocmd("FileType", {
        pattern = "oil",
        callback = function()
          cmp.setup.buffer({ enabled = false })
        end,
      })
    end,
  },
  {
    "sainnhe/gruvbox-material",
    priority = 1000,
    config = function()
      vim.g.gruvbox_material_better_performance = 1
      vim.g.gruvbox_material_disable_italic_comment = 1
      vim.cmd.colorscheme("gruvbox-material")

      local fg = vim.api.nvim_get_hl(0, { name = "Normal" }).fg
      local highlights = {
        FloatShadow = {},
        MatchParen = { bg = "#504945", sp = "NONE" },
        Normal = { bg = "#191919", fg = fg },
        StatusLine = { bg = "#0D0D0D", fg = fg },
        TelescopeNormal = { bg = "#0F0F0F", fg = fg },
        TelescopeBorder = { bg = "#0F0F0F", fg = fg },
        Pmenu = { bg = "#0D0D0D", fg = fg },
        NormalFloat = { bg = "#0D0D0D", fg = fg },
        CursorLine = { bg = "#0D0D0D" },
        FloatBorder = { bg = "#0B0B0B", fg = fg },
      }

      for group, opts in pairs(highlights) do
        vim.api.nvim_set_hl(0, group, opts)
      end
    end,
  },
  {
    "ThePrimeagen/harpoon",
    branch = "harpoon2",
    dependencies = { "nvim-lua/plenary.nvim" },
    config = function()
      local harpoon = require("harpoon")
      harpoon:setup()

      vim.keymap.set("n", "<leader>a", function() harpoon:list():add() end)
      vim.keymap.set("n", "<C-e>", function() harpoon.ui:toggle_quick_menu(harpoon:list()) end)

      vim.keymap.set("n", "<C-h>", function() harpoon:list():select(1) end)
      vim.keymap.set("n", "<C-t>", function() harpoon:list():select(2) end)
      vim.keymap.set("n", "<C-n>", function() harpoon:list():select(3) end)
      vim.keymap.set("n", "<C-s>", function() harpoon:list():select(4) end)
    end,
  },
  {
    "kylechui/nvim-surround",
    version = "*",
    event = "VeryLazy",
    config = function()
      require("nvim-surround").setup({
        keymaps = {
          normal = "s",
          visual = "s",
          normal_cur = "ss",
          delete = "ds",
          change = "cs",
        },
      })
    end
  },
  {
    "windwp/nvim-ts-autotag",
    dependencies = { "nvim-treesitter/nvim-treesitter" },
    ft = { "html", "javascript", "javascriptreact", "typescript",
           "typescriptreact", "svelte", "vue", "xml" },
    config = function()
      require("nvim-ts-autotag").setup({
        opts = {
          enable_close = true,
          enable_rename = true,
          enable_close_on_slash = true
        },
      })
    end,
  },
  {
    "rmagatti/auto-session",
    lazy = false,
    config = function()
      require("auto-session").setup({
        auto_restore_last_session = true,
      })
    end
  },
  {
    "windwp/nvim-autopairs",
    event = "InsertEnter",
    config = function()
      require("nvim-autopairs").setup({})
    end,
  },
  {
    "folke/todo-comments.nvim",
    dependencies = { "nvim-lua/plenary.nvim" },
    opts = { signs = false }
  },
  { "numToStr/Comment.nvim", event = "VeryLazy" },
  { "folke/lazydev.nvim", ft = "lua", opts = {} },
})
require("commands")