;; Initialize the package system first of all.
(require 'package)

(setq package-archives
      '(("gnu" . "https://elpa.gnu.org/packages/")
        ("melpa" . "https://melpa.org/packages/")
        ("elpy" . "https://jorgenschaefer.github.io/packages/")
        ("org" . "http://orgmode.org/elpa/")))

(defvar fcuny-path-emacs-var (expand-file-name "var" user-emacs-directory)
  "Path to some files for Emacs.")

(defvar fcuny-path-emacs-elpa (expand-file-name "elpa" fcuny-path-emacs-var)
  "Path to elpa's local files.")

(defvar fcuny-projects-ignored-dirs '(".git" ".svn" "target" "elpa")
   "Ignore the following directories when browsing with projectile.")

;; where to store the packages
(setq package-user-dir fcuny-path-emacs-elpa)

;; initialize it
(package-initialize)

;; if use-package is not present, we install it
(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))

(require 'use-package)

(defvar fcuny-path-home (getenv "HOME")
  "Path to the user's home directory.")

(defvar fcuny-bookmarks-dir (expand-file-name "bookmarks" fcuny-path-emacs-var)
  "Path to save the bookmarks")

(defvar fcuny-custom-settings (expand-file-name "emacs-custom.el" fcuny-path-emacs-var)
  "Path to emacs custom variables.")

(defun fc/rename-this-buffer-and-file ()
  "Renames current buffer and file it is visiting."
  (interactive)
  (let ((name (buffer-name))
        (filename (buffer-file-name))
        (read-file-name-function 'read-file-name-default))
    (if (not (and filename (file-exists-p filename)))
        (error "Buffer '%s' is not visiting a file!" name)
      (let ((new-name (read-file-name "New name: " filename)))
        (cond ((get-buffer new-name)
               (error "A buffer named '%s' already exists!" new-name))
              (t
               (rename-file filename new-name 1)
               (rename-buffer new-name)
               (set-visited-file-name new-name)
               (set-buffer-modified-p nil)
               (message "File '%s' successfully renamed to '%s'" name (file-name-nondirectory new-name))))))))

(defun fc/check-work-machine-p ()
  "Returns t if this is a work machine"
  (string-match "tw-mbp.*" (system-name)))

;; set utf-8 as the default encoding
(prefer-coding-system 'utf-8-unix)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)

;; alias yes-or-no to y-or-n
(fset 'yes-or-no-p 'y-or-n-p)

(setq auto-save-default nil)                     ;; don't auto save files
(setq auto-save-list-file-prefix nil)            ;; no backups
(setq create-lockfiles nil)                      ;; don't use a lock file
(setq custom-file fcuny-custom-settings)         ;; where to save custom settings
(setq make-backup-files nil)                     ;; really no backups
(setq minibuffer-message-timeout 0.5)            ;; How long to display an echo-area message
(setq next-screen-context-lines 5)               ;; scroll 5 lines at a time
(setq require-final-newline t)                   ;; ensure newline exists at the end of the file
(setq ring-bell-function 'ignore)                ;; really no bell
(setq tab-always-indent 'complete)               ;; when using TAB, always indent
(setq visible-bell nil)                          ;; no bell
(setq column-number-mode t)                      ;; show column number in the mode line
(setq use-package-always-ensure t)               ;; always ensure packages are present
(setq-default indent-tabs-mode nil)              ;; turn off tab indentation
(setq-default cursor-type 'hbar)                 ;; cursor is a horizontal bar
(setq bookmark-default-file fcuny-bookmarks-dir) ;; where to save bookmarks
(setq bookmark-save-flag 1)                      ;; save bookmarks when emacs qui
(setq vc-handled-backends nil)                   ;; don't use the VC backend, it's too slow with source
(setq-default frame-title-format "%b (%f)")      ;; set full path in the frame title
(setq-default delete-by-moving-to-trash t)       ;; delete files by moving them to the trash
(setq initial-scratch-message "")                ;; empty scratch buffer

(fringe-mode '(10 . 10))                         ;; size of the fringe

(custom-set-variables
 '(tool-bar-mode nil)
 '(scroll-bar-mode nil)
 '(use-file-dialog nil)
 '(use-dialog-box nil)
 '(blink-cursor-mode nil)
 '(inhibit-startup-screen t)
 '(inhibit-startup-message t)
 '(inhibit-startup-echo-area-message t))

(use-package frame
  :ensure nil
  :bind (("C-c C-m" . toggle-frame-fullscreen))
  :config
  ;; when using darwin I don't want to use the native full screen mode, as it opens a new work space
  (when (eq system-type 'darwin)
    (setq ns-use-native-fullscreen nil))
  (set-face-attribute 'default nil :height 130 :weight 'normal :width 'normal))

(use-package general
  :config
  (general-define-key
   "M-j" 'join-line))

;;; emacs hygiene

(use-package midnight
  :config
  (midnight-mode t))

(use-package server
  :no-require
  :hook (after-init . server-start))

(use-package exec-path-from-shell
  :if (memq window-system '(mac ns))
  :config
  (exec-path-from-shell-initialize)
  (if (fc/check-work-machine-p)
      (dolist (var '("GEM_HOME" "GEM_PATH" "MY_RUBY_HOME"))
        (unless (getenv var)
          (exec-path-from-shell-copy-env var)))))

;;; general editing

(use-package recentf
  :config
  (recentf-mode 1)
  (setq recentf-max-saved-items 500
        recentf-save-file (expand-file-name "var/recentf" user-emacs-directory)))

(use-package autorevert
  :config
  (setq global-auto-revert-non-file-buffers t)
  (setq auto-revert-verbose nil)
  (global-auto-revert-mode t))

;;; packages management

(use-package auto-package-update
  :custom
  (auto-package-update-delete-old-versions t)
  (auto-package-update-hide-results t)
  (auto-package-update-last-update-day-filename (expand-file-name "last-package-update-day" fcuny-path-emacs-var))
  :hook
  (after-init . auto-package-update-maybe))

;;; visual

(use-package hl-line
  :config
  (global-hl-line-mode t))

(use-package uniquify
  :ensure nil
  :defer 5
  :config
  (setq uniquify-ignore-buffers-re "^\\*") ; don't muck with special buffers
  (setq uniquify-buffer-name-style 'forward)
  (setq uniquify-separator "/"))

;;; files navigation

(use-package ag
  :bind (:map ag-mode-map
              ("p" . compilation-previous-error)
              ("n" . compilation-next-error)
              ("N" . compilation-next-file)
              ("P" . compilation-previous-file))
  :custom
  (ag-highlight-search t)
  (ag-reuse-buffers t)
  (ag-reuse-window t))

(use-package dired
  :ensure nil
  :defer t
  :bind (("C-x C-d" . dired)
         ("C-x C-j" . dired-jump))
  :diminish dired-omit-mode
  :init
  (setq-default dired-dwim-target t)
  (setq-default dired-listing-switches "--group-directories-first -alh")
  (setq dired-recursive-deletes 'always)
  (setq dired-recursive-copies 'always)

  (let ((gls (executable-find "/opt/twitter/bin/gls")))
    (when gls (setq insert-directory-program gls))))

(use-package ibuffer
  :bind ("C-x C-b" . ibuffer))

;;; general text editing

(use-package flyspell
  :hook ((text-mode . flyspell-mode)
         (prog-mode . flyspell-prog-mode))
  :config
  (setq ispell-dictionary "en_US")

  (when (executable-find "aspell")
    (setq ispell-program-name "aspell"
          ispell-list-command "--list"))

  (use-package flyspell-correct
    :after (flyspell)
    :commands (flyspell-correct-word-generic
               flyspell-correct-previous-word-generic)
    :bind (:map flyspell-mode-map
                ("C-;" . flyspell-correct-previous-word-generic)))

  (use-package flyspell-correct-ivy
    :commands (flyspell-correct-ivy)
    :init (setq flyspell-correct-interface #'flyspell-correct-ivy)))

(use-package whitespace
  :custom
  (whitespace-style '(face trailing))
  (show-trailing-whitespace t)
  :hook (whitespace-mode))

(use-package electric-pair-mode
  :ensure nil
  :commands electric-pair-mode
  :init (add-hook 'prog-mode-hook 'electric-pair-mode))

(use-package paren
  :custom
  (show-paren-delay 0)
  :config
  (show-paren-mode 1))

;;; text formats

(use-package markdown-mode
  :after (flyspell)
  :commands (markdown-mode gfm-mode)
  :mode (("README\\.md\\'" . gfm-mode)
         ("\\.md\\'"       . gfm-mode)
         ("\\.markdown\\'" . gfm-mode)))

;;; source control

(use-package magit
  :after (flyspell)
  :hook ((magit-mode . hl-line-mode))
  :bind (("C-x g s" . magit-status))
  :config
  (setq magit-completing-read-function 'ivy-completing-read)
  (setq git-commit-summary-max-length 50)
  (setq git-commit-fill-column 72)
  (setq git-commit-turn-on-auto-fill t))

;;; project management

(use-package counsel
  :after (projectile ivy)
  :bind
  (("M-x"     . counsel-M-x)
   ("C-s"     . counsel-grep-or-swiper)
   ("C-x C-f" . counsel-find-file)
   ("C-x C-r" . counsel-recentf)
   ("C-c s"   . counsel-git-grep)
   ("C-c C-x" . counsel-command-history)
   ("C-c /"   . counsel-ag)
   ("C-c y"   . counsel-yank-pop))
  :custom
  (counsel-find-file-at-point t)
  :config
  (use-package swiper)
  (use-package counsel-projectile
    :config
    (counsel-projectile-mode)))

(use-package projectile
  :bind
  ("C-c p" . projectile-command-map)
  :init
  (add-hook 'after-init-hook #'projectile-mode)
  :config
  (setq projectile-switch-project-action 'projectile-dired
        projectile-enable-caching t
        projectile-completion-system 'ivy
        projectile-known-projects-file (expand-file-name "var/projectile-bookmarks.eld" user-emacs-directory)
        projectile-cache-file (expand-file-name "var/projectile.cache" user-emacs-directory)
        projectile-globally-ignored-directories (append fcuny-projects-ignored-dirs
                                                        projectile-globally-ignored-directories)
        projectile-globally-ignored-files (append projectile-globally-ignored-files)))

;;; prog mode

(use-package flycheck
  :custom
  (flycheck-idle-change-delay 2)
  :config
  (setq-default flycheck-disabled-checkers '(html-tidy emacs-lisp emacs-lisp-checkdoc))
  (global-flycheck-mode))

(use-package lisp-mode
  :ensure nil
  :bind
  (("C-c C-e" . eval-buffer)
   ("C-c C-r" . eval-region)))

(use-package make-mode
  :config
  (add-hook 'makefile-mode-hook (lambda () (setq-local tab-width 2))))

(use-package go-mode
  :preface
  (defun fcuny/go-mode-setup ()
    (setq-default)
    (setq tab-width 2))
  :config
  (add-hook 'go-mode-hook #'fcuny/go-mode-setup))

(use-package python
  :mode (("\\.py$"   . python-mode)
         ("\\.wsgi$" . python-mode))
  :commands python-mode
  :custom (python-indent-offset 2))

(use-package scala-mode)

(use-package sh-script
  :after (flycheck)
  :mode ("bashrc" . sh-mode)
  :hook (after-save . executable-make-buffer-file-executable-if-script-p)
  :config
  (setq-default sh-indentation 2
                sh-basic-offset 2))

;;; configurations

(use-package docker
  :bind ("C-c d" . docker)
  :diminish)

(use-package docker-compose-mode
  :mode "docker-compose.*\.yml\\'")

(use-package docker-tramp
  :after tramp
  :defer 5)

(use-package dockerfile-mode
  :mode "Dockerfile[a-zA-Z.-]*\\'")

(use-package gitconfig-mode
  :defer 5)

(use-package puppet-mode)

(use-package yaml-mode)

(use-package json-mode
  :after (flyspell)
  :custom
  (json-reformat:indent-width 2)
  (js-indent-level 2)
  :hook ((json-mode . flyspell-prog-mode))
  :init
  (if (fc/check-work-machine-p)
    (add-to-list 'auto-mode-alist '("\\.workflow$" . json-mode))))

(use-package protobuf-mode
  :after (flyspell)
  :hook ((protobuf-mode . flyspell-prog-mode)))