lua <<EOF
local lazypath = vim.fn.stdpath('data') .. '/lazy/lazy.nvim'
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable", -- latest stable release
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

require('lazy').setup({
  {
    'doums/darcula',
    lazy = false,
    priority = 1000,
    config = function()
      vim.cmd([[colorscheme darcula]])
      vim.cmd([[set termguicolors]])
      vim.cmd([[highlight Normal guibg=NONE ctermbg=NONE]])
    end,
  },

  {
    'airblade/vim-gitgutter',
    event = 'VimEnter',
    config = function()
      vim.cmd([[nnoremap <leader>gp <cmd>GitGutterPreviewHunk<CR>]])
      vim.cmd([[nnoremap <leader>gu <cmd>GitGutterUndoHunk<CR>]])
    end,
  },

  {
    'lukas-reineke/indent-blankline.nvim',
    event = 'VimEnter',

    config = function()
      local hooks = require('ibl.hooks')

      hooks.register(
        hooks.type.WHITESPACE,
        hooks.builtin.hide_first_space_indent_level
      )

      hooks.register(
        hooks.type.WHITESPACE,
        hooks.builtin.hide_first_tab_indent_level
      )

      hooks.register(
        hooks.type.HIGHLIGHT_SETUP,
        function()
          vim.api.nvim_set_hl(0, 'IndentBlanklineChar', { fg = '#303030', nocombine = true })
          vim.api.nvim_set_hl(0, 'IndentBlanklineContextChar', { fg = '#404040', nocombine = true })
        end
      )

      require('ibl').setup {
        indent = {
          highlight = {
            'IndentBlanklineChar',
          },
        },

        whitespace = {
          remove_blankline_trail = true,
        },

        scope = {
          enabled = false,

          highlight = {
            'IndentBlanklineContextChar',
          },
        },
      }
    end,
  },

  { 'gpanders/editorconfig.nvim', event = 'VimEnter' },
  { 'tpope/vim-surround', event = 'VimEnter' },
  { 'sheerun/vim-polyglot', event = 'VimEnter' },

  {
    'williamboman/mason-lspconfig.nvim',
    event = 'VimEnter',

    dependencies = {
      'williamboman/mason.nvim',
      'hrsh7th/cmp-nvim-lsp',
      'neovim/nvim-lspconfig',
    },

    config = function()
      local on_attach = function(client, bufnr)
        local function buf_set_keymap(...) vim.api.nvim_buf_set_keymap(bufnr, ...) end
        local function buf_set_option(...) vim.api.nvim_buf_set_option(bufnr, ...) end

        -- Enable completion triggered by <c-x><c-o>
        buf_set_option('omnifunc', 'v:lua.vim.lsp.omnifunc')

        -- Mappings.
        local opts = { noremap=true, silent=true }

        -- See :help vim.lsp.* for documentation on any of the below functions
        buf_set_keymap('n', 'gD', '<cmd>lua vim.lsp.buf.declaration()<CR>', opts)
        buf_set_keymap('n', 'gd', '<cmd>lua vim.lsp.buf.definition()<CR>', opts)
        buf_set_keymap('n', 'K', '<cmd>lua vim.lsp.buf.hover()<CR>', opts)
        buf_set_keymap('n', 'gi', '<cmd>lua vim.lsp.buf.implementation()<CR>', opts)
        buf_set_keymap('n', '<C-k>', '<cmd>lua vim.lsp.buf.signature_help()<CR>', opts)
        buf_set_keymap('n', '<space>wa', '<cmd>lua vim.lsp.buf.add_workspace_folder()<CR>', opts)
        buf_set_keymap('n', '<space>wr', '<cmd>lua vim.lsp.buf.remove_workspace_folder()<CR>', opts)
        buf_set_keymap('n', '<space>wl', '<cmd>lua print(vim.inspect(vim.lsp.buf.list_workspace_folders()))<CR>', opts)
        buf_set_keymap('n', '<space>D', '<cmd>lua vim.lsp.buf.type_definition()<CR>', opts)
        buf_set_keymap('n', '<space>rn', '<cmd>lua vim.lsp.buf.rename()<CR>', opts)
        buf_set_keymap('n', '<space>ca', '<cmd>lua vim.lsp.buf.code_action()<CR>', opts)
        buf_set_keymap('n', 'gr', '<cmd>lua vim.lsp.buf.references()<CR>', opts)
        buf_set_keymap('n', '<space>e', '<cmd>lua vim.diagnostic.open_float()<CR>', opts)
        buf_set_keymap('n', '[d', '<cmd>lua vim.diagnostic.goto_prev()<CR>', opts)
        buf_set_keymap('n', ']d', '<cmd>lua vim.diagnostic.goto_next()<CR>', opts)
        buf_set_keymap('n', '<space>q', '<cmd>lua vim.diagnostic.setloclist()<CR>', opts)
        buf_set_keymap('n', '<space>f', '<cmd>lua vim.lsp.buf.format({async = true})<CR>', opts)
      end

      local capabilities = vim.lsp.protocol.make_client_capabilities()
      capabilities = require('cmp_nvim_lsp').default_capabilities(capabilities)

      vim.o.completeopt = 'menuone,noselect'

      require('mason').setup()
      require('mason-lspconfig').setup()
      require('mason-lspconfig').setup_handlers {
        function (server_name)
          local lspconfig_setup = {
            on_attach = on_attach,
            capabilities = capabilities,
          }

          -- server specific config
          if server_name == 'volar' then
            lspconfig_setup['init_options'] = {
              vue = {
                hybridMode = false,
              }
            }
          end

          require('lspconfig')[server_name].setup(lspconfig_setup)
        end
      }

      -- fix LSPs not attaching to buffer sometimes
      local filetypes = {
        {
            pattern = '*.php',
            filetype = 'php',
        },
        {
            pattern = '*.js',
            filetype = 'javascript',
        },
        {
            pattern = '*.vue',
            filetype = 'vue',
        },
        {
            pattern = '*.twig',
            filetype = 'twig',
        },
        {
            pattern = '*.lua',
            filetype = 'lua',
        },
        {
            pattern = '*.vim',
            filetype = 'vim',
        },
        {
            pattern = '*.mcfunction',
            filetype = 'mcfunction',
        },
        {
            pattern = '*.rs',
            filetype = 'rust',
        },
        {
            pattern = '*.py',
            filetype = 'python',
        },
      }
      for _, entry in ipairs(filetypes) do
        vim.api.nvim_create_autocmd({ 'BufEnter' }, {
          pattern = { entry['pattern'] },
          callback = function(event)
            vim.cmd('set filetype=' .. entry['filetype'])
          end,
        })
      end
    end,
  },

  {
    'nvim-treesitter/nvim-treesitter',
    event = 'VimEnter',

    build = function()
      vim.cmd([[:TSUpdate]])
    end,

    config = function()
      require('nvim-treesitter.configs').setup {
        --ensure_installed = 'all',
        sync_install = false,
        auto_install = false,
        indent = {
          enable = true,
        },
        highlight = {
          enable = true,
          additional_vim_regex_highlighting = false,
        },
      }

      vim.cmd([[highlight! link @text.diff.add DiffAdd]])
      vim.cmd([[highlight! link @text.diff.delete DiffDelete]])
      vim.cmd([[highlight! link @text.diff.change DiffChange]])
      vim.cmd([[highlight! link @text.diff.text DiffText]])
    end,
  },

  {
    'nvim-treesitter/nvim-treesitter-context',
    event = 'CursorMoved',

    dependencies = {
      'nvim-treesitter/nvim-treesitter',
    },
  },

  {
    'nvim-treesitter/nvim-treesitter-refactor',
    keys = {
      'gnd',
      'gnD',
      'gO',
    },

    dependencies = {
      'nvim-treesitter/nvim-treesitter',
    },
  },

  {
    'sindrets/diffview.nvim',

    dependencies = {
      'nvim-tree/nvim-web-devicons',
    },

    cmd = 'DiffviewOpen',

    config = function()
      require('diffview').setup({})

      -- close all windows when Diffview is closed
      vim.api.nvim_create_autocmd('QuitPre', {
        callback = function()
          if vim.bo.filetype == 'DiffviewFiles' then
            vim.cmd([[quitall]])
          end
        end,
      })
    end,
  },

  {
    'preservim/nerdtree',

    dependencies = {
      'ryanoasis/vim-devicons',
      'Xuyuanp/nerdtree-git-plugin',
    },

    event = 'BufWinEnter',

    config = function()
      vim.g.NERDTreeShowHidden = 1
      vim.g.NERDTreeGitStatusShowIgnored = 1

      vim.g.NERDTreeShowLineNumbers = 1
      vim.cmd([[:autocmd BufEnter NERD_* setlocal rnu]])

      vim.cmd([[
        if !&diff
          autocmd StdinReadPre * let s:std_in=1
        endif
      ]])

      vim.cmd([[
        function NERDTreeInit()
          if !&diff
            let buffer_type = getbufvar(bufnr(), "&filetype")
            if index(g:NERDTreeNoInitFiletypes, buffer_type) == -1
              NERDTree

              if argc() > 0 || exists('s:std_in')
                wincmd p
              endif

              if argc() > 0
                silent NERDTreeFind
                wincmd p
              endif
            endif
          endif
        endfunction
        autocmd VimEnter * call NERDTreeInit()
      ]])

      vim.cmd([[autocmd BufWinEnter * if getcmdwintype() == '' | silent NERDTreeMirror | endif]])
      vim.cmd([[autocmd BufEnter * if winnr('$') == 1 && exists('b:NERDTree') && b:NERDTree.isTabTree() | quit | endif]])

      vim.cmd([[
        " set status line on tab switch
        function NERDTreeStatusLineTabSwitch()
          " only when in non-meaningful window
          if index(g:NERDTreeStatusLineTabSwitchFiletypes, &filetype) == -1
            return
          endif

          let tab_nr = tabpagenr()
          let buffer_list = tabpagebuflist(tab_nr)

          " default to 2
          let meaningful_window_nr = 2

          for buffer_nr in buffer_list
            let buffer_type = getbufvar(buffer_nr, "&filetype")
            if index(g:NERDTreeStatusLineTabSwitchFiletypes, buffer_type) == -1
              let meaningful_window_nr = bufwinnr(buffer_nr)
              break
            endif
          endfor

          exe meaningful_window_nr .. "wincmd w"
        endfunction
        autocmd TabLeave * call NERDTreeStatusLineTabSwitch()
      ]])

      vim.cmd([[map <C-b> <cmd>NERDTreeToggle<CR>]])
    end,
  },

  {
    'nvim-telescope/telescope.nvim',
    cmd = 'Telescope',
    dependencies = {
      'nvim-lua/plenary.nvim',
    },
    init = function()
      vim.cmd([[nnoremap <leader>ff <cmd>Telescope find_files<CR>]])
      vim.cmd([[nnoremap <leader>fg <cmd>Telescope live_grep<CR>]])
      vim.cmd([[nnoremap <leader><leader> <cmd>Telescope buffers<CR>]])
    end,
  },

  {
    'mg979/vim-xtabline',
    event = 'TabEnter',
  },

  {
    'ggandor/leap.nvim',
    keys = { 's', 'S' },
    config = function()
      require('leap').add_default_mappings()
    end,
  },

  {
    'iamcco/markdown-preview.nvim',

    ft = 'markdown',

    build = function()
     vim.fn['mkdp#util#install']()
    end,

    config = function()
      vim.g.mkdp_preview_options = {
        disable_sync_scroll = 1
      }
    end,
  },

  {
    'stevearc/aerial.nvim',

    dependencies = {
      'nvim-telescope/telescope.nvim',
    },

    cmd = {
      'AerialToggle',
      'Telescope aerial',
    },

    init = function()
      vim.cmd([[nnoremap <leader>a <cmd>AerialToggle!<CR>]])
      vim.cmd([[nnoremap <leader>fa <cmd>Telescope aerial<CR>]])
    end,

    config = function()
      require('aerial').setup({
        filter_kind = false,
      })

      require('telescope').load_extension('aerial')

      vim.cmd([[
        " add aerial to tab switch filetypes
        call add(g:NERDTreeStatusLineTabSwitchFiletypes, 'aerial')

        " close Aerial and NERDTree if they are the only remaining windows
        function AerialNERDTreeClose()
          if winnr('$') != 2
            return
          endif

          let window_filetypes = UtilityWinfiletypes()

          if index(window_filetypes, 'aerial') != -1 && index(window_filetypes, 'nerdtree') != -1
            " one quit suffices, since aerial and nerdtree close themselves
            quit
          endif
        endfunction
        autocmd BufEnter * call AerialNERDTreeClose()
      ]])
    end,
  },

  {
    'numToStr/Comment.nvim',
    keys = {
      'gcc',
      { 'gc', mode = 'v' },
      { 'gb', mode = 'v' },
    },
    config = function()
      require('Comment').setup()
    end,
  },

  {
    'hrsh7th/nvim-cmp',
    dependencies = {
      'saadparwaiz1/cmp_luasnip',
      'L3MON4D3/LuaSnip',
    },
    event = 'InsertEnter',
    config = function()
      local cmp = require('cmp')
      local luasnip = require('luasnip')

      cmp.setup {
        snippet = {
          expand = function(args)
            luasnip.lsp_expand(args.body)
          end,
        },
        mapping = {
          ['<C-p>'] = cmp.mapping.select_prev_item(),
          ['<C-n>'] = cmp.mapping.select_next_item(),
          ['<C-d>'] = cmp.mapping.scroll_docs(-4),
          ['<C-f>'] = cmp.mapping.scroll_docs(4),
          ['<C-Space>'] = cmp.mapping.complete(),
          ['<C-e>'] = cmp.mapping.close(),
          ['<CR>'] = cmp.mapping.confirm {
            behavior = cmp.ConfirmBehavior.Replace,
            select = true,
          },
          ['<Tab>'] = function(fallback)
            if cmp.visible() then
              cmp.select_next_item()
            elseif luasnip.expand_or_jumpable() then
              luasnip.expand_or_jump()
            else
              fallback()
            end
          end,
          ['<S-Tab>'] = function(fallback)
            if cmp.visible() then
              cmp.select_prev_item()
            elseif luasnip.jumpable(-1) then
              luasnip.jump(-1)
            else
              fallback()
            end
          end,
        },
        sources = {
          { name = 'nvim_lsp' },
          { name = 'luasnip' },
        },
      }
    end
  },

  -- { 'https://gitlab.com/dweipert.de/rclone.nvim' },
  { dir = '~/Projects/rclone.nvim', cmd = 'Rclone' },


  -- Optional

  {
    'ryanoasis/vim-devicons',
    lazy = true,
    optional = true,
    config = function()
      -- @see https://github.com/ryanoasis/vim-devicons/issues/235#issuecomment-370112019
      vim.cmd([[let g:WebDevIconsUnicodeDecorateFileNodesExtensionSymbols['vue'] = '󰡄']])
    end
  },

  { 'nvim-tree/nvim-web-devicons', lazy = true, optional = true },
  { 'Xuyuanp/nerdtree-git-plugin', lazy = true, optional = true },
})
EOF