(when (fboundp 'electric-pair-mode)
  (setq electric-pair-pairs (append electric-pair-pairs '((?\{ . ?\}) (?\' . ?\'))))
  (add-hook 'after-init-hook 'electric-pair-mode))
(add-hook 'after-init-hook 'electric-indent-mode)

;; https://github.com/VandeeFeng/emacs.d/blob/archlinux/lisp/init-editing-utils.el
;; Mark & edit
(global-set-key (kbd "M-m") 'set-mark-command)

(with-eval-after-load 'evil
  (define-prefix-command 'my/mark-map)
  (define-key evil-normal-state-map (kbd "m") 'my/mark-map)
  (define-key evil-motion-state-map (kbd ";") nil)
  (evil-define-key '(normal visual) 'global
    "gc" #'comment-dwim)

  ;; this keybindings only use not in insert mode
  (dolist (binding '(("m" . mark-sexp)
                     ("p" . set-pin-mark) ; 这是自己实现的 init-mark.el
                     ("g" . goto-pin-mark) ; 简化版的 bookmark
                     ("d" . mark-defun)
                     (";" . comment-indent)
                     ;; (";" . comment-dwim) ; use gc instead
                     ("k" . move-dup-move-lines-up)
                     ("j" . move-dup-move-lines-down)
                     ("u" . upcase-dwim) ; equal to g U in vim
                     ("s" . thing-copy-symbol)
                     ("S" . thing-cut-symbol)
                     ("w" . thing-copy-word)
                     ("W" . thing-cut-word)
                     ("-" . thing-copy-to-line-end)
                     ("_" . thing-cut-to-line-end)
                     ("0" . thing-copy-to-line-beginning)
                     (")" . thing-cut-to-line-beginning)))
    (define-key my/mark-map (kbd (car binding)) (cdr binding)))
  )

(with-eval-after-load 'evil
  ;; normal, visual, insert
  (dolist (binding '(("C-s" . backward-kill-sexp)
                     ("C-S-s" . kill-back-to-indentation)
                     ("C-d" . kill-sexp)
                     ("C-k" . kill-visual-line)
                     ("C-y" . clipboard-yank)
                     ("C-a" . beginning-of-line)
                     ("C-e" . end-of-line)
                     ("C-b" . backward-char) ;; 覆盖 evil 的键位，回归 Emacs 默认键位
                     ("C-f" . forward-char) ;; 覆盖 evil 的键位，回归 Emacs 默认键位
                     ("C-n" . next-line) ;; 覆盖 evil 的键位，回归 Emacs 默认键位
                     ("C-p" . previous-line) ;; 覆盖 evil 的键位，回归 Emacs 默认键位
                     ))
    (dolist (state '(normal visual insert))
      (evil-global-set-key state (kbd (car binding)) (cdr binding))))

  ;; ;; visual, insert
  ;; (dolist (binding '(("C-h" . backward-char)
  ;;                    ("C-l" . forward-char)
  ;;                    ("C-j" . next-line)
  ;;                    ("C-k" . previous-line)))
  ;;   (dolist (state '(visual insert))
  ;;     (evil-global-set-key state (kbd (car binding)) (cdr binding))))

  ;; normal visual
  (dolist (binding '(("-" . end-of-line)
                     ("," . backward-sexp)
                     ("." . forward-sexp)
                     ))
    (dolist (state '(normal visual))
      (evil-global-set-key state (kbd (car binding)) (cdr binding))))

  (define-key evil-motion-state-map (kbd "C-v") nil)
  (global-unset-key (kbd "C-v"))
  (global-set-key (kbd "S-<backspace>") 'delete-char))

;; https://github.com/VandeeFeng/emacs.d/blob/archlinux/lisp/init-hydra.el
;; general 设置 leader key SPC
(general-define-key
 :states '(normal motion visual)
 :keymaps 'override
 :prefix "SPC"
 "" '(hydra-leader/body :wk "hydra leader"))

;; 不同模式的常用快捷键设置
;; Mode-specific hydra bindings
(define-key evil-normal-state-map (kbd "C-.") nil)
(defun hydra-mode-setup ()
  "Setup hydra bindings for specific modes."
  (cond
   ((eq major-mode 'dired-mode)
    (local-set-key (kbd "C-.") 'hydra-dired/body))

   ((eq major-mode 'org-mode)
    (local-set-key (kbd "C-.") 'hydra-org/body))

   ((eq major-mode 'magit-status-mode)
    (local-set-key (kbd "C-.") 'hydra-magit/body))

   ((derived-mode-p 'prog-mode)
    (local-set-key (kbd "C-.") 'hydra-code/body))))

;; Add mode-specific setup to hooks
(add-hook 'dired-mode-hook 'hydra-mode-setup)
(add-hook 'org-mode-hook 'hydra-mode-setup)
(add-hook 'magit-status-mode-hook 'hydra-mode-setup)
(add-hook 'prog-mode-hook 'hydra-mode-setup)

;; jk 退出 insert
(with-eval-after-load 'evil
  (use-package key-chord
    :ensure t
    :config
    (key-chord-mode 1)
    (setq key-chord-two-keys-delay 0.3) ;; 版本更新之后，默认j k 的判断时间变少了
    (key-chord-define evil-insert-state-map "jk" 'evil-normal-state)))

;; compile grep
(defun my/compile-grep-rn (pattern)
  "Run `grep -irn` with the given PATTERN in the current directory."
  (interactive "sGrep pattern: ")
  (compile (format "grep -irn '%s' ." pattern)))

(defun my/org-backlink ()
  "Find all org files in the current directory that link to the current file.
The search is performed using `rgrep` for the specific pattern
'filename.org][filename]]'."
  (interactive)
  (unless buffer-file-name
    (error "Current buffer is not visiting a file"))

  (let* ((current-file (file-name-nondirectory buffer-file-name))
         (current-dir (file-name-directory buffer-file-name))
         (file-basename (file-name-sans-extension current-file))
         ;; Search for the literal string "filename.org][filename]]"
         (search-pattern (concat (regexp-quote current-file)
                                 "\\]\\["
                                 (regexp-quote file-basename)
                                 "\\]\\]")))
    (rgrep search-pattern "*.org" current-dir)))

;; simple claude code shell command
(defun my/claude-shell-command (prompt)
  "Execute claude command asynchronously and display the output."
  (interactive "sClaude prompt: ")
  (let* ((output-buffer-name "*Claude Output*")
         (output-buffer (get-buffer-create output-buffer-name))
         (shell-program (or (getenv "SHELL") shell-file-name))
         ;; Use shell-quote-argument
         (command-str (format "claude -p %s" (shell-quote-argument prompt))))
    (with-current-buffer output-buffer
      (setq buffer-read-only nil)
      (erase-buffer)
      (setq-local header-line-format (format "Claude Output for prompt: %s" prompt)))
    ;; (display-buffer output-buffer) ; Show the buffer immediately
    (message "Claude command running asynchronously...")
    ;; Start the async process
    (let ((process (start-process "claude-process"
                                  output-buffer-name
                                  shell-program
                                  "-lc"
                                  command-str)))
      ;; Set a function to be called when the process finishes
      (set-process-sentinel process #'my/claude-process-sentinel))))

(defun my/claude-process-sentinel (process _event)
  "Sentinel for the claude async process. Handles success and error cases."
  (when (memq (process-status process) '(exit signal))
    (let* ((buffer (process-buffer process))
           (exit-code (process-exit-status process)))
      (cond
       ;; Case 1: Process failed (non-zero exit code)
       ((/= exit-code 0)
        (kill-buffer buffer)
        (if (= exit-code 127)
            (message "Error: 'claude' command not found. Please ensure it's in your shell's PATH.")
          (message "Error: Claude command failed with exit code %d." exit-code)))

       ;; Case 2: Process succeeded but produced no output
       ((zerop (with-current-buffer buffer (buffer-size)))
        (kill-buffer buffer)
        (message "Claude command finished with no output."))

       ;; Case 3: Success
       (t
        (with-current-buffer buffer
          (setq buffer-read-only t)
          (goto-char (point-min)))
        (display-buffer buffer)
        (message "Claude command finished."))))))

(require 'org-protocol)
(require 'gptel)

(require 'server)
(unless (server-running-p)
  (server-start))

;; Handler for gptel queries from browser
(defun my/gptel-org-protocol-handler (info)
  "Handle gptel query from org-protocol.
INFO is the data passed by org-protocol."
  (let ((text (plist-get info :text)))
    (when (and text (not (string-empty-p text)))
      (let ((query (decode-coding-string (url-unhex-string text) 'utf-8)))
        (message "Received gptel query: %s" query)
        ;; Create or switch to gptel buffer
        (let ((buffer (get-buffer-create "*gptel-browser*")))
          (with-current-buffer buffer
            (unless (eq major-mode 'gptel-default-mode)
              (funcall gptel-default-mode))
            (gptel-mode 1)
            (goto-char (point-max))
            (insert "\n\n--- From Browser ---\n")
            (insert query)
            (insert "\n")
            (goto-char (point-max))
            ;; Send the query to gptel
            (gptel-send)
            (display-buffer buffer)))))))

;; Register the protocol handler
(setq org-protocol-protocol-alist
      (append org-protocol-protocol-alist
              '(("gptel-browser"
                 :protocol "gptel"
                 :function my/gptel-org-protocol-handler))))

;; JavaScript bookmarklet for browser (copy this as bookmark URL):
;; Basic version:
;; javascript:(function(){const selectedText=window.getSelection().toString().trim();if(!selectedText){alert('Please select some text first');return;}const pageTitle=document.title;const pageUrl=window.location.href;const fullText=`From: ${pageTitle}\nURL: ${pageUrl}\n\nSelected text:\n${selectedText}`;const encodedText=encodeURIComponent(fullText);const protocolUrl=`org-protocol://gptel?text=${encodedText}`;window.location.href=protocolUrl;})();

;; Enhanced version with prompt for question:
;; javascript:(function(){const selectedText=window.getSelection().toString().trim();if(!selectedText){alert('Please select some text first');return;}const pageTitle=document.title;const pageUrl=window.location.href;const userQuestion=prompt('Optional: Add a question or context:');let fullText=`From: ${pageTitle}\nURL: ${pageUrl}\n\n`;if(userQuestion){fullText+=`Question: ${userQuestion}\n\n`;}fullText+=`Selected text:\n${selectedText}`;const encodedText=encodeURIComponent(fullText);const protocolUrl=`org-protocol://gptel?text=${encodedText}`;window.location.href=protocolUrl;})();