;;; init-lang.el -*- lexical-binding: t; -*-

;;; Syntax highlighting: tree-sitter

(setopt treesit-enabled-modes t

        treesit-auto-install-grammar 'always

        treesit-font-lock-level 4)      ; 4 = everything (calls, properties, operators)

;;; LSP: eglot

(defvar my/lsp-servers

  '(((typescript-ts-mode tsx-ts-mode js-ts-mode) "vtsls" "--stdio")

    (rust-ts-mode       "rust-analyzer")

    ((go-ts-mode go-mod-ts-mode) "gopls")

    ((c-ts-mode c++-ts-mode) "clangd")

    (lua-ts-mode        "lua-language-server")

    ;;(css-ts-mode        "vscode-css-language-server" "--stdio")

    ((mhtml-ts-mode html-ts-mode) "vscode-html-language-server" "--stdio")

    (json-ts-mode       "vscode-json-language-server" "--stdio")

    (python-ts-mode     "pylsp")

    (python-ts-mode     "basedpyright-langserver" "--stdio") ; wins if both installed

    (bash-ts-mode       "bash-language-server" "start")

    (scheme-mode        "guile-lsp-server"))

  "Alist of (MODES SERVER ARGS...) used to auto-start eglot.")

(use-package eglot

  :ensure nil

  :defer t

  :custom

  (eglot-autoshutdown t)                ; kill server when last buffer closes

  (eglot-events-buffer-config '(:size 0 :format full)) ; no event logging

  (eglot-extend-to-xref t)              ; stay in eglot when jumping into deps

  :config

  (dolist (entry my/lsp-servers)

    (when (executable-find (cadr entry))

      (add-to-list 'eglot-server-programs

                   (cons (ensure-list (car entry)) (cdr entry))))))

;; Hooks go in now so eglot itself only loads when a matching buffer opens

(dolist (entry my/lsp-servers)

  (when (executable-find (cadr entry))

    (dolist (mode (ensure-list (car entry)))

      (add-hook (intern (format "%s-hook" mode)) #'eglot-ensure))))

;;; Indentation per language

(defvar my/indent-settings

  '(((typescript-ts-mode tsx-ts-mode) 2 nil typescript-ts-mode-indent-offset)

    (js-ts-mode                       2 nil js-indent-level)

    (rust-ts-mode                     4 nil rust-ts-mode-indent-offset)

    (go-ts-mode                       4 t   go-ts-mode-indent-offset)

    ((c-ts-mode c++-ts-mode)          4 nil c-ts-mode-indent-offset)

    (lua-ts-mode                      2 nil lua-ts-indent-offset)

    (css-ts-mode                      2 nil css-indent-offset)

    ((mhtml-ts-mode html-ts-mode)     2 nil html-ts-mode-indent-offset)

    (json-ts-mode                     2 nil json-ts-mode-indent-offset)

    (python-ts-mode                   4 nil python-indent-offset)

    (bash-ts-mode                     2 nil sh-basic-offset)

    ((emacs-lisp-mode scheme-mode)    2 nil nil))

  "List of (MODES WIDTH TABS OFFSET-VAR) applied in each mode's hook.")

(dolist (entry my/indent-settings)

  (pcase-let ((`(,modes ,width ,tabs ,var) entry))

    (dolist (mode (ensure-list modes))

      (add-hook (intern (format "%s-hook" mode))

                (lambda ()

                  (setq-local tab-width width

                              indent-tabs-mode tabs)

                  (when var (set (make-local-variable var) width)))))))

;;; Format on save

;; Uses eglot when the server can format, else re-indents lisp buffers.  Off for a

;; buffer with SPC c F, or per project via .dir-locals.el:

(defvar my/format-on-save t

  "Non-nil formats eglot-managed buffers before saving.")

(put 'my/format-on-save 'safe-local-variable #'booleanp)

(defvar my/reindent-modes '(emacs-lisp-mode scheme-mode)

  "Modes without an LSP formatter that format by re-indenting the buffer.")

(defun my/format-buffer ()

  "Format with eglot if the server can, else re-indent in `my/reindent-modes'."

  (interactive)

  (cond ((and (fboundp 'eglot-managed-p) (eglot-managed-p)

              (eglot-server-capable :documentFormattingProvider))

         (eglot-format-buffer))

        ((apply #'derived-mode-p my/reindent-modes)

         (indent-region (point-min) (point-max)))

        ((called-interactively-p 'any)

         (message "No formatter for %s" major-mode))))

(defun my/format-on-save ()

  (when my/format-on-save (my/format-buffer)))

(add-hook 'before-save-hook #'my/format-on-save)

(defun my/toggle-format-on-save ()

  "Toggle format on save for the current buffer."

  (interactive)

  (setq-local my/format-on-save (not my/format-on-save))

  (message "Format on save %s" (if my/format-on-save "on" "off")))

;; Diagnostics

(setq flymake-show-diagnostics-at-end-of-line 'short)

(with-eval-after-load 'general

  (my/leader

    "c"   '(:ignore t :wk "code")

    "ca"  '(eglot-code-actions :wk "actions")

    "cr"  '(eglot-rename :wk "rename")

    "cf"  '(my/format-buffer :wk "format")

    "cF"  '(my/toggle-format-on-save :wk "toggle format on save")

    "cd"  '(xref-find-definitions :wk "definition")

    "cR"  '(xref-find-references :wk "references")

    "ci"  '(eglot-find-implementation :wk "implementation")

    "ct"  '(eglot-find-typeDefinition :wk "type def")

    "ce"  '(flymake-show-buffer-diagnostics :wk "errors")

    "cE"  '(flymake-show-project-diagnostics :wk "project errors")

    "cn"  '(flymake-goto-next-error :wk "next error")

    "cp"  '(flymake-goto-prev-error :wk "prev error")

    "cl"  '(eglot :wk "start lsp")

    "cL"  '(eglot-shutdown :wk "stop lsp")))

(provide 'init-lang)