{ pkgs, ... }:
let
  customPlugins = {
    vim-zettel = pkgs.vimUtils.buildVimPlugin {
      name = "vim-zettel";
      src = pkgs.fetchFromGitHub {
        owner = "michal-h21";
        repo = "vim-zettel";
        rev = "929d90eec62e6f693c2702d2b6f76a93f2f1689d";
        sha256 = "1fzKmknfVlEYwqeXgbKITbb2/PJ023iJyMz6vak3qh4=";
      };
    };
    lsp-format = pkgs.vimUtils.buildVimPlugin {
      name = "lsp-format";
      src = pkgs.fetchFromGitHub {
        owner = "lukas-reineke";
        repo = "lsp-format.nvim";
        rev = "84e117b99bb2bc0d0c8122e2b256046f046f8aff";
        sha256 = "rs3NTZwWdsmBGXnrgUeVxUiNjbN/ULxJHifPYJD9mT4=";
      };
    };
    vim-tidal = pkgs.vimUtils.buildVimPluginFrom2Nix {
      name = "vim-tidal";
      src = pkgs.fetchgit {
        url = "https://github.com/tidalcycles/vim-tidal";
        # version 1.4.6
        rev = "52134979252757a5736ae09cb9fc6ae3cc04daef";
        sha256 = "c12v9+s/JspQ9Am291RFI7eg0UAeXGDvJ5lK+7ukOb0=";
      };
      dependencies = [ ];
    };
    tidal = pkgs.stdenv.mkDerivation {
      name = "tidal";
      src = pkgs.fetchgit {
        url = "https://github.com/tidalcycles/vim-tidal";
        # version 1.4.6
        rev = "52134979252757a5736ae09cb9fc6ae3cc04daef";
        sha256 = "c12v9+s/JspQ9Am291RFI7eg0UAeXGDvJ5lK+7ukOb0=";
      };
      preConfigure = ''
        mkdir -p $out/bin
        substituteInPlace Makefile \
            --replace '/usr/local' "$out" \
      '';
    };
  };

  my-python-packages = python-packages: with python-packages; [
    tasklib
    pynvim
    six
    python-lsp-server
    pylsp-mypy
    pylint
    black
    # other python packages you want
  ];
  python-with-my-packages = pkgs.python3.withPackages my-python-packages;
in
{
  #environment.variables.EDITOR = "nvim";
  #environment.shellAliases = {
  #  k = "cd ~/kitaab/vimwiki; vim -c :VimwikiIndex; cd $OLDPWD";
  #  kz = "cd ~/kitaab/vimwiki; vim -c :VimwikiIndex -c :ZettelNew; cd $OLDPWD";
  #};

  #environment.systemPackages = with customPlugins; [ tidal ];
  programs.neovim = {
    enable = true;

    extraConfig = ''
      set tabstop=2
      set showmatch
      set shiftwidth=2
      set noexpandtab
      set autoindent
      set undofile
      set signcolumn=auto:4

      " set foldmethod=indent		" fold based on indent
      set number
      set nocompatible
      set relativenumber
      set showtabline=2
      set noexpandtab
      set autowriteall
      syntax on
      set list lcs=tab:\|\ 
      filetype plugin on

      set termguicolors
      colorscheme ayu-mirage

      " set spell
      set spelllang=en_gb
      set ignorecase
      set smartcase
      set incsearch
      " if hidden is not set, TextEdit might fail.
      set hidden
      " Some servers have issues with backup files, see #649
      set nobackup
      set nowritebackup
      " Better display for messages
      set cmdheight=2
      " You will have bad experience for diagnostic messages when it's default 4000.
      set updatetime=300
      " don't give |ins-completion-menu| messages.
      set shortmess+=c
      " always show signcolumns
      set signcolumn=yes

      " window
      nmap <leader>wh :topleft	vnew<CR>
      nmap <leader>wl :botright vnew<CR>
      nmap <leader>wk :topleft	new<CR>
      nmap <leader>wj :botright new<CR>

      " tabs
      nmap <leader>rt :retab!<CR>
      vmap <leader>rt :retab!<CR>

      let mapleader = "\<Space>"
      let maplocalleader = ","

      " moving splits with vim movements.
      :tnoremap <A-h> <C-\><C-N><C-w>h
      :tnoremap <A-j> <C-\><C-N><C-w>j
      :tnoremap <A-k> <C-\><C-N><C-w>k
      :tnoremap <A-l> <C-\><C-N><C-w>l
      :inoremap <A-h> <C-\><C-N><C-w>h
      :inoremap <A-j> <C-\><C-N><C-w>j
      :inoremap <A-k> <C-\><C-N><C-w>k
      :inoremap <A-l> <C-\><C-N><C-w>l
      :nnoremap <A-h> <leader>h
      :nnoremap <A-j> <leader>j
      :nnoremap <A-k> <leader>k
      :nnoremap <A-l> <leader>l
      :nnoremap <F5> "=strftime("%Y-%m-%d %H:%M")<CR>
      :inoremap <F5> <C-R>=strftime("%Y-%m-%d %H:%M")<CR>
      :inoremap <F4> <C-R>=strftime("%H:%M")<CR>

      " tidal nvim terminal
      let g:tidal_target = "terminal"

      " telescope
      " Find files using Telescope command-line sugar.
      nnoremap <leader>ff <cmd>Telescope find_files<cr>
      nnoremap <leader>fg <cmd>Telescope live_grep<cr>
      nnoremap <leader>fb <cmd>Telescope buffers<cr>
      nnoremap <leader>fh <cmd>Telescope help_tags<cr>
      nnoremap <leader>ft <cmd>Telescope tags<cr>

      " exit normal mode in terminal
      :tnoremap <C-n> <C-\><C-n>

      " Sexp in Conjure (since it's fennel)
      " let g:sexp_filetypes = [ "fennel" ]

      let g:rainbow_active = 0
      autocmd BufReadPost,BufNewFile c,clj,cljs RainbowParenthesesToggleAll

      " general commands
      map <leader>t :NERDTreeToggle<CR>
      map <leader>s :w<CR>
      map <leader>q :wq<CR>
      map <leader>r :RainbowParenthesesToggleAll<CR>
      map <leader><BS> :noh<CR>
      nnoremap Y y$
      " center moving
      nnoremap n nzzzv
      nnoremap N Nzzzv
      nnoremap J mzJ'z
      " undo points
      inoremap , ,<c-g>u
      inoremap . .<c-g>u
      inoremap ? ?<c-g>u
      inoremap ! !<c-g>u
      inoremap ) )<c-g>u
      inoremap [ [<c-g>u
      inoremap ] ]<c-g>u
      inoremap { {<c-g>u
      inoremap ( (<c-g>u
      inoremap } }<c-g>u
      " moving text
      vnoremap J :m '>+1<CR>gv=gv
      vnoremap K :m '>-2<CR>gv=gv
      inoremap <c-j> <esc>:m .+1<CR>==
      inoremap <c-k> <esc>:m .-2<CR>==
      nnoremap <leader>j <esc>:m .+1<CR>==
      nnoremap <leader>k <esc>:m .-2<CR>==
      " Pasting 
      :map <leader>sy :!xclip -i<CR><CR>
      :vmap <leader>sy "*y
      :map <leader>sp :r!xclip -o<CR>

      " barbar
      nnoremap <silent> gT :BufferPrevious<CR>
      nnoremap <silent> gt :BufferNext<CR>
      nnoremap <silent> gj :BufferPick<CR>
      nnoremap <silent> gq :BufferClose<CR>

      " git
      nnoremap <leader>ga :G fetch --all
      nmap <leader>gs :G<CR>
      nmap <leader>gl :diffget //3<CR>
      nmap <leader>gh :diffget //2<CR>
      nmap <leader>gb :GBranches<CR>
      nnoremap <leader>gp :Git! push<CR>
      nnoremap <leader>gd :Gdiff<CR>
      nnoremap <leader>gc :G commit -v -q %:p<CR>

      " kitaab
      map <leader>zs :ZettelSearch<CR>
      map <leader>zo :ZettelOpen<CR>
      map <leader>zn :ZettelNew<CR>
      map <leader>zd :VimwikiDiary<CR>
      map <leader>zf :Telescope oldfiles only_cwd=true<CR>
      map <leader>wt :VimwikiMakeTomorrowDiaryNote
      map <leader>wd :VimwikiMakeYesterdayDiaryNote
      let g:vimwiki_list = [{ 'path': '~/kitaab/vimwiki', 'auto_tags': 1, 'auto_diary_index': 1, 'auto_generate_links': 1 }]

      let g:mapleader="\<Space>"
      let g:dashboard_default_executive = 'telescope'
      nmap <Leader>ss :<C-u>SessionSave<CR>
      nmap <Leader>sl :<C-u>SessionLoad<CR>
      nnoremap <silent> <Leader>fh :DashboardFindHistory<CR>
      nnoremap <silent> <Leader>ff :DashboardFindFile<CR>
      nnoremap <silent> <Leader>fm :DashboardJumpMark<CR>
      nnoremap <silent> <Leader>cn :DashboardNewFile<CR>
      autocmd FileType dashboard set showtabline=0 | autocmd WinLeave <buffer> set showtabline=2 

      " fzf
      " not sure we even use this
      let g:fzf_layout = { 'window': { 'width': 0.8, 'height': 0.8 } }

      " lsp commands
      nnoremap <leader>vd :lua vim.lsp.buf.definition()<CR>
      nnoremap <leader>vi :lua require('telescope.builtin').lsp_implementation()<CR>
      nnoremap <leader>vsh :lua vim.lsp.buf.signature_help()<CR>
      nnoremap <leader>vrr :lua require('telescope.builtin').lsp_references()<CR>
      nnoremap <leader>vrn :lua vim.lsp.buf.rename()<CR>
      nnoremap <leader>vh :lua vim.lsp.buf.hover()<CR>
      nnoremap <leader>vca :lua vim.lsp.buf.code_action()<CR>
      nnoremap <leader>vsd :lua rim.lsp.diagnostic.show_line_diagnostics(); vim.lsp.util.show_line_diagnostics()<CR>
      nnoremap <leader>vn :lua vim.lsp.diagnostic.goto_next()<CR>
      nnoremap <leader>vll :call LspLocationList()<CR>
      nnoremap <leader>va :lua require('telescope.builtin').lsp_code_actions(require('telescope.themes').get_cursor())<cr>

      " lua config 
      lua <<EOF
      vim.g.diagnostics_active = true
      function _G.toggle_diagnostics()
        if vim.g.diagnostics_active then
          vim.g.diagnostics_active = false
          vim.lsp.diagnostic.clear(0)
          vim.lsp.handlers["textDocument/publishDiagnostics"] = function() end
        else
          vim.g.diagnostics_active = true
          vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
            vim.lsp.diagnostic.on_publish_diagnostics, {
              virtual_text = true,
              signs = true,
              underline = true,
              update_in_insert = false,
            }
          )
        end
      end

      vim.api.nvim_set_keymap('n', '<leader>vt', ':call v:lua.toggle_diagnostics()<CR>',  {noremap = true, silent = true})

      -- autopairs
      require('nvim-autopairs').setup{}

      -- Setup nvim-cmp.
      local has_words_before = function()
        local line, col = unpack(vim.api.nvim_win_get_cursor(0))
        return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil
      end

      local luasnip = require("luasnip")
      local cmp = require('cmp')
      local cmp_autopairs = require('nvim-autopairs.completion.cmp')
      local t = function(str)
          return vim.api.nvim_replace_termcodes(str, true, true, true)
      end
      local check_back_space = function()
          local col = vim.fn.col(".") - 1
          return col == 0 or vim.fn.getline("."):sub(col, col):match("%s") ~= nil
      end
      cmp.setup {
          formatting = {
              format = function(entry, vim_item)
                  -- fancy icons and a name of kind
                  vim_item.kind = require("lspkind").presets.default[vim_item.kind] ..
                                      " " .. vim_item.kind
                  -- set a name for each source
                  vim_item.menu = ({
                      buffer = "[Buffer]",
                      nvim_lsp = "[LSP]",
                      cmp_tabnine = "[TabNine]",
                      look = "[Look]",
                      path = "[Path]",
                      spell = "[Spell]",
                      calc = "[Calc]",
                  })[entry.source.name]
                  return vim_item
              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.Insert,
                  select = true
              }),
              ["<Tab>"] = cmp.mapping(function(fallback)	
                if cmp.visible() then  
                    cmp.select_next_item()	
                elseif luasnip.expand_or_jumpable() then
                  luasnip.expand_or_jump()
                elseif has_words_before() then
                  cmp.complete()
                else
                    fallback()	
                end
              end, {"i", "s"}),
              ["<S-Tab>"] = cmp.mapping(function(fallback)	
                if cmp.visible() then  
                    cmp.select_prev_item()	
                elseif luasnip.jumpable(-1) then
                  luasnip.jump(-1)
                else	
                    fallback()	
                end  
              end, { "i", "s" }),
          },
          sources = {
              {name = 'buffer'}, {name = 'nvim_lsp'}, 
              {name = "look"}, {name = "path"},
              {name = 'cmp_tabnine'}, {name = "calc"}, {name = "spell"},
              {name = 'cmp-conjure'}
          },
          completion = {completeopt = 'menu,menuone,noinsert'}
      }
      cmp.event:on( 'confirm_done', cmp_autopairs.on_confirm_done({  map_char = { tex = ' ' } }))
      -- TabNine cmp
      local tabnine = require('cmp_tabnine.config')
      tabnine:setup({max_lines = 1000, max_num_results = 20, sort = true})

      -- Setup lspconfig
      require("lsp-format").setup {}

      local capabilities = require('cmp_nvim_lsp').update_capabilities(vim.lsp.protocol.make_client_capabilities())
      require('lspconfig').clojure_lsp.setup {on_attach = require "lsp-format".on_attach}
      require('lspconfig').rnix.setup {on_attach = require "lsp-format".on_attach}
      require('lspconfig').pylsp.setup {on_attach = require "lsp-format".on_attach,
        settings = {
          formatCommand = {"black"},
          pylsp = {
            configurationSources = { "flake8", "mypy" },
            plugins = {
              jedi_signature_help = {enabled = true},
              jedi_completion = { include_params = true },
              pylsp_mypy={ enabled = true },
              pycodestyle={
                enabled=true,
                ignore={'E501', 'E231'},
                maxLineLength=120,
              },
            },
          },
        },
      }
      require('lspconfig').terraform_lsp.setup {on_attach = require "lsp-format".on_attach}

      require('gitsigns').setup { sign_priority=80 }

      -- treesitter
      require('nvim-treesitter.configs').setup { ensure_installed={'nix', 'clojure', 'python', 'typescript'}}

      -- lualine
      require('nvim-gps').setup {}
      local gps = require('nvim-gps')
      require('lualine').setup {
        options = { theme = 'ayu' },
        sections = {
          lualine_c = {
              'filename', { gps.get_location, condition=gps.is_available },
          },
          lualine_y = {
            function()
              local msg = 'No Active Lsp'
              local buf_ft = vim.api.nvim_buf_get_option(0, 'filetype')
              local clients = vim.lsp.get_active_clients()
              if next(clients) == nil then
                return msg
              end
              for _, client in ipairs(clients) do
                local filetypes = client.config.filetypes
                if filetypes and vim.fn.index(filetypes, buf_ft) ~= -1 then
                  return client.name
                end
              end
              return msg
            end
            },
        }
      }

      -- nvim-lint
      require('lint').linters_by_ft = {
        markdown = {'vale'},
      }

      -- f_term
      local map = vim.api.nvim_set_keymap
      local opts = { noremap = true, silent = true }
      map('n', '<C-i>', '<CMD>lua require("FTerm").toggle()<CR>', opts)
      map('t', '<A-i>', '<C-\\><C-n><CMD>lua require("FTerm").toggle()<CR>', opts)
      EOF

    '';
    extraPackages = with pkgs // customPlugins; [
      # used to compile tree-sitter grammar
      tree-sitter
      python-with-my-packages
      nodejs
      clojure-lsp
      rnix-lsp
      terraform-lsp
      clj-kondo
      # installs different langauge servers for neovim-lsp
      # have a look on the link below to figure out the ones for your languages
      # https://github.com/neovim/nvim-lspconfig/blob/master/CONFIG.md
      nodePackages.typescript
      nodePackages.typescript-language-server
    ];
    plugins = with pkgs.vimPlugins // customPlugins; [
      # you can use plugins from the pkgs
      vim-which-key
      # general
      vim-nix
      fzf-vim
      vim-elixir
      emmet-vim
      nerdtree
      neovim-ayu
      goyo-vim
      csv-vim
      rainbow_parentheses-vim
      vim-surround
      vim-devicons
      nvim-web-devicons
      direnv-vim
      vim-peekaboo
      undotree
      telescope-nvim
      plenary-nvim
      lualine-nvim
      nvim-gps
      nvim-treesitter
      nvim-treesitter-context
      dashboard-nvim
      FTerm-nvim
      barbar-nvim

      # kitaab stuff
      vimwiki
      taskwiki
      vim-zettel

      # lsp stuff
      nvim-lint
      nvim-lspconfig
      nvim-cmp
      cmp-nvim-lsp
      cmp-treesitter
      nvim-lsp-ts-utils
      cmp-conjure
      cmp-buffer
      cmp-tabnine
      lspkind-nvim
      cmp-path
      cmp-spell
      nvim-autopairs
      cmp_luasnip
      luasnip
      lsp-format

      # git stuff
      vim-fugitive
      gitsigns-nvim
      fzf-checkout-vim

      # Clojure stuff
      conjure
      vim-sexp
      vim-sexp-mappings-for-regular-people

      # experimental 
      vim-tidal
      # vim-processing
    ];
    withPython3 = true;
    extraPython3Packages = pkgs: with pkgs; [ tasklib six ];
    vimAlias = true;
  };
}