;; -*- lexical-binding: t; -*-
(require 'package)
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t)
(package-initialize)

(if (string= system-type "darwin")
    (set-frame-font "Berkeley Mono 18" nil t)
  (set-frame-font "BerkeleyMono 14" nil t))

(load-theme 'deeper-blue)

(when (string= system-type "darwin")
  (setq manual-program "gman")
  (setq dired-use-ls-dired nil)
  (setq mac-command-modifier 'control))

(keymap-global-set "M-o"     #'other-window)
(keymap-global-set "M-i"     #'imenu)
(keymap-global-set "C-c c"   #'compile)
(keymap-global-set "M-0"     #'delete-window)
(keymap-global-set "M-1"     #'delete-other-windows)
(keymap-global-set "M-2"     #'split-window-below)
(keymap-global-set "M-3"     #'split-window-right)

(keymap-global-set "C-x C-b" #'ibuffer)

(keymap-global-set "C-c e i" #'hgh/edit-init-file)
(keymap-global-set "C-c e l" #'hgh/load-init-file)
(keymap-global-set "C-,"     #'duplicate-dwim)

(keymap-set help-map "h" #'eldoc)
;; (keymap-global-set "C-h h"   #'eldoc)

(require 'grep)
(grep-apply-setting 'grep-command "rg --no-heading")
(grep-apply-setting 'grep-find-command nil)

(defun hgh/emacs-directory (path)
  (concat user-emacs-directory path))

(setq
 org-default-notes-file "~/inbox.org"
 org-todo-keywords '((sequence "TODO" "INPROGRESS" "DONE"))
 custom-file (hgh/emacs-directory "custom.el")
 make-backup-files nil
 dired-dwim-target t
 manual-program "gman"
 speedbar-window-default-width 25
 speedbar-window-max-width 25
 duplicate-line-final-position -1
 duplicate-region-final-position -1)

(setq project-switch-commands '((project-find-file "Find file" "f")
                                (project-find-dir "Find dir" "d")
                                (project-dired "Dired" "D")
                                (project-find-regexp "ripgrep" "g")
                                (magit-project-status "Magit" "m")))

(when (file-directory-p (hgh/emacs-directory "work"))
  (load-file (hgh/emacs-directory "work/work.el"))
  (add-to-list 'load-path (hgh/emacs-directory "work")))

(load-file (hgh/emacs-directory "utils.el"))

(setopt
 use-short-answers t
 use-dialog-box nil
 use-package-enable-imenu-support t
 display-line-numbers-type 'relative)

(electric-pair-mode 1)
(fido-mode 1)
(global-completion-preview-mode 1)
(tab-bar-mode -1)
(tool-bar-mode -1)
(scroll-bar-mode -1)
(global-hl-line-mode 1)
(global-eldoc-mode 1)
(global-display-line-numbers-mode 1)
(global-auto-revert-mode 1)

(defun hgh/untabify-buffer ()
  (interactive)
  (untabify (region-beginning) (region-end) nil))

(add-hook 'compilation-filter-hook 'ansi-color-compilation-filter)
(add-hook 'before-save-hook 'delete-trailing-whitespace)
(add-hook 'before-save-hook 'hgh/untabify-buffer)


(if (file-exists-p custom-file)
    (load-file custom-file))

(require 'use-package)
(setq use-package-always-ensure t)

(use-package exec-path-from-shell
  :custom
  (exec-path-from-shell-variables '("PATH" "MANPATH" "AWS_ACCESS_KEY_ID" "AWS_SECRET_ACCESS_KEY" "AWS_SESSION_TOKEN"))
  :demand t)

(exec-path-from-shell-initialize)

(use-package diminish
  :demand t
  :config
  (diminish 'eldoc-mode)
  (diminish 'completion-preview-mode))

(setq treesit-enabled-modes t)

(defun hgh/dired-this-directory ()
  (interactive)
  (dired (file-name-directory buffer-file-name)))

(use-package evil
  :custom
  (evil-want-C-u-scroll t)
  (evil-want-Y-yank-to-eol t)
  (evil-move-beyond-eol t)
  (evil-undo-system 'undo-tree)
  :ensure t
  :init
  (setq evil-want-integration t) ;; This is optional since it's already set to t by default.
  (setq evil-want-keybinding nil)

  (defvar hgh/evil-eglot-prefix-map
    (let ((map (make-sparse-keymap)))
      (define-key map "a" 'eglot-code-actions)
      (define-key map "r" 'eglot-rename)
      map))
  :config
  (evil-set-leader nil (kbd "SPC"))
  (evil-mode 1)

  (evil-global-set-key 'normal (kbd "M-.") #'xref-find-definitions)

  (evil-global-set-key 'normal (kbd "<leader>ff") #'find-file)
  (evil-global-set-key 'normal (kbd "<leader>fs") #'save-buffer)
  (evil-global-set-key 'normal (kbd "<leader>fb") #'switch-to-buffer)
  (evil-global-set-key 'normal (kbd "<leader>gs") #'magit)
  (evil-global-set-key 'normal (kbd "<leader>gg") #'magit)
  (evil-global-set-key 'normal (kbd "<leader>rw") #'hgh/dired-this-directory)
  (evil-global-set-key 'normal (kbd "<leader>h")  #'help-command)

  (evil-global-set-key 'normal (kbd "<leader>w")  evil-window-map)
  (evil-global-set-key 'normal (kbd "<leader>p")  project-prefix-map)
  (evil-global-set-key 'visual (kbd "TAB")        #'indent-region)
  (evil-global-set-key 'normal (kbd "]d")         #'flymake-goto-next-error)
  (evil-global-set-key 'normal (kbd "[d")         #'flymake-goto-prev-error)
  (evil-define-key 'normal eglot-mode-map (kbd "<leader>l") hgh/evil-eglot-prefix-map)
  (evil-global-set-key 'normal (kbd "[d")         #'flymake-goto-prev-error))

(use-package evil-collection
  :diminish 'evil-collection-unimpaired-mode
  :after evil
  :ensure t
  :custom
  (evil-collection-key-blacklist '("SPC"))
  :config
  (evil-collection-init)

  (require 'compile)
  (keymap-set compilation-minor-mode-map "SPC" nil)
  (keymap-set compilation-mode-map "SPC" nil)
  (keymap-set help-mode-map "SPC" nil))

(use-package evil-surround
  :ensure t
  :config
  (global-evil-surround-mode 1))

(use-package move-text
  :bind (("M-<down>" . 'move-text-down)
         ("M-j"      . 'move-text-down)
         ("M-<up>"   . 'move-text-up)
         ("M-k"      . 'move-text-up)))

(use-package jai-mode
  :vc (:url "https://github.com/valignatev/jai-mode.git"
            :rev :newest))

(use-package magit
  :bind ("C-x g" . magit-status)
  :config
  (when (require 'evil nil 'noerror)
    (evil-global-set-key 'normal (kbd "<leader>gg") #'magit-status)))

(use-package multiple-cursors
  :custom
  (mc/always-run-for-all t)
  :bind (("C->"     . mc/mark-next-like-this)
         ("C-<"     . mc/mark-previous-like-this)
         ("C-c C-<" . mc/mark-all-like-this)
         ("C-c C->" . mc/mark-lines)))

(use-package cape
  :hook ((completion-at-point-functions . cape-dabbrev)
         (completion-at-point-functions . cape-file)))

(use-package dumber-jump
  :init
  (add-hook 'xref-backend-functions #'dumber-jump-xref-activate)
  :config
  (push
   '(:language "jai" :type "function"
               :supports ("ag" "grep" "rg" "git-grep")
               :regex "\\bJJJ\\s*::"
               :tests ("test ::"))
   dumber-jump-find-rules)
  (push
   '(:language "jai" :type "variable"
               :supports ("ag" "grep" "rg" "git-grep")
               :regex "\\bJJJ\\s*(:|:\\s*=|::)"
               :tests ("test: Type" "test : Type = Val" "test :: Val"))
   dumber-jump-find-rules)
  (push
   '(:language "jai" :type "type"
               :supports ("ag" "grep" "rg" "git-grep")
               :regex "\\bJJJ\\s*::"
               :tests ("test ::"))
   dumber-jump-find-rules))

(use-package eglot
  :custom
  (eglot-documentation-renderer 'markdown-ts-view-mode)
  (eglot-code-action-indications nil)
  :bind (("C-c l a" . eglot-code-actions))
  :hook ((jai-mode . eglot-ensure)
         (dart-mode . eglot-ensure)
         (terraform-mode . eglot-ensure)
         (typescript-ts-mode . eglot-ensure)
         (tsx-ts-mode . eglot-ensure)
         (elixir-ts-mode . eglot-ensure))

  :config
  (push `(jai-mode "jails" "-jai_path" ,(concat (getenv "HOME") "/.local/jai/")) eglot-server-programs)
  (push '(sql-mode "postgres-language-server" "lsp-proxy") eglot-server-programs)
  (setf (alist-get '(elixir-mode elixir-ts-mode heex-ts-mode)
                   eglot-server-programs
                   nil nil #'equal)
        '("/Users/grant/programming/thirdparty/elixir-ls/build/language_server.sh" "--stdio"))
  )

(use-package yaml-mode)

(use-package fish-mode)

(use-package yasnippet
  :diminish yas-minor-mode
  :config
  (yas-global-mode 1))

(use-package yasnippet-snippets)

(use-package undo-tree
  :diminish undo-tree-mode
  :custom
  (undo-tree-history-directory-alist `(,(cons "." (concat (file-name-directory user-init-file) "undo-tree"))))
  :config
  (global-undo-tree-mode 1))

(use-package dart-mode)

(use-package flymake
  :custom
  (flymake-wrap-around t))

(use-package markdown-ts-mode
  :mode ("\\.md\\'" . markdown-ts-mode)
  :defer t)

(use-package org-roam
  :custom
  (org-roam-directory (file-truename "~/org-roam"))
  :init
  (defvar hgh/org-roam-node-map
    (define-keymap
      "o" #'org-roam-node-find
      "f" #'org-roam-node-find
      "i" #'org-roam-node-insert
      "c" #'org-roam-capture)
    "Keymap for capturing new org roam nodes.")
  (evil-global-set-key 'normal (kbd "<leader>o") hgh/org-roam-node-map)
  :config
  (condition-case err
      (make-directory "~/org-roam")
    (file-already-exists nil))
  (org-roam-db-autosync-mode))

(use-package ghostel
  :custom
  (ghostel-module-auto-install "download"))

(use-package terraform-mode
  :init
  (setf (alist-get "\\.tfstate\\'" auto-mode-alist nil nil #'string=) 'json-ts-mode))

(use-package apheleia
  :diminish apheleia-mode
  :config
  (dolist (pair apheleia-formatters)
    (let ((formatter (symbol-name (car pair))))
      (when (string-prefix-p "prettier" formatter)
        (setf (alist-get (car pair) apheleia-formatters)
              '("npx" "prettier" "--stdin-filepath" filepath)))))
  (apheleia-global-mode 1))


(use-package mise
  :diminish mise-mode
  :config
  (global-mise-mode 1))

(use-package dotenv-mode)