;;; -*- lexical-binding: t; -*-
;;; Commentary:
;;; Code:

(require 'selector)
(require 'dash)

(setopt display-line-numbers-type 'relative)
(defvar bd/enable-line-numbers-in-hooks
  '(prog-mode-hook)
  "List of hook symbols to add `display-line-numbers-mode' to.")
(mapc
 (lambda (hook)
   (add-hook hook #'display-line-numbers-mode))
 bd/enable-line-numbers-in-hooks)

;; skr (skribe) is a scheme extension
(add-to-list 'auto-mode-alist '("\\.skr\\'" . scheme-mode))

(defun bd/beginning-of-visual-line-dwim (&optional n)
  (interactive "P")
  (let ((pt (point)))
    (back-to-indentation)
    (when (or n (eq pt (point)))
      (beginning-of-visual-line n))))

(define-minor-mode dwim-cursor-mode
  "Toggle dwim-cursor-mode."
  :init-value nil
  :group 'quality
  :light " SC"
  :keymap (list
           (cons (kbd "C-a") #'bd/beginning-of-visual-line-dwim)))

(use-package prog-mode
  :hook
  ((js-mode . (lambda ()
                (add-to-list 'prettify-symbols-alist '("function" . ?ƒ))))
   (prog-mode . (lambda ()
                  (font-lock-add-keywords
                   nil '(("\\<\\(FIX\\(ME\\)?\\|TODO\\)"
                          1 font-lock-warning-face t)))))
   (prog-mode . dwim-cursor-mode))
  :config
  (global-prettify-symbols-mode 1))

(use-package tramp
  :config
  (defun request-sudo ()
    "Uses TRAMP to edit current opened file as root."
    (interactive)
    (when buffer-file-name
      (find-alternate-file
       (concat "/sudo:root@localhost:"
               buffer-file-name))))
  (setopt tramp-remote-path
          (append tramp-remote-path
                  '(tramp-own-remote-path
                    "~/.guix-profile/bin" "~/.guix-profile/sbin"))))

(use-package vc
  :bind (("C-x v B" . #'bd/vc-browse-remote))
  :config
  (defun bd/vc-browse-remote (&optional current-line)
    "Open the repository's remote URL in the browser.
If CURRENT-LINE is non-nil, point to the current branch, file, and line.
Otherwise, open the repository's main page."
    (interactive "P")
    (let* ((remote-url (string-trim (vc-git--run-command-string nil "config" "--get" "remote.origin.url")))
           (branch (string-trim (vc-git--run-command-string nil "rev-parse" "--abbrev-ref" "HEAD")))
           (file (string-trim (file-relative-name (buffer-file-name) (vc-root-dir))))
           (line (line-number-at-pos)))
      (message "Opening remote on browser: %s" remote-url)
      (if (and remote-url (string-match "\\(?:git@\\|https://\\)\\([^:/]+\\)[:/]\\(.+?\\)\\(?:\\.git\\)?$" remote-url))
          (let ((host (match-string 1 remote-url))
                (path (match-string 2 remote-url)))
            ;; Convert SSH URLs to HTTPS (e.g., git@github.com:user/repo.git -> https://github.com/user/repo)
            (when (string-prefix-p "git@" host)
              (setq host (replace-regexp-in-string "^git@" "" host)))
            ;; Construct the appropriate URL based on CURRENT-LINE
            (browse-url
             (if current-line
                 (format "https://%s/%s/blob/%s/%s#L%d" host path branch file line)
               (format "https://%s/%s" host path))))
        (message "Could not determine repository URL")))))

(use-package hl-line
  :hook
  ((prog-mode . hl-line-mode)
   (text-mode . hl-line-mode)))

(use-package compile
  :demand t
  :hook ((compilation-filter . ansi-color-compilation-filter))
  :config
  (setopt compilation-always-kill t
          compilation-scroll-output 'first-error
          compilation-ask-about-save nil
          ansi-color-for-compilation-mode t)
  (defun bd/compile-dwim (f)
    (let ((default-directory (bd/get-directory-dwim)))
      (call-interactively f)))
  (add-to-list 'display-buffer-alist
               '((major-mode . compilation-mode)
                 (display-buffer-in-side-window)
                 (side . bottom)
                 (slot . -1)
                 (width . 0.15)
                 (post-command-select-window t)))

  (keymap-set prog-mode-map
              "C-," #'(lambda ()
                        (interactive)
                        (bd/compile-dwim #'recompile)))
  (keymap-set prog-mode-map
              "C-<" #'(lambda ()
                        (interactive)
                        (bd/compile-dwim #'compile))))

(use-package man
  :config
  (setopt Man-notify-method 'pushy))

(use-package eldoc
  :init
  (global-eldoc-mode))

(use-package flymake
  :bind (("C-c f f" . #'flymake-mode)
         :map   flymake-mode-map
         ("C-c f s" . #'flymake-start)
         ("C-c f n" . #'flymake-goto-next-error)
         ("C-c f p" . #'flymake-goto-prev-error)
         ("C-c f b" . #'flymake-show-buffer-diagnostics)
         ("C-c f d" . #'flymake-show-project-diagnostics))
  :config
  (setopt flymake-no-changes-timeout nil
          flymake-start-on-flymake-mode t
          flymake-start-on-save-buffer t
          flymake-proc-compilation-prevents-syntax-check t
          flymake-wrap-around nil
          flymake-show-diagnostics-at-end-of-line nil))

(require 'geiser)
(require 'geiser-mode)
(require 'geiser-guile)

(defcustom doc-dirs '()
  "Defines a buffer-local list of directories to find
documentation."
  :type 'list
  :group 'docs
  :safe 'listp
  :local t)

(defun bd/selector-doc (dir)
  "List all HTML files in a directory (recursive), and
display for opening with browser."
  (selector-source-create
   dir
   :candidates
   (-map
    (lambda (d) (selector-candidate-create (file-relative-name d dir) :value d))
    (directory-files-recursively dir ".html"))
   :actions
   (list (lambda (x) (eww-open-file x)))))

(defun bd/doc-finder ()
  (interactive)
  (unwind-protect
      (selector
       (append (-map (lambda (x) (bd/selector-doc x)) doc-dirs)
               (list (bd/selector-search))))))

(use-package eglot
  :defer t
  :hook ((c-mode . eglot-ensure)
         (c++-mode . eglot-ensure))
  :bind (:map eglot-mode-map
              ("C-c C-f" . eglot-format)
              ("C-c C-e" . eglot-rename))
  :config
  (setopt eglot-autoshutdown t
          eglot-prefer-plaintext t
          jsonrpc-event-hook nil)
  (add-to-list 'eglot-server-programs
               '(c-mode . ("ccls" "--init={\"clang\": {\"extraArgs\": [\"-std=c++20\"]}}"))))

(use-package cc-mode
  :hook (((c-mode c++-mode) . (lambda () (setq-local doc-dirs '("~/dc/cppreference"))))))

(use-package rainbow-mode
  :hook css-mode)

(use-package slime
  :defer t
  :commands slime
  :bind (:map slime-mode-map
              ("C-c C-k" . slime-eval-buffer))
  :config
  ;; more memory for ml libraries
  (setopt inferior-lisp-program "sbcl --dynamic-space-size 4096"))

(use-package paren
  :config
  (setopt show-paren-delay 0
          show-paren-style 'mixed
          show-paren-highlight-openparen t
          show-paren-context-when-offscreen t
          show-paren-when-point-in-periphery t
          show-paren-when-point-inside-paren t))


(use-package rainbow-delimiters
  :hook prog-mode)

(use-package paredit
  :hook (ielm-mode
         emacs-lisp-mode
         eshell-mode
         geiser-repl-mode
         lisp-mode
         scheme-mode
         lisp-interaction-mode)
  :config
  (defun bd/paredit-preserve-repl (f &rest args)
    "Wrapper around F (paredit-RET), discarding ARGS."
    (pcase (cons major-mode (eolp))
      ('(inferior-emacs-lisp-mode . t) (ielm-return))
      ('(eshell-mode . t) (eshell-send-input))
      ('(geiser-repl-mode . t) (geiser-repl-maybe-send))
      (_ (funcall f))))
  (advice-add #'paredit-RET :around #'bd/paredit-preserve-repl)
  (eldoc-add-command
   'paredit-backward-delete
   'paredit-close-round))


(provide 'bd--devel)
;;; bd--devel.el ends here