(require 'evil)
(require 'cider)
(require 'cider-scratch)
(require 'highlight)
(require 'eval-sexp-fu)

;; make wrapping friendly to Clojure/Pixie/Hy
(with-eval-after-load "evil-lisp-state"
  ;; undef SPC k w so we can generalize it
  (evil-leader/set-key "kw" nil)
  ;; wrap using SPC k w ([{
  (evil-leader/set-key "kw("
    (lambda (&optional arg) (interactive "P") (sp-wrap-with-pair "(")))
  (evil-leader/set-key "kw["
    (lambda (&optional arg) (interactive "P") (sp-wrap-with-pair "[")))
  (evil-leader/set-key "kw{"
    (lambda (&optional arg) (interactive "P") (sp-wrap-with-pair "{")))
  (evil-leader/set-key "kw\""
    (lambda (&optional arg) (interactive "P") (sp-wrap-with-pair "\""))))

(defun spacemacs//emacs-lisp-eval-region-and-print (beg end)
  (interactive)
  (let* ((raw-result (with-output-to-string
                       (eval-region beg end standard-output)))
         (result (when (>= (length raw-result) 1)
                   (substring raw-result 1 -1))))
    (when result
      (cider--display-interactive-eval-result result end))))

(defvar spacemacs--generic-eval-region-alist
  '((clojure-mode . cider-eval-region)
    (emacs-lisp-mode . spacemacs//emacs-lisp-eval-region-and-print)
    (python-mode . python-shell-send-region)
    (lisp-mode . lisp-eval-region)))

;(lisp-eval-string "(+ 1 2 3)")

(defun spacemacs//get-eval-region-for-current-mode ()
  (interactive)
  (catch 'break
    (dolist (test spacemacs--generic-eval-region-alist)
      (let ((mode (car test))
            (val (cdr test)))
        (when (and (symbolp mode)
                   (derived-mode-p mode)
                   (symbolp val))
          (throw 'break val))))))

(defun spacemacs//generic-eval-region (beg end)
  (interactive)
  (let ((f (spacemacs//get-eval-region-for-current-mode)))
    (when (functionp f)
      (funcall f beg end))))

(evil-define-operator spacemacs//generic-evil-eval-operator (beg end)
  (spacemacs//generic-eval-region beg end))

(defun spacemacs//generic-eval-line ()
  "Evals the current line as though you did (kbd \"ma^ SPC meo $`a\")"
  (interactive)
  ;; we don't use execute-kbd-macro here, because popping the mark kills the overlay
  (save-excursion
    (let* ((beg (progn (beginning-of-line) (point)))
          (end (progn (end-of-line) (point))))
      (spacemacs//generic-eval-region beg end))))

(defun spacemacs//generic-eval-paragraph ()
  "Evals the current paragraph as though you did (kbd \"ma SPC meo ap`a\")"
  (interactive)
  ;; we don't use execute-kbd-macro here, because popping the mark kills the overlay
  (save-excursion
    (let* ((graph (evil-inner-paragraph))
          (beg (first graph))
          (end (second graph)))
      (spacemacs//generic-eval-region beg end))))

;; Enable highlighting of the area to be eval'd
(define-eval-sexp-fu-flash-command spacemacs//generic-eval-region
  (eval-sexp-fu-flash (cons beg end)))

(defun emidln//setup-emacs-lisp-mode ()
  (interactive)

  ;; treat - as part of words
  (modify-syntax-entry ?- "w" emacs-lisp-mode-syntax-table)

  ;; enable SPC meo as eval operator
  (evil-leader/set-key "meo" 'spacemacs//generic-evil-eval-operator)

  ;; setup custom keybindings
  (define-key emacs-lisp-mode-map (kbd "C-c C-c") nil)
  (define-key emacs-lisp-mode-map (kbd "C-c C-l") nil)
  (define-key emacs-lisp-mode-map (kbd "C-c C-L") nil)
  (define-key emacs-lisp-mode-map (kbd "C-c C-r") nil)

  ;; (evil-define-key 'normal emacs-lisp-mode-map
  ;;   (kbd "C-c C-l") nil)

  ;; (evil-define-key 'normal emacs-lisp-mode-map
  ;;   (kbd "C-c C-l") 'spacemacs//generic-eval-line)

  ;; (evil-define-key 'normal emacs-lisp-mode-map
  ;;   (kbd "C-c C-l") 'spacemacs//generic-eval-paragraph)

  (evil-define-key 'normal emacs-lisp-mode-map
    (kbd "C-c C-c") 'spacemacs//generic-eval-paragraph
    (kbd "C-c C-l") 'spacemacs//generic-eval-line
    (kbd "C-c C-L") 'eval-buffer
    (kbd "C-c C-r") 'spacemacs//generic-eval-region)

  (spacemacs/set-leader-keys-for-major-mode 'emacs-lisp-mode
    "er" 'spacemacs//generic-eval-region
    "ep" 'spacemacs//generic-eval-paragraph
    "el" 'spacemacs//generic-eval-line))

(emidln//setup-emacs-lisp-mode)
(add-hook 'emacs-lisp-mode-hook 'emidln//setup-emacs-lisp-mode)

(defun emidln//setup-lisp-mode ()
  (interactive)
  ;; treat - as part of words
  (modify-syntax-entry ?- "w" emacs-lisp-mode-syntax-table)

  ;; enable SPC meo as eval operator
  (evil-leader/set-key "meo" 'spacemacs//generic-evil-eval-operator)

  ;; setup custom keybindings
  (define-key lisp-mode-map (kbd "C-c C-c") nil)
  (define-key lisp-mode-map (kbd "C-c C-l") nil)
  (define-key lisp-mode-map (kbd "C-c C-L") nil)
  (define-key lisp-mode-map (kbd "C-c C-r") nil)

  (evil-define-key 'normal lisp-mode-map
    (kbd "C-c C-c") 'spacemacs//generic-eval-paragraph
    (kbd "C-c C-l") 'spacemacs//generic-eval-line
    (kbd "C-c C-L") 'eval-buffer
    (kbd "C-c C-r") 'spacemacs//generic-eval-region)

  (spacemacs/set-leader-keys-for-major-mode 'lisp-mode
    "er" 'spacemacs//generic-eval-region
    "ep" 'spacemacs//generic-eval-paragraph
    "el" 'spacemacs//generic-eval-line)
  )

(emidln//setup-lisp-mode)
(add-hook 'lisp-mode 'emidln//setup-lisp-mode)

(defun cider-show-cider-buffer ()
  (interactive)
  (command-execute 'cider-switch-to-repl-buffer)
  (command-execute 'cider-switch-to-last-clojure-buffer))

(defun emidln//setup-clojure-mode ()
  (interactive)

  ;; treat - as part of words
  (modify-syntax-entry ?- "w" clojure-mode-syntax-table)

  ;; enable SPC meo as eval operator
  (evil-leader/set-key "meo" 'spacemacs//generic-evil-eval-operator)

  ;; setup custom bindings
  (define-key cider-mode-map (kbd "C-c C-c") 'spacemacs//generic-eval-paragraph)
  (define-key cider-mode-map (kbd "C-c C-l") 'spacemacs//generic-eval-line)
  (define-key cider-mode-map (kbd "C-c C-L") 'cider-load-buffer)
  (define-key cider-mode-map (kbd "C-c C-i") 'cider-inspect-last-result)
  (define-key cider-clojure-interaction-mode-map (kbd "C-c C-l") 'spacemacs//generic-eval-line)
  (define-key cider-clojure-interaction-mode-map (kbd "C-c C-L") 'cider-load-buffer)
  (spacemacs/set-leader-keys-for-major-mode 'clojure-mode
    "ep" 'spacemacs//generic-eval-paragraph
    "sp" 'spacemacs//generic-eval-paragraph
    "sl" 'spacemacs//generic-eval-line
    "el" 'spacemacs//generic-eval-line
    "sS" 'cider-show-cider-buffer
    "dl" 'cider-inspect-last-result
    )

  )

(emidln//setup-clojure-mode)

(with-eval-after-load "clojure-mode"
  (emidln//setup-clojure-mode))

;(add-hook 'clojure-mode-hook 'emidln//setup-clojure-mode)

(defadvice cider-scratch (after cider-scratch-advise activate)
  (with-current-buffer (get-buffer cider-scratch-buffer-name)
    (clojure-mode)
    (cider-jack-in)))

(which-key-add-key-based-replacements
  "SPC m s b" "load buffer"
  "SPC m s B" "send buffer and focus"
  "SPC m s c" "connect"
  "SPC m s e" "eval last sexp"
  "SPC m s E" "send last sexp and focus"
  "SPC m s f" "send function"
  "SPC m s F" "send function and focus"
  "SPC m s i" "start repl"
  "SPC m s I" "start cljs repl"
  "SPC m s l" "eval line"
  "SPC m e l" "eval line"
  "SPC m s n" "send ns form"
  "SPC m s N" "send ns form and focus"
  "SPC m s o" "switch repls"
  "SPC m s p" "eval paragraph"
  "SPC m e p" "eval paragraph"
  "SPC m s q" "quit repl"
  "SPC m s r" "send region"
  "SPC m s R" "send region and focus"
  "SPC m s s" "focus repl"
  "SPC m s S" "show repl"
  "SPC m s x" "refresh repl"
  "SPC m d l" "inspect last result")

;; quick window navigation vim-style
(evil-global-set-key 'normal (kbd "C-w w") 'next-multiframe-window)
(evil-global-set-key 'normal (kbd "C-w C-w") 'next-multiframe-window)
(evil-global-set-key 'emacs (kbd "C-w w") 'next-multiframe-window)
(evil-global-set-key 'emacs (kbd "C-w C-w") 'next-multiframe-window)
(spacemacs/set-leader-keys (kbd "ww") 'next-multiframe-window)


(defmacro comment (&rest body)
  "ignore the body and return nil"
  nil)

;; make text-scale-increase/text-scale-decrease global across buffers
(defadvice text-scale-increase (around all-buffers (arg) activate)
  (dolist (buffer (buffer-list))
    (with-current-buffer buffer
      ad-do-it)))