;; (require 'paredit)

;; (add-hook 'emacs-lisp-mode-hook 'paredit-mode)
;; (add-hook 'lisp-mode-hook 'paredit-mode)
;; (add-hook 'scheme-mode-hook 'paredit-mode)
;; (add-hook 'inferior-scheme-mode-hook 'paredit-mode)
;; (add-hook 'inferior-lisp-mode-hook 'paredit-mode)
;; (add-hook 'ielm-mode-hook 'paredit-mode)

;; (global-set-key (kbd "C-x C-p") 'paredit-mode)

;; (cp-set-keys
;;  :keymap paredit-mode-map
;;  :bindings
;;  `((,(kbd "C-p") paredit-backward-down)
;;    (,(kbd "C-n") paredit-forward-up)
;;    (,(kbd "C-b") paredit-backward)
;;    (,(kbd "C-f") paredit-forward)
;;    (,(kbd "C-u") paredit-backward-up)
;;    (,(kbd "C-d") paredit-forward-down)

;;    (,(kbd "M-b") backward-char)
;;    (,(kbd "M-f") forward-char)
;;    (,(kbd "M-p") previous-line)
;;    (,(kbd "M-n") next-line)
;;    (,(kbd "M-u") paredit-kill-0)
;;    (,(kbd "M-d") paredit-forward-delete)

;;    (,(kbd "C-M-b") backward-word)
;;    (,(kbd "C-M-f") forward-word)
;;    (,(kbd "C-M-u") upcase-word)
;;    (,(kbd "C-M-d") paredit-forward-kill-word)
;;    (,(kbd "C-M-p") nil)
;;    (,(kbd "C-M-n") nil)

;;    (,(kbd "M-w") paredit-copy-as-kill)
;;    (,(kbd "C-h") paredit-backward-delete)
;;    (,(kbd "C-w") paredit-backward-kill-word)))

;; (cp-set-keys
;;  :keymap comint-mode-map
;;  :bindings
;;  `((,(kbd "C-d") paredit-forward-down)
;;    (,(kbd "C-M-p") comint-previous-input)
;;    (,(kbd "C-M-n") comint-next-input)))

(defun cp/sp-after-colon-p (id action context)
  (save-excursion
    (forward-char -1)
    (looking-at-p ":")))

(use-package smartparens
  :load-path "~/.emacs.d/elisp-git/smartparens/"
  :init
  (smartparens-global-mode)
  :config
  (add-to-list 'sp-no-reindent-after-kill-modes 'markdown-mode)
  :bind
  (("M-<up>" . sp-splice-sexp-killing-backward)
   :map smartparens-mode-map
   ("C-)" . sp-forward-slurp-sexp)
   ("C-(" . sp-backward-slurp-sexp)
   ("C-}" . sp-forward-barf-sexp)
   ("C-{" . sp-backward-barf-sexp)
   ("C-j" . sp-newline)
   ("C-|" . sp-join-sexp)

   ("C-k" . sp-kill-hybrid-sexp)
   ("C-h" . sp-backward-delete-char)
   ("<backspace>" . sp-backward-delete-char)
   ("C-w" . sp-backward-kill-word)
   ("<C-backspace>" . sp-backward-kill-word)
   ("M-DEL" . sp-backward-kill-word)
   ("M-d" . sp-kill-word)

   ("C-M-p" . sp-backward-down-sexp)
   ("C-M-n" . sp-backward-up-sexp)
   ("C-M-b" . sp-backward-sexp)
   ("C-M-f" . sp-forward-sexp)
   ("C-M-u" . sp-up-sexp)
   ("C-M-d" . sp-down-sexp)
   ("C-M-a" . sp-beginning-of-sexp)
   ("C-M-e" . sp-end-of-sexp)

   ("C-M-k" . sp-kill-sexp)
   ("C-M-w" . sp-copy-sexp)
   :map emacs-lisp-mode-map
   (";" . sp-comment))
  :hook
  (eval-expression-minibuffer-setup . smartparens-mode))

(require 'smartparens)
(require 'smartparens-config)
(smartparens-global-mode)
(add-hook 'paredit-mode-hook 'turn-off-smartparens-mode)
;; (sp-pair "(" ")" :trigger-wrap (kbd "M-(") :actions '(insert wrap autoskip navigate escape))
(sp-pair "(" ")" :wrap "M-(")
(sp-pair "[" "]" :wrap "M-[")
(sp-pair "\"" "\"" :wrap "M-\"")
;; (global-unset-key (kbd "M-\'"))
;; (sp-pair "\'" "\'" :wrap "M-\'") ;; buggy
(sp-pair "<" ">" :wrap "M-<")
(sp-pair "{" "}" :wrap "M-{")
;; (sp-pair "\\\\*" "\\\\*" :actions '(wrap))
;; (sp-pair "\\\\*" :wrap)
;; (sp-pair "\\\\/" :wrap)

;; commented out on 2017-06-06T19:25:13+0530 -
(add-hook 'erc-mode-hook 'smartparens-mode)
;; Disable inserting pair if preceded by : (e.g. in IRC smileys)
(defun cp-point-after-colon-p ()
  (equal (string (char-before)) ":"))
;; (sp-pair "(" nil :unless '(cp-point-after-colon-p))

;;;; sp-backward-kill-word and subword-backward-kill conflict
;; (define-key emacs-lisp-mode-map (kbd "C-p") 'sp-previous-sexp)
;; (define-key emacs-lisp-mode-map (kbd "C-n") 'sp-next-sexp)

;; 2016-11-12 - trying something different, hopefully more consistent
(defun cp-setup-lisp-keys ()
  ;; (cp-set-keys
  ;;  :keymap smartparens-mode-map
  ;;  :bindings
  ;;  `((,(kbd "C-M-b") nil)
  ;;    (,(kbd "C-M-f") nil)
  ;;    (,(kbd "C-M-u") nil)
  ;;    (,(kbd "C-M-d") nil)
  ;;    (,(kbd "C-M-p") nil)
  ;;    (,(kbd "C-M-n") nil)))

  ;; (cp-set-keys
  ;;  :keymap 'local
  ;;  :bindings
  ;;  `((,(kbd ";") sp-comment)
  ;;    (,(kbd "C-p") sp-backward-down-sexp)
  ;;    (,(kbd "C-n") sp-backward-up-sexp)
  ;;    (,(kbd "C-b") sp-backward-sexp)
  ;;    (,(kbd "C-f") sp-forward-sexp)
  ;;    (,(kbd "C-u") sp-up-sexp)
  ;;    (,(kbd "C-d") sp-down-sexp)
  ;;    (,(kbd "C-a") sp-beginning-of-sexp)
  ;;    (,(kbd "C-e") sp-end-of-sexp)

  ;;    (,(kbd "C-k") sp-kill-sexp)
  ;;    (,(kbd "M-w") sp-copy-sexp)
  ;;    (,(kbd "C-h") sp-backward-delete-char)
  ;;    (,(kbd "C-w") sp-backward-kill-word)
  ;;    (,(kbd "M-q") sp-indent-defun)

  ;;    (,(kbd "M-b") backward-char)
  ;;    (,(kbd "M-f") forward-char)
  ;;    (,(kbd "M-p") previous-line)
  ;;    (,(kbd "M-n") next-line)
  ;;    (,(kbd "M-u") cp-kill-line-0)
  ;;    (,(kbd "M-d") sp-delete-char)
  ;;    (,(kbd "M-a") beginning-of-line)
  ;;    (,(kbd "M-e") end-of-line)

  ;;    (,(kbd "C-M-b") backward-word)
  ;;    (,(kbd "C-M-f") forward-word)
  ;;    (,(kbd "C-M-u") upcase-word)
  ;;    (,(kbd "C-M-d") sp-kill-word)))

  ;; (cp-set-keys
  ;;  :keymap comint-mode-map
  ;;  :bindings
  ;;  `((,(kbd "C-d")   sp-down-sexp)
  ;;    (,(kbd "C-M-p") comint-previous-input)
  ;;    (,(kbd "C-M-n") comint-next-input)))

  (cp-set-keys
   :keymap 'local
   :bindings
   `((,(kbd "M-q") sp-indent-defun)
     (,(kbd "M-w") contrapunctus-lisp-copy)))
  )

;; experiment
(defun cp/erc-sp-keys ()
  (cp-set-keys
   :keymap smartparens-mode-map
   :unset t
   :bindings
   `((,(kbd "C-h"))
     (,(kbd "C-w")))
   ;; `((,(kbd "C-h") backward-delete-char)
   ;;   (,(kbd "C-w") backward-kill-word))
   ))

;; ;; 2016-11-06 - commented out to try a different, hopefully more consistent setup -
(add-hook 'emacs-lisp-mode-hook      'cp-setup-lisp-keys)
(add-hook 'lisp-mode-hook            'cp-setup-lisp-keys)
(add-hook 'scheme-mode-hook          'cp-setup-lisp-keys)
(add-hook 'inferior-scheme-mode-hook 'cp-setup-lisp-keys)
(add-hook 'ielm-mode-hook            'cp-setup-lisp-keys)

(add-hook 'eval-expression-minibuffer-setup-hook 'smartparens-mode)
(add-hook 'erc-mode                  'cp/erc-sp-keys)
;; (add-hook 'eval-expression-minibuffer-setup-hook 'cp-setup-lisp-keys)

;; ielm
;; (require 'ielm)
;; (define-key ielm-map (kbd "C-p") 'sp-backward-down-sexp)
;; (define-key ielm-map (kbd "C-n") 'sp-backward-up-sexp)
;; (define-key ielm-map (kbd "C-b") 'sp-backward-sexp)
;; (define-key ielm-map (kbd "C-f") 'sp-forward-sexp)
;; (define-key ielm-map (kbd "C-u") 'sp-up-sexp)
;; (define-key ielm-map (kbd "C-d") 'sp-down-sexp)
;; (define-key comint-mode-map (kbd "C-d") 'sp-down-sexp)
;; (define-key ielm-map (kbd "C-a") 'sp-beginning-of-sexp)
;; (define-key ielm-map (kbd "C-e") 'sp-end-of-sexp)

;; (define-key ielm-map (kbd "C-k") 'sp-kill-sexp)
;; (define-key ielm-map (kbd "M-w") 'sp-copy-sexp)
;; (define-key ielm-map (kbd "C-h") 'sp-backward-delete-char)
;; (define-key ielm-map (kbd "C-w") 'sp-backward-kill-word)

;; (define-key ielm-map (kbd "M-b") 'backward-char)
;; (define-key ielm-map (kbd "M-f") 'forward-char)
;; (define-key ielm-map (kbd "M-p") 'previous-line)
;; (define-key ielm-map (kbd "M-n") 'next-line)
;; (define-key ielm-map (kbd "M-u") 'cp-kill-line-0)
;; (define-key ielm-map (kbd "C-k") 'sp-kill-sexp)
;; (define-key ielm-map (kbd "M-d") 'sp-delete-char)

;; (define-key ielm-map (kbd "C-M-b") 'backward-word)
;; (define-key ielm-map (kbd "C-M-f") 'forward-word)
;; (define-key ielm-map (kbd "C-M-u") 'upcase-word)
;; (define-key ielm-map (kbd "C-M-d") 'sp-kill-word)
;; (define-key ielm-map (kbd "C-M-p") nil)
;; (define-key ielm-map (kbd "C-M-n") nil)

;; (define-key comint-mode-map (kbd "C-M-p") 'comint-previous-input)
;; (define-key comint-mode-map (kbd "C-M-n") 'comint-next-input)


;; (define-key scheme-mode-map (kbd "C-p") 'sp-backward-down-sexp)
;; (define-key scheme-mode-map (kbd "C-n") 'paredit-forward-up)
;; (define-key scheme-mode-map (kbd "C-b") 'paredit-backward)
;; (define-key scheme-mode-map (kbd "C-f") 'sp-forward-sexp)
;; (define-key scheme-mode-map (kbd "C-u") 'paredit-backward-up)
;; (define-key scheme-mode-map (kbd "C-d") 'paredit-forward-down)
;; (define-key comint-mode-map (kbd "C-d") 'paredit-forward-down)

;; (define-key scheme-mode-map (kbd "M-b") 'backward-char)
;; (define-key scheme-mode-map (kbd "M-f") 'forward-char)
;; (define-key scheme-mode-map (kbd "M-p") 'previous-line)
;; (define-key scheme-mode-map (kbd "M-n") 'next-line)
;; ;; (define-key scheme-mode-map (kbd "M-u") 'paredit-kill-0)
;; (define-key scheme-mode-map (kbd "C-k") 'sp-kill-sexp)
;; (define-key scheme-mode-map (kbd "M-d") 'sp-delete-char)

;; (define-key scheme-mode-map (kbd "C-M-b") 'backward-word)
;; (define-key scheme-mode-map (kbd "C-M-f") 'forward-word)
;; (define-key scheme-mode-map (kbd "C-M-u") 'upcase-word)
;; (define-key scheme-mode-map (kbd "C-M-d") 'sp-kill-word)
;; (define-key scheme-mode-map (kbd "C-M-p") nil)
;; (define-key scheme-mode-map (kbd "C-M-n") nil)
;; (define-key comint-mode-map (kbd "C-M-p") 'comint-previous-input)
;; (define-key comint-mode-map (kbd "C-M-n") 'comint-next-input)

;; (define-key scheme-mode-map (kbd "M-w") 'paredit-copy-as-kill)
;; (define-key scheme-mode-map (kbd "C-h") 'paredit-backward-delete)
;; (define-key scheme-mode-map (kbd "C-w") 'paredit-backward-kill-word)

(provide 'cp-parens)