;;; plugin.fnl - plugin configurations

(import-macros {: bind! : hook!
                : use! : setup!
                : module-call!
                : module-fn!} :macros)

(fn [use]
  ;; Packer
  (use! :wbthomason/packer.nvim)

  ;; tangerine.nvim (auto fennel compile)
  (use! :udayvir-singh/tangerine.nvim)

  ;; Treesitter
  (use! :nvim-treesitter/nvim-treesitter
        :config #(setup! "nvim-treesitter.configs"
                         :ensure_installed :all
                         :sync_install false
                         :auto_install true
                         :highlight { :enable true
                                      :additional_vim_regex_highlighting false }
                         :indent { :enable true }))

  ;; nightfox.nvim (colorscheme)
  (use! :EdenEast/nightfox.nvim
        :after :nvim-treesitter
        :config #(vim.cmd.colorscheme :carbonfox))

  ;; Devicons
  (use! :kyazdani42/nvim-web-devicons)

  ;; lualine.nvim
  (use! :nvim-lualine/lualine.nvim
        :after [ :nightfox.nvim :nvim-web-devicons ]
        :config #(setup! :lualine
                         :options { :section_separators ""
                                    :component_separators "│" }
                         :sections { :lualine_x [
                           { 1 #(.. "recording @" (vim.fn.reg_recording))
                           :cond #(not= (# (vim.fn.reg_recording)) 0) }
                           :encoding
                           :fileformat
                           :filetype ]}))

  ;; bufferline.nvim
  (use! :akinsho/bufferline.nvim
        :after [ :nvim-web-devicons :nightfox.nvim ]
        :config #(setup! :bufferline
                         :options {
                           :always_show_bufferline false
                           :mode :tabs
                           :numbers :buffer-id
                           :show_buffer_close_icons false
                           :show_close_icon false }))

  ;; fzf (a fuzzy finder)
  (use! :ibhagwan/fzf-lua
        :config #(let [fzf (require :fzf-lua)]
                   (fzf.register_ui_select)
                   (bind! :n :<leader>fq fzf.quickfix)
                   (bind! :n :<leader>fr fzf.registers)
                   (bind! :n :<leader>fj fzf.jumps)
                   (bind! :n :<leader>fa fzf.marks)
                   (bind! :n :<leader>fh fzf.help_tags)
                   (bind! :n :<leader>g fzf.live_grep)
                   (bind! :n :<leader>fg fzf.live_grep)
                   (bind! :n :<leader>G fzf.grep)
                   (bind! :n :<leader>fG fzf.grep)
                   (bind! :n :<leader>b fzf.buffers)
                   (bind! :n :gb fzf.buffers)
                   (bind! :n :<leader>fu fzf.git_status)
                   (bind! :n :<leader>fm fzf.man_pages)
                   (bind! :n :<leader>fe fzf.diagnostics_document)
                   (bind! :n :<leader>fE fzf.diagnostics_workspace)
                   (bind! :n :<leader>d fzf.loclist)
                   (bind! :n :<leader>fp fzf.spell_suggest)
                   (bind! :n :<leader>i fzf.files)
                   (bind! :n :z= fzf.spell_suggest)
                   (bind! :n :<leader>ff (fn []
                                           (let [code (os.execute "git rev-parse --is-inside-work-tree >/dev/null 2>&1")]
                                             (if (= code 0)
                                                 (fzf.git_files)
                                                 (fzf.files)))))
                   (fn jump-or-open-terminal []
                     "If no terminal buffer exists, create one. Otherwise, open new one."
                     (var term_count 0)
                     (var last_id 0)
                     (var terms [ ])
                     (each [_ id (pairs (vim.api.nvim_list_bufs))]
                       (let [name (vim.api.nvim_buf_get_name id)]
                       (when (vim.startswith name "term://")
                       (table.insert terms name)
                       (set term_count (+ term_count 1))
                       (set last_id id))))
                     (if (= term_count 0)
                       (vim.cmd.terminal)
                         (= term_count 1)
                       (vim.cmd.buffer last_id)
                       (fzf.buffers { :query "term://" })))
                   (bind! :n :<leader>t jump-or-open-terminal)))

  ;; Nvim surround
  (use! :kylechui/nvim-surround
        :config #(setup! :nvim-surround))

  ;; Leap
  (use! :ggandor/leap.nvim
        :after :nvim-treesitter
        :config (fn []
                  ((. (require :leap) :add_default_mappings))
                  (bind! :o :z "<plug>(leap-forward-to)")
                  (bind! :o :Z "<plug>(leap-backward-to)")
                  (vim.api.nvim_set_hl 0 :LeapBackdrop { :link :Comment })))

  ;; Leap spooky (remote operations)
  (use! :ggandor/leap-spooky.nvim
        :after :leap.nvim
        :config #(setup! :leap-spooky))

  ;; Flit (leap for 'till' and 'forward' motions)
  (use! :ggandor/flit.nvim
        :after :leap.nvim
        :config #(setup! :flit))

  ;; Comment.nvim
  (use! :numToStr/Comment.nvim
        :config #(setup! :Comment))

  ;; nvim-find-other
  (use! "https://git.zander.im/Zander671/nvim-find-other.git"
        :config (fn [] (setup! :nvim-find-other
                               :c [ "h" "H" ]
                               :h [ "c" "C" "cpp" "cxx" "c++" "cc" ]
                               :cpp [ "hpp" "hxx" "h++" "hh" "h" "H" ]
                               :hpp [ "cpp" "cxx" "c++" "cc" ])
                        (let [find-other (require :nvim-find-other)]
                          (vim.api.nvim_create_user_command
                            "FindOtherFile"
                            find-other.find_other_current_buffer
                            {})
                          (bind! :n :go find-other.find_other_current_buffer))))

  ;; illuminate (same symbol highlight)
  (use! :RRethy/vim-illuminate
        :config (fn []
                   (module-call! :illuminate :configure)
                   { :providers [
                       "lsp"
                       "treesitter"
                       "ragex" ]
                     :modes_denylist [
                       :markdown
                       :text
                       :gitconfig
                       :gitignore ]
                     :delay 0 }
                   (hook! :FileType :lua #(vim.api.nvim_set_hl 0
                                                               :IlluminatedWordText
                                                               {}))))

  ;; vlime (lisp environment)
  (use! :vlime/vlime
        :config (fn []
                  (set vim.g.vlime_cl_impl :my_sbcl)
                  (set vim.g.vlime_address [ "127.0.0.1" 52842 ])
                  (vim.cmd "function! VlimeBuildServerCommandFor_my_sbcl(vlime_loader, vlime_eval)
                                return [ \"/usr/bin/sbcl\",
                                         \\ \"--load\", a:vlime_loader,
                                         \\ \"--eval\", \"(vlime:main :port 52842)\" ]
                            endfunction")))

  ;; Snippy
  (use! :dcampos/nvim-snippy
        :config #(let [map (require :snippy.mapping)]
                   (bind! [ :i :s ] :<tab> ((. map :next) :<tab>))
                   (bind! [ :i :s ] :<s-tab> (map.previous :<tab>))))

  ;; nvim-cmp (autocomplete)
  (use! :hrsh7th/nvim-cmp
        :requires [ :hrsh7th/cmp-buffer
                    :hrsh7th/cmp-path
                    :hrsh7th/cmp-cmdline
                    :hrsh7th/cmp-nvim-lsp
                    :HiPhish/nvim-cmp-vlime
                    { 1 :ray-x/cmp-treesitter
                        :after :nvim-cmp }
                    :dcampos/cmp-snippy ]
        :config (module-fn! :plugin.cmp :configure))

  ;; guess style from buffer
  (use! :NMAC427/guess-indent.nvim
        :config #(setup! :guess-indent :auto_cmd true))

  ;; lspconfig
  (use! :neovim/nvim-lspconfig
        :after [ :cmp-nvim-lsp
                 :fzf-lua ]
        :config (module-fn! :plugin.lsp :configure))

  ;; nvim-jdtls
  (use! :mfussenegger/nvim-jdtls
        :after :nvim-lspconfig
        :config (module-fn! :plugin.jdtls :configure))

  ;; Sync all packages on first launch
  (if _G.first_launch
      (module-call! :packer :sync)))