marleyvim/modules/nixvim/keymaps/default.nix

{
  lib,
  helpers,
  ...
}: let
  inherit
    (lib)
    map
    mapAttrsToList
    toUpper
    substring
    mapCartesianProduct
    toLower
    ;

  inherit (lib.marleyos.keys) mkKeymap mkKeymapWithOpts;
  inherit (helpers) mkRaw;
in {
  globals = {
    mapleader = " ";
    maplocalleader = "\\";
  };

  keymaps =
    # Disable Arrow Key Movement - - - - - - - - - - - - - - - - - - - - - - - -
    (
      map
      (d: {
        mode = [
          "i"
          "n"
        ];
        key = d;
        action = "<nop>";
      })
      [
        "<Down>"
        "<Up>"
        "<Left>"
        "<Right>"
      ]
    )
    # Better Up/Down - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ (
      mapAttrsToList
      (d: k: {
        mode = [
          "n"
          "x"
        ];
        key = k;
        action = "v:count == 0 ? 'g${k}' : '${k}'";
        options = {
          desc = d;
          expr = true;
          silent = true;
        };
      })
      {
        Down = "j";
        Up = "k";
      }
    )
    # Resize Windows - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ (
      mapAttrsToList
      (
        k: d: let
          s =
            if (d == "Increase")
            then "+"
            else "-";
        in {
          mode = ["n"];
          key = "<C-${k}>";
          action = "<cmd>resize ${s}4<cr>";
          options = {
            desc = "${d} Window Height";
          };
        }
      )
      {
        Up = "Increase";
        Down = "Decrease";
        Left = "Decrease";
        Right = "Increase";
      }
    )
    # Buffers - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ (
      mapAttrsToList
      (
        k: d: let
          # previous -> Prev
          prettyDir = (toUpper (substring 0 1 d)) + (substring 1 3 d);
        in {
          mode = ["n"];
          key = k;
          action = "<cmd>b${d}<cr>";
          options = {
            desc = "${prettyDir} Buffer";
          };
        }
      )
      {
        "<S-h>" = "previous";
        "<S-l>" = "next";
        "[b" = "previous";
        "]b" = "next";
      }
    )
    ++ [
      (mkKeymap ["n"] "<leader>bD" "<cmd>bd<cr>" "Delete Buffer and Window")
    ]
    # Clear Search/Diff Update/Redraw - - - - - - - - - - - - - - - - - - - - -
    ++ [
      (mkKeymap [
        "i"
        "n"
      ] "<esc>" "<cmd>noh<cr><esc>" "Escape and Clear hlsearch")
      (
        mkKeymap ["n"] "<leader>ur" "<cmd>nohlsearch<bar>diffupdate<bar>normal! <C-l><cr>"
        "Redraw / Clear hlsearch / Diff Update"
      )
    ]
    # Better n & N - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ (
      mapCartesianProduct
      (
        {
          m,
          d,
        }: let
          nn =
            if (d == "Next")
            then "Nn"
            else "nN";
          zv =
            if (m == "n")
            then ".'zv'"
            else "";
        in {
          mode = [m];
          key =
            if (d == "Next")
            then "n"
            else "N";
          action = "'${nn}'[v:searchforward]${zv}";
          options = {
            desc = "${d} Search Result";
            expr = true;
          };
        }
      )
      {
        m = [
          "n"
          "x"
          "o"
        ];
        d = [
          "Next"
          "Prev"
        ];
      }
    )
    # Undo Break-Points - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ (
      map
      (c: {
        mode = ["i"];
        key = c;
        action = "${c}<c-g>u";
      })
      [
        ","
        "."
        ";"
      ]
    )
    # Search Docs (keywordprog) - - - - - - - - - - - - - - - - - - - - - - - -
    # https://til.codeinthehole.com/posts/about-how-to-use-keywordprg-effectively/
    ++ [(mkKeymap ["n"] "<leader>K" "<cmd>norm! K<cr>" "Search <keywordprog> for word")]
    # Better Indenting - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ (
      map
      (c: {
        mode = ["v"];
        key = c;
        action = "${c}gv";
      })
      [
        "<"
        ">"
      ]
    )
    # Commenting - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ (
      mapAttrsToList
      (k: d: {
        mode = ["n"];
        key = "gc${k}";
        action = "${k}<esc>Vcx<esc><cmd>normal gcc<cr>fxa<bs>";
        options = {
          desc = "Add Comment ${d}";
        };
      })
      {
        o = "Below";
        O = "Above";
      }
    )
    # New File - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ [(mkKeymap ["n"] "<leader>fn" "<cmd>enew<cr>" "New File")]
    # Locations/Quickfixes - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ [
      (mkKeymap ["n"] "<leader>xl" "<cmd>lopen<cr>" "Location List")
      (mkKeymap ["n"] "<leader>xq" "<cmd>copen<cr>" "Quickfix list")
    ]
    ++ (
      mapAttrsToList
      (
        k: d: let
          cmd = substring 0 4 (toLower d);
        in {
          mode = ["n"];
          key = "${k}q";
          action = "<cmd>c${cmd}<cr>";
          options = {
            desc = "${d} Quickfix";
          };
        }
      )
      {
        "[" = "Previous";
        "]" = "Next";
      }
    )
    # Diagnostics - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ [
      (mkKeymap ["n"] "<leader>cd" (
        mkRaw
        # lua
        "function() vim.diagnostic.open_float() end"
      ) "Line Diagnostics")
    ]
    ++ (
      mapCartesianProduct
      (
        {
          dir,
          key,
        }: let
          sevs = {
            d = {
              key = "nil";
              desc = "Diagnostic";
            };
            e = {
              key = "vim.diagnostic.severity.ERROR";
              desc = "Error";
            };
            w = {
              key = "vim.diagnostic.severity.WARN";
              desc = "Warning";
            };
          };

          cmd = toLower dir;
          sev = sevs."${key}".key;
        in {
          mode = ["n"];
          key = "${
            if (dir == "Next")
            then "]"
            else "["
          }${key}";
          action.__raw =
            # lua
            "function() vim.diagnostic.goto_${cmd}({ severity = ${sev} }) end";
          options = {
            desc = "${dir} ${sevs."${key}".desc}";
          };
        }
      )
      {
        dir = [
          "Next"
          "Prev"
        ];
        key = [
          "d"
          "e"
          "w"
        ];
      }
    )
    # Quit - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ [(mkKeymap ["n"] "<leader>qq" "<cmd>qa<cr>" "Quit All")]
    # Inspect - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ [(mkKeymap ["n"] "<leader>ui" (mkRaw "vim.show_pos") "Inspect Position")]
    # Window Management - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ [
      (mkKeymapWithOpts ["n"] "<leader>w" "<C-w>" "Windows" {remap = true;})
      (mkKeymapWithOpts ["n"] "<leader>-" "<C-w>s" "Split Window Below" {remap = true;})
      (mkKeymapWithOpts ["n"] "<leader>|" "<C-w>v" "Split Window Right" {remap = true;})
      (mkKeymapWithOpts ["n"] "<leader>wd" "<C-w>c" "Delete Window" {remap = true;})
    ]
    # Tab Management - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    ++ (
      mapAttrsToList
      (k: a: {
        mode = ["n"];
        key = "<leader><tab>${k}";
        action = "<cmd>tab${toLower a}<cr>";
        options = {
          desc =
            if (a == "Only")
            then "Close Other Tabs"
            else "${a} Tab";
        };
      })
      {
        l = "Last";
        o = "Only";
        f = "First";
        "<Tab>" = "New";
        "]" = "Next";
        d = "Close";
        "[" = "Previous";
      }
    );
}