(use-package emacs
  :ensure nil
  :demand t
  :bind
  (("C-x i" . insert-char)
   ("M-z"   . zap-to-char)
   ("<f10>"  . toggle-input-method))
  :config
  ;; Sentence size
  (setq sentence-end-double-space nil)

  ;; Keyboard things
  (setq default-input-method "cyrillic-yawerty")
  (setq default-transient-input-method "cyrillic-yawerty"))

;; spell check
(use-package text-mode
  :ensure nil
  :hook
  (text-mode . flyspell-mode))

;; Tab settings
(use-package emacs
  :config
  (setq tab-always-indent 'complete)
  (setq tab-first-completion 'word-or-paren-or-punct)
  (setq-default tab-width 4
                indent-tabs-mode nil))

(use-package yasnippet
  :ensure t
  :hook ((LaTeX-mode . yas-minor-mode)
         (post-self-insert . my/yas-try-expanding-auto-snippets))
  :config
  (setq yas-snippet-dirs '("~/.emacs.d/snippets"))
  (yas-global-mode t)
  (use-package warnings
    :config
    (cl-pushnew '(yasnippet backquote-change)
                warning-suppress-types
                :test 'equal))

  (setq yas-triggers-in-field t)

  ;; Function that tries to autoexpand YaSnippets
  ;; The double quoting is NOT a typo!
  (defun my/yas-try-expanding-auto-snippets ()
    (when (and (boundp 'yas-minor-mode) yas-minor-mode)
      (let ((yas-buffer-local-condition ''(require-snippet-condition . auto)))
        (yas-expand)))))

(use-package yasnippet-capf
  :ensure t
  :after cape
  :config
  (add-to-list 'completion-at-point-functions #'yasnippet-capf))

(use-package cdlatex
  :hook ((cdlatex-tab . yas-expand)
         (cdlatex-tab . cdlatex-in-yas-field))
  :config
  (use-package yasnippet
    :bind (:map yas-keymap
           ("<tab>" . yas-next-field-or-cdlatex)
           ("TAB" . yas-next-field-or-cdlatex))
    :config
    (defun cdlatex-in-yas-field ()
      ;; Check if we're at the end of the Yas field
      (when-let* ((_ (overlayp yas--active-field-overlay))
                  (end (overlay-end yas--active-field-overlay)))
        (if (>= (point) end)
            ;; Call yas-next-field if cdlatex can't expand here
            (let ((s (thing-at-point 'sexp)))
              (unless (and s (assoc (substring-no-properties s)
                                    cdlatex-command-alist-comb))
                (yas-next-field-or-maybe-expand)
                t))
          ;; otherwise expand and jump to the correct location
          (let (cdlatex-tab-hook minp)
            (setq minp
                  (min (save-excursion (cdlatex-tab)
                                       (point))
                       (overlay-end yas--active-field-overlay)))
            (goto-char minp) t))))

    (defun yas-next-field-or-cdlatex nil
      (interactive)
      "Jump to the next Yas field correctly with cdlatex active."
      (if
          (or (bound-and-true-p cdlatex-mode)
              (bound-and-true-p org-cdlatex-mode))
          (cdlatex-tab)
        (yas-next-field-or-maybe-expand)))))

(use-package denote
  :ensure t
  :config
  (require 'bard-writing)
  (setq denote-directory "~/Notes/denote/")
  (setq denote-buffer-name-prefix "[Note] "
        denote-rename-buffer-format "%t %b")
  (setq denote-known-keywords
        '("emacs"
          "linux"
          "programming"
          "org"
          "school"
          "language"
          "history"
          "biology"
          ))

  (setq denote-templates
        '((default . "Related to — ")
          (todo . bard/denote-todo-template)))

  (setq denote-save-buffers t)
  (setq denote-prompts '(title keywords))
  (setq denote-sort-dired-extra-prompts nil)
  (setq denote-sort-dired-default-sort-component 'identifier)
  (setq denote-sort-dired-default-reverse-sort nil)

  ;; backlinks sidebar
  (setq denote-backlinks-display-buffer-action
        '((display-buffer-in-direction)
          (direction . right)
          (window-width . 0.33)
          (window-height . fit-window-to-buffer)
          (dedicated . t)))

  (denote-rename-buffer-mode 1)

  (require 'bard-writing)

  :hook
  (dired-mode . denote-dired-mode)
  :bind
  (("C-c n n" . denote)
   ("C-c n d" . denote-sort-dired)
   ("C-c n r" . denote-rename-file-using-front-matter)
   ("C-c n k" . denote-rename-file-keywords)
   ("C-c n I" . denote-add-links)
   ("C-c n b" . bard/consult-buffer-notes)   ; notes buffer
   ("C-c n B" . bard/ibuffer-notes)          ; notes buffer but more
   (:map dired-mode-map ; rename files in dired with denote structure
         ("r" . denote-rename-file))))

(use-package denote-org
  :ensure t
  )

(use-package denote-silo
  :ensure t
  :config
  (setq denote-silo-directories '("~/Notes/denote"
                                  "~/Notes/Old Notes/")))

(use-package denote-sequence
  :ensure t
  :config
  (require 'bard-writing)
  :bind
  ("C-c n N" . denote-sequence)
  ("C-c n D" . denote-sequence-dired))

(use-package denote-journal
  :ensure t
  :bind
  ("C-c n j" . denote-journal-new-or-existing-entry)
  :config
  (setq denote-journal-directory "~/Notes/denote/journal/")

  (setq denote-journal-title-format "Daily Tasks and Notes"))

(use-package denote-roam
  :ensure nil
  :load-path "~/Code/denote-roam/"
  :bind
  ("C-c n i" . denote-roam-insert-or-create-node)  ; node insert
  ("C-c n o" . denote-roam-find-or-create-node)    ; node open
  :custom
  (denote-roam-include-journal nil)
  (denote-roam-directory "~/Notes/denote")
  :config
  (denote-roam-mode t))

(use-package org-roam
  :ensure t
  :custom
  (org-roam-directory (file-truename "~/Notes/denote"))
  :bind (("C-c n l" . org-roam-buffer-toggle))
  :config
  (cl-defmethod org-roam-node-type ((node org-roam-node))
    "Return the TYPE of NODE based on its filetags."
    (let ((tags (org-roam-node-tags node)))
      (cond
       ((member "bib"   tags) "reference")
       ((member "topic" tags) "topic")
       (tags                  "main")
       (t                     "root"))))

  (setq org-roam-node-display-template
        (concat "${type:10} ${title:*} " (propertize "${tags:*}" 'face 'org-tag)))

  (setq org-roam-db-node-include-function
        (lambda ()
          (not (member "ATTACH" (org-get-tags)))))

  (org-roam-db-autosync-mode 1))

(use-package org-roam-ui
  :ensure t
  :bind
  ("C-c n u" . org-roam-ui-open)
  :custom
  (org-roam-ui-open-on-start nil))

;; Center line scrolling for focused writing
(use-package emacs
  :config
  (define-minor-mode bard/scroll-center-cursor-mode
    "Toggle centered cursor scrolling behavior."
    :init-value nil
    :lighter " S="
    :global nil
    (if bard/scroll-center-cursor-mode
        (setq-local scroll-margin (* (frame-height) 2)
                    scroll-conservatively 0
                    maximum-scroll-margin 0.5)
      (dolist (local '(scroll-preserve-screen-position
                       scroll-conservatively
                       maximum-scroll-margin
                       scroll-margin))
        (kill-local-variable `,local))))
  (defun bard/cursor-centered-p ()
    "Check if `bard/scroll-center-cursor-mode` is currently active."
    (bound-and-true-p bard/scroll-center-cursor-mode))
  :bind
  (("C-c L" . bard/scroll-center-cursor-mode)))

(use-package olivetti
  :ensure t
  :config
  (setq olivetti-minimum-body-width 90)
  (setq olivetti-recall-visual-line-mode-entry-state t)
  :hook
  ((olivetti-mode-on . (lambda () (olivetti-set-width 90)))
   ))

;; narrowing and focus mode
(use-package logos
  :ensure t
  :config
  (defun logos-reveal-entry ()
    "Reveal Org or Outline entry."
    (cond
     ((and (eq major-mode 'org-mode)
           (org-at-heading-p))
      (org-show-subtree))
     ((or (eq major-mode 'outline-mode)
          (bound-and-true-p outline-minor-mode))
      (outline-show-subtree))))

  (setq logos-outlines-are-pages t)

  (setq logos-outline-regexp-alist
        `((emacs-lisp-mode . "^;;;+ ")
          (org-mode . "^\\* +")
          (t . ,(or outline-regexp logos--page-delimiter))))

  (setq-default logos-hide-cursor nil
                logos-hide-mode-line nil
                logos-hide-header-line t
                logos-hide-buffer-boundaries t
                logos-hide-fringe t
                logos-variable-pitch t
                logos-olivetti t)

  (defun bard/logos--recenter-top ()
    "Use `recenter' to reposition the view at the top."
    (unless (derived-mode-p 'prog-mode)
      (recenter 1))) ; Use 0 for the absolute top
  :hook
  ((logos-page-motion . bard/logos--recenter-top))
  :hook
  ((org-mode . logos-focus-mode)
   (markdown-mode . logos-focus-mode))
  :bind
  (("M-]" . logos-forward-page-dwim)
   ("M-[" . logos-backward-page-dwim)
   ("<f9>" . logos-focus-mode)
   ("C-x n n" . logos-narrow-dwim)))

(use-package typst-ts-mode
  :ensure t
  :hook (typst-ts-mode . eglot-ensure)
  :config
  (add-to-list 'treesit-language-source-alist
               '(typst "https://github.com/uben0/tree-sitter-typst")))

;; Tinymist for LSP
(with-eval-after-load 'eglot
  (add-to-list 'eglot-server-programs
               '(typst-ts-mode "tinymist")))


(use-package typst-preview
  :ensure t
  :init
  (setq typst-preview-autostart t)
  (setq typst-preview-open-browser-automatically t)
  :custom
  (setq typst-preview-browser "zen"
        typst-preview-invert-colors "never"
        typst-preview-executable "tinymist"
        typst-preview-partial-rendering t)
  ;; :config
  ;; (define-key typst-preview-mode-map (kbd "C-c C-j") 'typst-preview-send-position)
  )

(use-package citar
  :ensure t
  :bind
  ("C-c n c" . citar-open)
  :config
  (setq citar-bibliography '("~/Documents/bib/references.bib"))
  (setq org-cite-global-bibliography citar-bibliography
        org-cite-insert-processor 'citar
        org-cite-follow-processor 'citar
        org-cite-activate-processor 'citar)

  (setq citar-notes-paths '("~/Notes/denote"))
  (setq citar-library-paths '("~/Documents/Research Articles/"))
  ;; (setq citar-file-open-functions 'find-file)
  :hook
  (org-mode . citar-capf-setup)
  :bind (("C-c i" . citar-insert-citation)))

(use-package citar-denote
  :ensure t
  :config
  (citar-denote-mode t)
  )

(use-package citar-embark
  :ensure t
  )

(defun bard/create-bib-entry ()
  (interactive)
  (let* ((default-file (when (derived-mode-p 'dired-mode)
                         (dired-get-file-for-visit)))
         (file (read-file-name "PDF: "
                               "~/Documents/Research Articles/"
                               default-file nil
                               (when default-file
                                 (file-name-nondirectory default-file)))))
    (find-file "~/Documents/bib/references.bib")
    (goto-char (point-max))
    (yas-expand-snippet
     (format "@article{$1,
  author       = {$2},
  title        = {$3},
  journaltitle = {$4},
  year         = {$5},
  doi          = {$9},
  url          = {$10},
  file         = {PDF:%s:application/pdf},
}" file))))

(use-package citar-typst
  :ensure t
  :hook (typst-ts-mode . citar-typst-mode))

(provide 'bard-emacs-writing)