(load-theme 'tangotango t)

;; hide toolbar and scrollbar
(tool-bar-mode 0)
(scroll-bar-mode 0)

;; show x-position (ie column number) for point in buffer
(column-number-mode 1)

(setq enable-recursive-minibuffers t)

(minibuffer-depth-indicate-mode 1)

(define-key prog-mode-map (kbd "M-n") #'highlight-symbol-next)
(define-key prog-mode-map (kbd "M-p") #'highlight-symbol-prev)

;; Whilst YAML isn't a programming language, it's useful to move by
;; symbol here too.
(use-package yaml-mode
  :config
  (define-key yaml-mode-map (kbd "M-n") #'highlight-symbol-next)
  (define-key yaml-mode-map (kbd "M-p") #'highlight-symbol-prev)
  (define-key yaml-mode-map (kbd "M-N") #'highlight-symbol-last)
  (define-key yaml-mode-map (kbd "M-P") #'highlight-symbol-first))

(defun highlight-symbol-first ()
  "Jump to the first location of symbol at point."
  (interactive)
  (push-mark)
  (eval
   `(progn
      (goto-char (point-min))
      (let ((case-fold-search nil))
        (search-forward-regexp
         (rx symbol-start ,(thing-at-point 'symbol) symbol-end)
         nil t))
      (beginning-of-thing 'symbol))))

(define-key prog-mode-map (kbd "M-P") #'highlight-symbol-first)

(defun highlight-symbol-last ()
  "Jump to the last location of symbol at point."
  (interactive)
  (push-mark)
  (eval
   `(progn
      (goto-char (point-max))
      (let ((case-fold-search nil))
        (search-backward-regexp
         (rx symbol-start ,(thing-at-point 'symbol) symbol-end)
         nil t)))))

(global-set-key (kbd "M-N") 'highlight-symbol-last)

(global-set-key (kbd "C-a") #'crux-move-beginning-of-line)

(global-set-key (kbd "M-m") #'jump-char-forward)
(global-set-key (kbd "M-M") #'jump-char-backward)

(keyfreq-mode 1)
(keyfreq-autosave-mode 1)

(require 'smartparens)

;; (foo bar) -> foo bar
(define-key smartparens-mode-map (kbd "M-s") 'sp-splice-sexp)

;; (foo bar) -> [foo bar]
(define-key smartparens-mode-map (kbd "M-S") 'sp-rewrap-sexp)

;; (|foo) bar -> (|foo bar)
(define-key smartparens-mode-map (kbd "<C-right>") 'sp-slurp-hybrid-sexp)

;; (|foo bar) -> (|foo) bar
(define-key smartparens-mode-map (kbd "<C-left>") #'sp-forward-barf-sexp)

;; foo(1, |[2, 3], 4) -> foo(1, |, 2)
(define-key smartparens-mode-map (kbd "C-M-k") #'sp-kill-sexp)
(define-key smartparens-mode-map (kbd "s-k") #'sp-kill-sexp)

(defun wh/smartparens-wrap-round (arg)
  "Smartparens equivalent of `paredit-wrap-round'."
  (interactive "P")
  (sp-wrap-with-pair "("))

(define-key smartparens-mode-map (kbd "M-(") #'wh/smartparens-wrap-round)

(defun wh/smartparens-wrap-square-bracket (arg)
  "[] equivalent of `wh/smartparens-wrap-round'."
  (interactive "P")
  (sp-wrap-with-pair "["))

(define-key smartparens-mode-map (kbd "M-[") #'wh/smartparens-wrap-square-bracket)

(defun wh/smartparens-wrap-curly-paren (arg)
  "{} equivalent of `wh/smartparens-wrap-round'."
  (interactive "P")
  (sp-wrap-with-pair "{"))

(define-key smartparens-mode-map (kbd "M-{") #'wh/smartparens-wrap-curly-paren)

(defun wh/smartparens-wrap-singlequote (arg)
  "As `wh/smartparens-wrap-round' but for wrapping with single quotes."
  (interactive "P")
  (sp-wrap-with-pair "'"))

(define-key smartparens-mode-map (kbd "M-'") #'wh/smartparens-wrap-singlequote)

(define-key smartparens-mode-map (kbd "s-f") #'sp-forward-sexp)
(define-key smartparens-mode-map (kbd "C-M-f") #'sp-forward-sexp)

(define-key smartparens-mode-map (kbd "s-b") #'sp-backward-sexp)
(define-key smartparens-mode-map (kbd "C-M-b") #'sp-backward-sexp)

(define-key smartparens-mode-map (kbd "s-u") #'sp-backward-up-sexp)

(require 'smartparens-config)
(require 'smartparens-html)
(add-hook 'prog-mode-hook #'smartparens-strict-mode)

(add-hook 'yaml-mode-hook #'smartparens-mode)
(add-hook 'sqlplus-mode-hook #'smartparens-mode)

(require 'recentf)

;; offer recently accessed files from the menu
(recentf-mode t)

;; remember this many files
(setq recentf-max-saved-items 500)

;; from http://www.masteringemacs.org/article/find-files-faster-recent-files-package
(require 'crux)

(global-set-key (kbd "C-x C-r") #'crux-recentf-ido-find-file)

(projectile-mode)

(global-set-key (kbd "C-x C-g") 'projectile-find-file)

(use-package dired+
  :init
  (setq diredp-hide-details-initially-flag nil))

(setq delete-by-moving-to-trash t)

(setq
   backup-by-copying t      ; don't clobber symlinks
   backup-directory-alist
    '(("." . "~/.saves"))    ; don't litter my fs tree
   delete-old-versions t
   kept-new-versions 6
   kept-old-versions 2
   version-control t)       ; use versioned backups

(add-hook 'after-save-hook 'backup-each-save)

(defun start--file (path)
  "Create a file at PATH, creating any containing directories as necessary.
Visit the file after creation."
  (make-directory (file-name-directory path) t)
  (find-file path))

(defun wh/start-scratch-file (file-name)
  "Create a file in ~/scratch for the given file name."
  (interactive "sName of scratch file: ")
  (start--file (expand-file-name (format "~/scratch/%s" file-name))))

(defun wh/start-tmp-file (file-name)
  "Create a file in /tmp for the given file name."
  (interactive "sName of temporary file: ")
  (start--file (expand-file-name (format "/tmp/%s" file-name))))

(defun wh/start-scratch-html-file (file-name)
  "Create a test HTML file in ~/scratch to play around with."
  (interactive "sName of scratch HTML file: ")
  (wh/start-scratch-file file-name)
  (erase-buffer)
  (insert "<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">
        <title>
        </title>
        <style type=\"text/css\">
        </style>
    </head>
    <body>

    </body>
</html>")
  (forward-line -2)
  (move-end-of-line nil))

(setq flycheck-highlighting-mode 'lines)

(custom-set-faces
 '(flycheck-error ((((class color)) (:underline "Red"))))
 '(flycheck-warning ((((class color)) (:underline "Orange")))))

(require 'flycheck)
(define-key flycheck-mode-map (kbd "<f8>") 'flycheck-previous-error)
(define-key flycheck-mode-map (kbd "<f9>") 'flycheck-next-error)

(define-key flycheck-mode-map (kbd "C-c f") #'flycheck-list-errors)

(defadvice flycheck-next-error (before wh/flycheck-next-error-push-mark activate)
  (push-mark))

(with-eval-after-load 'flycheck
  (flycheck-title-mode))

(add-hook 'python-mode-hook 'flycheck-mode)

(add-hook 'python-mode-hook
          (lambda ()
            (add-to-list 'flycheck-disabled-checkers 'python-pylint)))

(add-to-list 'auto-mode-alist
             (cons (rx "flake8" eos) #'conf-mode))

(use-package python
  :config
  (define-skeleton python-insert-docstring
    "Insert a Python docstring."
    "This string is ignored!"
    "\"\"\"" - "\n\n    \"\"\"")

  (define-key python-mode-map (kbd "C-c s") 'python-insert-docstring))

(add-hook 'haskell-mode-hook 'flycheck-mode)

(add-hook 'haskell-mode-hook 'turn-on-haskell-indentation)

(add-to-list 'auto-mode-alist '("Vagrantfile" . ruby-mode))

(add-hook 'c-mode-common-hook #'flycheck-mode)

(setq-default c-default-style "linux"
              c-basic-offset 4)

(setq-default c-hungry-delete-key t)

(use-package sgml-mode
  :config
  (setq sgml-basic-offset 4))

(require 'smartparens-config)
(add-hook 'html-mode-hook 'smartparens-strict-mode)

(add-to-list 'auto-mode-alist '("\\.dtml$" . html-mode))

;; Define coloured faces for Django syntax.
(defvar django-tag-face (make-face 'django-tag-face))
(set-face-foreground 'django-tag-face "Orange")
;
(defvar django-variable-face (make-face 'django-variable-face))
(set-face-foreground 'django-variable-face "Green")

(defvar django-comment-face (make-face 'django-comment-face))
(set-face-foreground 'django-comment-face "Gray")

;; Use these faces for Django syntax.  
(font-lock-add-keywords
 'html-mode
 '(
   ("\\({%[^%]*%}\\)" 1 django-tag-face prepend)
   ("\\({{[^}]*}}\\)" 1 django-variable-face prepend)
   ("\\({#[^}]*#}\\)" 1 django-comment-face prepend)
   ("\\({% comment %}\\(.\\|
\\)*{% endcomment %}\\)" 1 django-comment-face prepend)
   ))

; skeletons for Django template tags
(define-skeleton template-tag-skeleton
  "Insert a {% foo %} template tag"
  "Template tag name: "
  "{% " str " %}")
(define-skeleton template-variable-skeleton
  "Insert a {{ foo }} template variable"
  "Template variable: "
  "{{ " str " }}")
(define-skeleton template-comment-skeleton
  "Insert a {# foo #} template variable"
  "Comment: "
  "{# " str " #}")
(define-skeleton template-block-skeleton
  "Insert {% block foo %}{% endblock %}"
  "Block name: "
  "{% block " str " %}\n" - "\n{% endblock %}")
(define-skeleton template-if-else-skeleton
  "Insert {% if foo %}{% else %}{% endif %}"
  "If condition: "
  "{% if " str " %}\n" - "\n{% else %}\n\n{% endif %}")
(define-skeleton template-if-skeleton
  "Insert {% if foo %}{% endif %}"
  "If condition: "
  "{% if " str " %}" - "{% endif %}")
(define-skeleton underscore-skeleton
  "Insert <%= foo %>"
  "Contents: "
  "<%= " str " %>")

(defvar template-skeletons
  '(template-tag-skeleton
    template-variable-skeleton
    template-comment-skeleton
    template-block-skeleton
    template-if-skeleton
    template-if-else-skeleton
    underscore-skeleton))

(defun insert-django-skeleton ()
  (interactive)
  (let* ((skeleton-names (mapcar 'symbol-name template-skeletons))
         (skeleton-chosen (ido-completing-read "HTML skeleton: " skeleton-names)))
    (funcall (intern skeleton-chosen))))

(use-package sgml-mode
  :config
  (define-key html-mode-map "\C-ct" 'insert-django-skeleton))

(defun visit-parent-django-template ()
  "In a buffer containg {% extends \"foo.html\" %}, visit foo.html."
  (interactive)
  (let (start-pos end-pos template-name)
    (save-excursion
      (widen)
      (goto-char (point-min))
      ;; Find the extends tag
      (while (not (looking-at "{% ?extends"))
        (forward-char 1))
      ;; Find the opening " of the file name.
      (while (not (looking-at "\""))
        (forward-char 1))
      (forward-char)
      (setq start-pos (point))

      ;; Find the closing "
      (while (not (looking-at "\""))
        (forward-char 1))
      (setq end-pos (point))

      (setq template-name (buffer-substring-no-properties start-pos end-pos)))

    ;; Open this file, assuming it's in the same directory.
    ;; TODO: Search the current VCS checkout for it.
    (find-file template-name)))

(defun html-linkify-region (url)
  "Wraps the region in an <a> tag with href set to URL."
  (interactive "sURL: ")
  (let* ((initial-cursor-position (point))
         (beginning (region-beginning))
         (end (region-end))
         (first-replacement (concat "<a href=\"" url "\">"))
         (second-replacement "</a>"))
    (goto-char beginning)
    (insert first-replacement)
    (goto-char (+ end (length first-replacement)))
    (insert second-replacement)
    (goto-char (+ initial-cursor-position (length first-replacement)))))

;; zen coding: converts selector-style lines to tags
;; e.g. table>tr*2 becomes <table><tr></tr><tr></tr></table>
(add-hook 'sgml-mode-hook 'zencoding-mode) ;; Auto-start on any markup modes

(setq css-indent-offset 4)

(add-hook 'css-mode-hook 'rainbow-mode)

(add-hook 'css-mode-hook #'smartparens-strict-mode)

(add-hook 'css-mode-hook #'highlight-symbol-mode)

(add-hook 'css-mode-hook #'company-mode)

(require 'css-mode)
(define-key css-mode-map (kbd "C-c i") #'emr-css-toggle-important)

(use-package less-css-mode
  :config
  (add-hook 'less-css-mode-hook 'flymake-mode))

(setq org-src-fontify-natively t)

(add-hook 'markdown-mode-hook 'auto-fill-mode)

(use-package exec-path-from-shell
  :init
  (setq exec-path-from-shell-check-startup-files nil)
  (exec-path-from-shell-initialize))

(use-package asm-mode
  :config
  (setq asm-comment-char ?#))

(use-package llvm-mode
  :config
  ;; TODO: llvm-mode should really inherit from prog-mode.
  (add-hook 'llvm-mode-hook #'highlight-symbol-mode))

(use-package coffee-mode
  :config
  (setq coffee-tab-width 2)

  (defun wh/company-in-coffee-mode ()
    (set (make-local-variable 'company-backends) (list #'company-dabbrev-code)))
  (add-hook 'coffee-mode-hook #'wh/company-in-coffee-mode)

  (add-hook 'coffee-mode-hook #'flycheck-mode))

(use-package rcirc
  :config
  (setq rcirc-default-nick "wilfredh")
  (setq rcirc-server-alist
        '(("irc.freenode.net" :channels ("#emacs"))
          ("irc.mozilla.org" :channels ("#rust"))))
  ;; Keep history.
  (setq rcirc-log-flag t)
  (setq rcirc-log-directory "~/irc_logs")
  ;; Taken from
  ;; https://github.com/s1n4/dotfiles/blob/master/emacs.d/config/rcirc-config.el
  (defun wh/log-filename-with-date (process target)
    (format
     "%s_%s.log"
     (if target
         (rcirc-generate-new-buffer-name process target)
       (process-name process))
     (format-time-string "%Y-%m-%d")))

  (setq rcirc-log-filename-function #'wh/log-filename-with-date)
  ;; Ignore away/join/part messages from lurkers.
  (setq rcirc-omit-responses '("JOIN" "PART" "QUIT" "NICK" "AWAY"))
  (add-hook 'rcirc-mode-hook #'rcirc-omit-mode)
  (require 'rcirc-color))

(use-package twittering-mode
  :init
  ;; Don't show the twitter client or location, it's just distracting.
  (setq twittering-status-format "%i %s,  %@:\n%FILL[  ]{%T %r%R}\n "))

(use-package google-this
  :config
  (global-set-key (kbd "C-c g") #'google-this))

(eval-after-load 'cc-mode
  '(set-keymap-parent c-mode-base-map prog-mode-map))

(remove-hook 'find-file-hook #'crux-reopen-as-root)