-- This is where I install my package manager and plugins of choice. For more
-- details, just look for `packger.nvim` help tag.

-- Bootstrapping for the package manager
local install_path = vim.fn.stdpath("data") .. "/site/pack/packer/start/packer.nvim"

if vim.fn.empty(vim.fn.glob(install_path)) > 0 then
  packer_bootstrap = vim.fn.system({ "git", "clone", "https://github.com/wbthomason/packer.nvim", install_path })
end

local packer = require("packer")
local util = require("packer.util")

return packer.startup({
  function(use)
    -- Let the package manager manage itself.
    use({ "wbthomason/packer.nvim" })

    -- Custom color themes!
    use({ "rktjmp/lush.nvim" })

    -- EditorConfig plugin
    use({ "editorconfig/editorconfig-vim" })

    -- Colorize common color strings
    use({
      "norcalli/nvim-colorizer.lua",
      config = function()
        require("colorizer").setup()
      end,
    })

    -- Snippets engine.
    -- A must have for me.
    use({
      "L3MON4D3/LuaSnip",
      requires = {
        "rafamadriz/friendly-snippets",
      },
      config = function()
        require("luasnip.loaders.from_vscode").lazy_load()
        require("luasnip.loaders.from_lua").lazy_load()

        local ls = require("luasnip")
        local types = require("luasnip.util.types")
        ls.config.set_config({
          history = true,
          update_events = "TextChanged,TextChangedI",
          ext_opts = {
            [types.choiceNode] = {
              active = {
                virt_text = { { "<- Current choice", "Comment" } },
              },
            },
          },
        })

        vim.keymap.set({ "i", "s" }, "<c-j>", function()
          if ls.jumpable(1) then
            ls.jump(1)
          end
        end)

        vim.keymap.set({ "i", "s" }, "<c-k>", function()
          if ls.jumpable(-1) then
            ls.jump(-1)
          end
        end)

        vim.keymap.set({ "i", "s" }, "<c-l>", function()
          if ls.expand_or_jumpable() then
            ls.expand_or_jump()
          end
        end)

        vim.keymap.set({ "i", "s" }, "<c-u>", function()
          require("luasnip.extras.select_choice")()
        end)
      end,
    })

    -- Fuzzy finder of lists
    use({
      "nvim-telescope/telescope.nvim",
      requires = {
        { "nvim-lua/popup.nvim" },
        { "nvim-lua/plenary.nvim" },
        { "nvim-telescope/telescope-project.nvim" },
      },

      config = function()
        -- Telescope setup
        require("telescope").setup({
          extensions = {
            project = {
              base_dirs = {
                { "~/library/projects/software", max_depth = 2 },
                { "~/library/projects/packages" },
                { "~/library/writings" },
              },
            },
          },
        })

        require("telescope").load_extension("project")

        vim.keymap.set(
          "n",
          "<leader>ff",
          '<cmd>lua require("telescope.builtin").find_files({ hidden = true })<cr>',
          { noremap = true }
        )
        vim.keymap.set(
          "n",
          "<leader>fF",
          '<cmd>lua require("telescope.builtin").find_files({ cwd = require("telescope.utils").buffer_dir(), hidden = true })<cr>',
          { noremap = true }
        )
        vim.keymap.set("n", "<leader>fg", '<cmd>lua require("telescope.builtin").grep_string()<cr>', { noremap = true })
        vim.keymap.set("n", "<leader>fG", '<cmd>lua require("telescope.builtin").live_grep()<cr>', { noremap = true })
        vim.keymap.set("n", "<leader>fb", '<cmd>lua require("telescope.builtin").buffers()<cr>', { noremap = true })
        vim.keymap.set("n", "<leader>fh", '<cmd>lua require("telescope.builtin").help_tags()<cr>', { noremap = true })
        vim.keymap.set("n", "<leader>ft", '<cmd>lua require("telescope.builtin").treesitter()<cr>', { noremap = true })
        vim.keymap.set("n", "<leader>fb", '<cmd>lua require("telescope.builtin").buffers()<cr>', { noremap = true })
        vim.keymap.set("n", "<leader>fr", '<cmd>lua require("telescope.builtin").oldfiles()<cr>', { noremap = true })
        vim.keymap.set(
          "n",
          "<leader>fR",
          '<cmd>lua require("telescope.builtin").oldfiles({ only_cwd = true })<cr>',
          { noremap = true }
        )
        vim.keymap.set("n", "<leader>fA", '<cmd>lua require("telescope.builtin").resume()<cr>', { noremap = true })

        -- Ekeymap.set
        vim.keymap.set(
          "n",
          "<leader>fp",
          '<cmd>lua require("telescope").extensions.project.project({})<cr>',
          { noremap = true }
        )
      end,
    })

    -- Marks in ~~steroids~~ coconut oil
    use({
      "ThePrimeagen/harpoon",
      config = function()
        vim.keymap.set("n", "<leader>fm", "<cmd>lua require('harpoon.mark').add_file()<cr>", {})

        local has_telescope, telescope = pcall("telescope")
        if has_telescope then
          vim.keymap.set("n", "<leader>fM", "<cmd>lua require('telescope').extensions.harpoon.harpoon({})<cr>", {})
          require("telescope").load_extension("harpoon")
        end
      end,
      requires = { { "nvim-lua/plenary.nvim" } },
    })

    -- A completion engine.
    -- nvim-cmp is mostly explicit by making the configuration process manual unlike bigger plugins like CoC
    use({
      "hrsh7th/nvim-cmp",
      requires = {
        "hrsh7th/cmp-buffer",
        "hrsh7th/cmp-path",
        "hrsh7th/cmp-nvim-lsp",
        "hrsh7th/cmp-nvim-lua",
        "saadparwaiz1/cmp_luasnip",
      },
      config = function()
        local cmp = require("cmp")

        cmp.setup({
          snippet = {
            expand = function(args)
              ls.lsp_expand(args.body)
            end,
          },

          sources = {
            { name = "luasnip" },
            { name = "buffer" },
            { name = "path" },
            { name = "nvim_lua" },
            { name = "nvim_lsp" },
          },

          mapping = {
            ["<C-Space>"] = cmp.mapping(cmp.mapping.complete(), { "i", "c" }),
            ["<C-b>"] = cmp.mapping(cmp.mapping.scroll_docs(-4), { "i", "c" }),
            ["<C-f>"] = cmp.mapping(cmp.mapping.scroll_docs(4), { "i", "c" }),
            ["<C-n>"] = cmp.mapping(cmp.mapping.select_next_item(), { "i", "c" }),
            ["<C-p>"] = cmp.mapping(cmp.mapping.select_prev_item(), { "i", "c" }),
            ["<C-l>"] = cmp.mapping(cmp.mapping.confirm({ select = true }), { "i", "c" }),
            ["<C-g>"] = cmp.mapping({
              i = cmp.mapping.abort(),
              c = cmp.mapping.close(),
            }),
          },
        })
      end,
    })

    -- A linting engine, a DAP client, and an LSP client entered into a bar.
    use({
      "dense-analysis/ale",
      config = function()
        vim.g.ale_disable_lsp = 1
      end,
    })
    use({ "neovim/nvim-lspconfig" })
    use({ "mfussenegger/nvim-dap" })
    use({ "puremourning/vimspector" })

    -- tree-sitter
    use({
      "nvim-treesitter/nvim-treesitter",
      requires = {
        "nvim-treesitter/nvim-treesitter-textobjects",
      },
      run = ":TSUpdate",
      config = function()
        vim.opt.foldmethod = "expr"
        vim.opt.foldexpr = "nvim_treesitter#foldexpr()"

        require("nvim-treesitter.configs").setup({
          highlight = {
            enable = true,
            additional_vim_regex_highlighting = false,
          },

          incremental_selection = {
            enable = true,
            keymaps = {
              init_selection = "gnn",
              node_incremental = "grn",
              scope_incremental = "grc",
              node_decremental = "grm",
            },
          },

          indent = { enable = true },

          -- custom text objects with nvim-treesitter-textobjects
          -- I've just copied this from the README but they are reasonable additions to me.
          textobjects = {
            select = {
              enable = true,
              lookahead = true,

              keymaps = {
                ["af"] = "@function.outer",
                ["if"] = "@function.inner",
                ["ae"] = "@block.outer",
                ["ie"] = "@block.inner",
                ["ac"] = "@class.outer",
                ["ic"] = "@class.inner",
                ["aC"] = "@conditional.outer",
                ["iC"] = "@conditional.inner",
              },
            },
          },
        })
      end,
    })

    -- One of the most popular plugins.
    -- Allows to create more substantial status bars.
    use({ "vim-airline/vim-airline" })

    -- Fuzzy finder for finding files freely and fastly.
    use({
      "junegunn/fzf",
      requires = "junegunn/fzf.vim",
    })

    -- Enable visuals for addition/deletion of lines in the gutter (side) similar to Visual Studio Code.
    use({ "airblade/vim-gitgutter" })

    -- Language plugins.
    use({ "LnL7/vim-nix" }) -- Nix
    use({ "vmchale/dhall-vim" }) -- Dhall
    use({ "ziglang/zig.vim" }) -- Zig

    use({ "RRethy/nvim-base16" })

    -- Use Neovim even inside of browsers.
    use({
      "glacambre/firenvim",
      run = function()
        vim.fn["firenvim#install"](0)
      end,
    })

    use({ "https://gitlab.com/HiPhish/guile.vim.git" })
    use({ "Olical/conjure" })
  end,
  config = {
    compile_path = util.join_paths(vim.fn.stdpath("data"), "site", "after", "plugin", "packer_compiled.lua"),
  },
})