;; Packages
(require 'package)
(add-to-list 'package-archives
             '("melpa" . "https://melpa.org/packages/"))
(when (< emacs-major-version 24)
    ;; For important compatibility libraries like cl-lib
    (add-to-list 'package-archives '("gnu" . "http://elpa.gnu.org/packages/")))
(package-initialize) ;; You might already have this line


;; define system
(defun system-is-linux()
    (string-equal system-type "gnu/linux"))

;; Start Emacs as server
(when (system-is-linux)
    (require 'server)
    (unless (server-running-p)
        (server-start)))

;; Disable backup
(setq make-backup-files nil)

;; Dired
(require 'dired)
(setq dired-recursive-deletes 'top)

;; Imenu
(require 'imenu)
(setq imenu-autorescan t)
(setq imenu-use-popup-menu t)

(global-set-key (kbd "<f4>") 'imenu)

;; Display name of teh buffer
(setq frame-title-format "GNU Emacs: %b")

;; Disable startup screen
(setq inhibit-splash-screen   t)
(setq inhibit-startup-message t)

;; Show-paren-mode settings
(show-paren-mode t)
(setq show-paren-style 'expression)

;; Electric-modes settings
(electric-pair-mode 1)
(electric-indent-mode 1)

;; Delete selection
(delete-selection-mode t)

(add-hook 'after-init-hook #'global-flycheck-mode)
;; (require 'autopair)
;; (autopair-global-mode)

;; Regexp search
(global-set-key (kbd "C-s") #'isearch-forward-regexp)
(global-set-key (kbd "C-r") #'isearch-backward-regexp)
(global-set-key (kbd "C-M-s") #'isearch-forward)
(global-set-key (kbd "C-M-r") #'isearch-backward)

;; Disable GUI
(tooltip-mode -1)
(menu-bar-mode -1)
(tool-bar-mode -1)
(scroll-bar-mode -1)
(setq use-dialog-box nil)
;; (setq redisplay-dont-pause t)
(setq ring-bell-function 'ignore)

;; Set cursor
(setq cursor-type 'bar)
(beacon-mode 1)

;; Scrolling
(setq scroll-step               1)
(setq scroll-margin            10)
(setq scroll-conservatively 10000)

;; Fill column indicator
(require 'fill-column-indicator)
(setq-default fill-column 99)
(setq fci-rule-width 1)
(setq fci-rule-color "#696969")
(define-globalized-minor-mode global-fci-mode fci-mode (lambda () (fci-mode 1)))

;; (global-fci-mode 1)


;; ibuffer settings

;; Buffers selectin and ibuffer settings
(require 'bs)
(require 'ibuffer)
;; (defalias 'list-buffers 'ibuffer-list-buffers)

(setq ibuffer-saved-filter-groups
      (quote (("default"
               ("python" (mode . python-mode))
               ("Go" (mode . go-mode))
               ("Slack" (mode . erc-mode))
               ("RPM" (mode . rpm-spec-mode))
               ("planner" (or
                           (name . "^\\*Calendar\\*$")
                           (name . "^diary$")
                           (mode . muse-mode)))
               ("emacs" (or
                         (name . "^\\*scratch\\*$")
                         (name . "^\\*Messages\\*$")))
               ("shell" (name . "^\\*shell*"))
               ))))

(setq ibuffer-show-empty-filter-groups nil)

(add-hook 'ibuffer-mode-hook
          (lambda ()
              (ibuffer-switch-to-saved-filter-groups "default")
              ;; (ibuffer-filter-by-name "^[^*]")
              ))

(add-hook 'ibuffer-hook
          (lambda ()
              (ibuffer-projectile-set-filter-groups)
              (unless (eq ibuffer-sorting-mode 'alphabetic)
                  (ibuffer-do-sort-by-alphabetic))))

(global-set-key (kbd "<f2>") 'ibuffer)
(global-set-key (kbd "<f5>") 'buffer-menu)

;; Linum plugin
(require 'linum)
(line-number-mode t)
(global-linum-mode t)
(column-number-mode t)
(setq linum-format " %d ")

;; Fringe settings
(fringe-mode '(4 . 0))
(setq-default indicate-empty-lines t)
(setq-default indicate-buffer-boundaries 'left)
;; (global-fringe-mode t)

;; Display file size in mode-line
(setq display-time-24hr-format t)
(display-time-mode             t)
(size-indication-mode          t)

;; Indent settings
(setq-default indent-tabs-mode nil)
(setq-default tab-width 4)
(setq-default c-basic-offset 4)
(setq-default standart-indent 4)
(setq-default lisp-body-indent 4)
(global-set-key (kbd "RET") 'newline-and-indent)
(add-hook 'go-mode-hook (lambda () (my-setup-indent 2)))

;; Clipboard settings
(setq x-select-enable-clipboard t)

;; EOF newlines
(setq require-final-newline t)
(setq next-line-add-newlines nil)

;; Highlight search results
(setq search-highlight t)
(setq query-replace-highlight t)

;; Undo & Redo
(global-unset-key "\C-z")
(global-set-key "\C-z" 'advertised-undo)

;; Comment block
(defun comment-dwim-line (&optional arg)
    "Replacement for comment-dwim"
    (interactive "*P")
    (comment-normalize-vars)
    (if (and (not (region-active-p)) (not (looking-at "[ \t]*$")))
            (comment-or-uncomment-region (line-beginning-position) (line-end-position))
        (comment-dwim arg)))
(global-set-key "\M-;" 'comment-dwim-line)

;; Python settings
;; ;;;;;;;;;;;;;;;
;; Python mode hook
(defun my-python-mode-hook ()
    (setq-default py-shell-name "ipython")
    (setq-default py-which-bufname "IPython")

    (require 'flymake-python-pyflakes)
    (setq flymake-python-pyflakes-executable "flake8")
    (setq flymake-python-pyflakes-extra-arguments '("--max-line-length=99"))

    ;; Jedi
    (setq jedi:complete-on-dot t)
    (require 'company)
    (add-to-list 'company-backends 'company-jedi)

    (fci-mode)
    (flymake-python-pyflakes-load)
    (jedi:setup)
    (setq py-autopep8-options '("--max-line-length=99"))
    (py-autopep8-enable-on-save)
    ;; Enable rainbow
    (rainbow-delimiters-mode-enable)

    ;; Refactoring
    (add-to-list 'load-path "/usr/share/emacs/site-lisp/pymacs")
    (require 'pymacs)
    (pymacs-load "ropemacs" "rope-")
    )

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

;; End of python settings
;; ;;;;;;;;;;;;;;;;;;;;;;

;; Enable rainbow
;; (add-hook 'lisp-mode-hook #'rainbow-delimiters-mode)

;; Close all buffers
(defun close-all-buffers ()
    (interactive)
    (mapc 'kill-buffer (buffer-list)))

;; Copy and Cut whole lines
(put 'kill-ring-save 'interactive-form
     '(interactive
       (if (use-region-p)
               (list (region-beginning) (region-end))
           (list (line-beginning-position) (line-beginning-position 2)))))

;; Projectile + Neotree
(setq neo-smart-open t)
(setq projectile-switch-project-action 'neotree-projectile-action)

(defun neotree-project-dir ()
    "Open NeoTree using the git root."
    (interactive)
    (let ((project-dir (projectile-project-root))
          (file-name (buffer-file-name)))
        (neotree-toggle)
        (if project-dir
                (if (neo-global--window-exists-p)
                        (progn
                            (neotree-dir project-dir)
                            (neotree-find file-name)))
            (message "Could not find git project root."))))

(global-set-key "\M-e" 'neotree-project-dir)
(projectile-mode)
(setq projectile-indexing-method 'native)

; Autocomplete
(defun ac-init()
    (require 'auto-complete-config)
    (ac-config-default)
    (setq ac-auto-start 1)
    (setq ac-auto-show-menu t)
    (global-auto-complete-mode t)
    (add-to-list 'ac-modes 'lisp-mode)
    (add-to-list 'ac-sources 'ac-source-variables)
    (add-to-list 'ac-sources 'ac-source-functions)
    (add-to-list 'ac-sources 'ac-source-dictionary))
(ac-init)

;; dirty fix for having AC everywhere
(define-globalized-minor-mode real-global-auto-complete-mode
    auto-complete-mode (lambda ()
                           (if (not (minibufferp (current-buffer)))
                                   (auto-complete-mode 1))
                           ))
(real-global-auto-complete-mode t)

;; Fonts
(add-to-list 'default-frame-alist '(font . "Hack 15"))
(set-face-attribute 'default t :font "Hack 15")

;; Calendar localization
(setq calendar-week-start-day 1
      calendar-day-name-array ["Вс" "Пн" "Вт" "Ср" "Чт" "Пт" "Сб"]
      calendar-month-name-array ["Январь" "Февраль" "Март" "Апрель" "Май"
                                 "Июнь" "Июль" "Август" "Сентябрь"
                                 "Октябрь" "Ноябрь" "Декабрь"])

;; golang
;; (add-to-list 'load-path "/usr/share/emacs/site-lisp/golang-mode")
(setenv "GOPATH" "/home/difrex/.local")
(require 'go-mode)
(require 'go-complete)
(add-hook 'completion-at-point-functions 'go-complete-at-point)

(defun set-exec-path-from-shell-PATH ()
    (let ((path-from-shell (replace-regexp-in-string
                            "[ \t\n]*$"
                            ""
                            (shell-command-to-string "$SHELL --login -i -c 'echo $PATH'"))))
        (setenv "PATH" path-from-shell)
        (setq eshell-path-env path-from-shell) ; for eshell users
        (setq exec-path (split-string path-from-shell path-separator))))

(when window-system (set-exec-path-from-shell-PATH))

(defun my-go-mode-hook ()
    "My Golang hook."
    ;; Call Gofmt before saving
    (add-hook 'before-save-hook 'gofmt-before-save)
    (if (not (string-match "go" compile-command))
            (set (make-local-variable 'compile-command)
                 "go build -v && go test -v && go vet"))
    ;; Oracle
    (load-file "$GOPATH/src/golang.org/x/tools/cmd/oracle/oracle.el")
    ;; Godef jump key binding
    (local-set-key (kbd "M-.") 'godef-jump)
    (local-set-key (kbd "M-*") 'pop-tag-mark)
    ;; Enable rainbow
    (rainbow-delimiters-mode-enable)
    (auto-complete-for-go)
    )
(add-hook 'go-mode-hook 'my-go-mode-hook)

;; Go autocomplete
(defun auto-complete-for-go ()
    "Enable golang autocomple."
    (auto-complete-mode 1))
;; (add-hook 'go-mode-hook 'auto-complete-for-go)

(add-hook 'go-mode-hook #'rainbow-delimiters-mode)

(with-eval-after-load 'go-mode
   (require 'go-autocomplete))

;; END OF GOLANG


;; Powerline
(setq powerline-default-separator 'bar)
(defun my-powerline-hook()
    (require 'powerline)
    (powerline-default-theme)

    (require 'spaceline-config)
    (spaceline-spacemacs-theme)

    ;; Battery
    (add-hook 'after-init-hook #'fancy-battery-mode)
    (fancy-battery-mode 1)
)
(add-hook 'after-init-hook 'my-powerline-hook)
;; End of powerline

;; Short messages
(defalias 'yes-or-no-p 'y-or-n-p)

;; HELM
(require 'helm-config)
(global-set-key (kbd "M-x") 'helm-M-x)
(global-set-key (kbd "C-x r b") #'helm-filtered-bookmarks)
(global-set-key (kbd "C-x C-f") #'helm-find-files)
(helm-mode 1)


(require 'helm-swoop)

;; Change keybinds to whatever you like :)
(global-set-key (kbd "M-i") 'helm-swoop)
(global-set-key (kbd "M-I") 'helm-swoop-back-to-last-point)
(global-set-key (kbd "C-c M-i") 'helm-multi-swoop)
(global-set-key (kbd "C-x M-i") 'helm-multi-swoop-all)

;; HELM TAB completion
(define-key helm-find-files-map "\t" 'helm-execute-persistent-action)

;; Helm fuzy match
(setq helm-mode-fuzzy-match t)
(setq helm-M-x-fuzzy-match t)

;; When doing isearch, hand the word over to helm-swoop
(define-key isearch-mode-map (kbd "M-i") 'helm-swoop-from-isearch)
(define-key helm-swoop-map (kbd "M-i") 'helm-multi-swoop-all-from-helm-swoop)

;; Save buffer when helm-multi-swoop-edit complete
(setq helm-multi-swoop-edit-save t)

;; If this value is t, split window inside the current window
(setq helm-swoop-split-with-multiple-windows nil)

;; Split direction. 'split-window-vertically or 'split-window-horizontally
(setq helm-swoop-split-direction 'split-window-vertically)

;; If nil, you can slightly boost invoke speed in exchange for text color
(setq helm-swoop-speed-or-color nil)

;; Go to the opposite side of line from the end or beginning of line
(setq helm-swoop-move-to-line-cycle t)

;; Optional face for line numbers
;; Face name is `helm-swoop-line-number-face`
(setq helm-swoop-use-line-number-face t)

;; END OF HELM

;; Yasnippet
(require 'yasnippet)
(yas-global-mode 1)

;; git-messenger
(global-set-key (kbd "C-x v p") 'git-messenger:popup-message)

;; Multiple cursors
(require 'multiple-cursors)
(global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)
(global-set-key (kbd "C->") 'mc/mark-next-like-this)
(global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
(global-set-key (kbd "C-c C-<") 'mc/mark-all-like-this)

;; Minimap
(add-hook 'minimap-sb-mode-hook (lambda () (setq mode-line-format nil)))

;; Diminish
(require 'diminish)
(eval-after-load "filladapt" '(diminish 'filladapt-mode))

(defun diminished-modes ()
    "Echo all active diminished or minor modes as if they were minor.
The display goes in the echo area; if it's too long even for that,
you can see the whole thing in the *Messages* buffer.
This doesn't change the status of any modes; it just lets you see
what diminished modes would be on the mode-line if they were still minor."
    (interactive)
    (let ((minor-modes minor-mode-alist)
          message)
        (while minor-modes
            (when (symbol-value (caar minor-modes))
                ;; This minor mode is active in this buffer
                (let* ((mode-pair (car minor-modes))
                       (mode (car mode-pair))
                       (minor-pair (or (assq mode diminished-mode-alist) mode-pair))
                       (minor-name (cadr minor-pair)))
                    (when (symbolp minor-name)
                        ;; This minor mode uses symbol indirection in the cdr
                        (let ((symbols-seen (list minor-name)))
                            (while (and (symbolp (callf symbol-value minor-name))
                                        (not (memq minor-name symbols-seen)))
                                (push minor-name symbols-seen))))
                    (push minor-name message)))
            (callf cdr minor-modes))
        ;; Handle :eval forms
        (setq message (mapconcat
                       (lambda (form)
                           (if (and (listp form) (eq (car form) :eval))
                                   (apply 'eval (cdr form))
                               form))
                       (nreverse message) ""))
        (when (= (string-to-char message) ?\ )
            (callf substring message 1))
        (message "%s" message)))

;; Hide modeline
(defvar-local hidden-mode-line-mode nil)

(define-minor-mode hidden-mode-line-mode
    "Minor mode to hide the mode-line in the current buffer."
    :init-value nil
    :global t
    :variable hidden-mode-line-mode
    :group 'editing-basics
    (if hidden-mode-line-mode
            (setq hide-mode-line mode-line-format
                  mode-line-format nil)
        (setq mode-line-format hide-mode-line
              hide-mode-line nil))
    (force-mode-line-update)
    ;; Apparently force-mode-line-update is not always enough to
    ;; redisplay the mode-line
    (redraw-display)
    (when (and (called-interactively-p 'interactive)
               hidden-mode-line-mode)
        (run-with-idle-timer
         0 nil 'message
         (concat "Hidden Mode Line Mode enabled.  "
                 "Use M-x hidden-mode-line-mode to make the mode-line appear."))))

;; If you want to hide the mode-line in every buffer by default
(add-hook 'after-change-major-mode-hook 'hidden-mode-line-mode)

;; Pomidor technique
(require 'pomidor)
(global-set-key (kbd "<f12>") #'pomidor)

;; SELinux
(add-to-list 'load-path "~/.emacs.d/lisp")
(require 'selinuxpolicy-mode)

;; Find file with sudo
(defun sudo-edit (&optional arg)
    "Edit currently visited file as root.
With a prefix ARG prompt for a file to visit.
Will also prompt for a file to visit if current
buffer is not visiting a file."
    (interactive "P")
    (if (or arg (not buffer-file-name))
            (find-file (concat "/sudo:d_zleztsov@localhost:"
                               (ido-read-file-name "Find file(as root): ")))
        (find-alternate-file (concat "/sudo:d_zheleztsov@localhost:" buffer-file-name))))
(global-set-key (kbd "C-x C-a") 'sudo-edit)

;; Vala mode
(require 'flymake-vala)
(add-hook 'vala-mode-hook 'flymake-vala-load)

;; Clojure
(eval-after-load 'clojure-mode
    '(progn
         (define-key clojure-mode-map (kbd "C-c C-h") #'clojure-cheatsheet)))

;; Puppet
(require 'flymake-puppet)
(add-to-list 'load-path "~/.emacs.d/lisp")
;; (require 'eruby-mode)

;; ERC settings
(require 'tls)
; M-x start-slack
(defun start-slack ()
    "Connect to IRC."
    (interactive)
    (erc-tls :server "XXX.irc.slack.com" :port 6697
             :nick "difrex" :full-name "Denis Zheleztsov"
             :password "XXX")
    (setq erc-autojoin-channels-alist '(
                                        ("#general" "#random" "#XXX" "#operations"))))
;; M-x stop-slack
(defun stop-slack ()
  "Disconnects from all irc servers."
  (interactive)
  (dolist (buffer (filter-server-buffers))
    (message "Server buffer: %s" (buffer-name buffer))
    (with-current-buffer buffer
      (erc-quit-server "Asta la vista"))))


(defun my-erc-modules ()
    "Provide ERC modules."
    (require 'erc-image)
    (add-to-list 'erc-modules 'image)
    (erc-update-modules)

    ;; Interpret mIRC-style color commands in IRC chats
    (setq erc-interpret-mirc-color t)

    ;; open query buffers in the current window
    (setq erc-query-display 'buffer)

    ;; exclude boring stuff from tracking
    (erc-track-mode t)
    (setq erc-track-exclude-types '("JOIN" "NICK" "PART" "QUIT" "MODE"
                                    "324" "329" "332" "333" "353" "477"))

    ;; logging
    (setq erc-log-channels-directory "~/.erc/logs/")
    (if (not (file-exists-p erc-log-channels-directory))
            (mkdir erc-log-channels-directory t))

    (setq erc-save-buffer-on-part t)
    (defadvice save-buffers-kill-emacs (before save-logs (arg) activate)
        (save-some-buffers t (lambda () (when (eq major-mode 'erc-mode) t))))

    ;; truncate long irc buffers
    (erc-truncate-mode +1)

    ;; enable spell checking
    (erc-spelling-mode 1)
    ;; TODO - replace this with use of notify.el
    ;; Notify my when someone mentions my nick.
    (defun call-libnotify (matched-type nick msg)
        (let* ((cmsg  (split-string (clean-message msg)))
               (nick   (first (split-string nick "!")))
               (msg    (mapconcat 'identity (rest cmsg) " ")))
            (shell-command-to-string
             (format "notify-send -u critical '%s says:' '%s'" nick msg))))

    (add-hook 'erc-text-matched-hook 'call-libnotify)

    (defvar erc-notify-nick-alist nil
        "Alist of nicks and the last time they tried to trigger a
notification")

    (defvar erc-notify-timeout 10
        "Number of seconds that must elapse between notifications from
the same person.")

    (defun erc-notify-allowed-p (nick &optional delay)
  "Return non-nil if a notification should be made for NICK.
If DELAY is specified, it will be the minimum time in seconds
that can occur between two notifications.  The default is
`erc-notify-timeout'."
  (unless delay (setq delay erc-notify-timeout))
  (let ((cur-time (time-to-seconds (current-time)))
        (cur-assoc (assoc nick erc-notify-nick-alist))
        (last-time nil))
    (if cur-assoc
        (progn
          (setq last-time (cdr cur-assoc))
          (setcdr cur-assoc cur-time)
          (> (abs (- cur-time last-time)) delay))
      (push (cons nick cur-time) erc-notify-nick-alist)
      t)))

    ;; private message notification
    (defun erc-notify-on-private-msg (proc parsed)
        (let ((nick (car (erc-parse-user (erc-response.sender parsed))))
              (target (car (erc-response.command-args parsed)))
              (msg (erc-response.contents parsed)))
            (when (and (erc-current-nick-p target)
                       (not (erc-is-message-ctcp-and-not-action-p msg))
                       (erc-notify-allowed-p nick))
                (shell-command-to-string
                 (format "notify-send -u critical '%s says:' '%s'" nick msg))
                nil)))

    (add-hook 'erc-server-PRIVMSG-functions 'erc-notify-on-private-msg)

    ;; utf-8 always and forever
    (setq erc-server-coding-system '(utf-8 . utf-8)))

(defun filter-server-buffers ()
    (delq nil
          (mapcar
           (lambda (x) (and (erc-server-buffer-p x) x))
           (buffer-list))))

(my-erc-modules)

;; SPEC
(autoload 'rpm-spec-mode "rpm-spec-mode.el" "RPM spec mode." t)
(setq auto-mode-alist (append '(("\\.spec" . rpm-spec-mode))
                              auto-mode-alist))


;; Temporary maximize buffer
(defun toggle-maximize-buffer ()
    "Maximize buffer."
    (interactive)
    (if (= 1 (length (window-list)))
            (jump-to-register '_)
        (progn
            (window-configuration-to-register '_)
            (delete-other-windows))))
(global-set-key [(super shift return)] 'toggle-maximize-buffer)