Emacs Configuration File

(add-hook 'emacs-startup-hook
          (lambda ()
            (message "Emacs ready in %s with %d garbage collections."
                     (format "%.2f seconds"
                             (float-time
                              (time-subtract after-init-time before-init-time)))
                     gcs-done)))

(setq custom-file (expand-file-name "custom.el" user-emacs-directory))
(load custom-file 'noerror)

(setq confirm-kill-emacs 'yes-or-no-p)

(defun append-to-list (list-var elements)
  "Append ELEMENTS to the end of LIST-VAR.

The return value is the new value of LIST-VAR."
  (unless (consp elements)
    (error "ELEMENTS must be a list"))
  (let ((list (symbol-value list-var)))
    (if list
        (setcdr (last list) elements)
      (set list-var elements)))
  (symbol-value list-var))

;;; Increment Numbers
(defun increment-number-at-point ()
  "Increments numbers at cursor"
  (interactive)
  (skip-chars-backward "0-9")
  (or (looking-at "[0-9]+")
      (error "No number at point"))
  (replace-match (number-to-string (1+ (string-to-number (match-string 0))))))

;;; Decrement Numbers
(defun decrement-number-at-point ()
  "Decrements numbers at cursor"
  (interactive)
  (skip-chars-backward "0-9")
  (or (looking-at "[0-9]+")
      (error "No number at point"))
  (replace-match (number-to-string (1- (string-to-number (match-string 0))))))

;;; Binding
(global-set-key (kbd "C-; C-=") 'increment-number-at-point)
(global-set-key (kbd "C-; C--") 'decrement-number-at-point)

(defun insertdirectory ()
  "Insert current directory for macro use"
  (interactive)
  (insert default-directory))

(defun ignore-error-wrapper (fn)
  "Funtion return new function that ignore errors.
     The function wraps a function with `ignore-errors' macro."
  (lexical-let ((fn fn))
    (lambda ()
      (interactive)
      (ignore-errors
        (funcall fn)))))

(defun insert-org-image (&optional swindow)
  "Prompt user for name of file, append time and date string, then use the Mac OSX `screencapture` feature to take a photo and place it in the relative ./figures directory."
  (interactive "P")
  (unless (not (eq system-type 'darwin))
    (let* ((outdir (concat (file-name-directory (buffer-file-name)) "/figures"))
           (namefile (concat (read-string "Enter File Name: ") "_" (format-time-string "%Y%m%d_%H%M%S.jpeg"))))
      (if (char-equal (aref namefile 0) ?_)
          (setq namefile (substring namefile 1 (length namefile))))
      (let* ((outfile (expand-file-name namefile outdir)))
        (unless (file-directory-p outdir)
          (make-directory outdir t))
        (message "Argument: %s" swindow)
        (if swindow
            (call-process "screencapture" nil nil nil "-w" outfile)
          (call-process "screencapture" nil nil nil "-i" outfile))
        (message namefile)
        (insert (concat (concat "[[file:./figures/" (file-name-nondirectory outfile)) "]]"))))
    )
  )

(set-keyboard-coding-system nil)

(defun pgw/dired-open-file ()
  "In dired, open the file named on this line using the default application in the system."
  (interactive)
  (let ((file (dired-get-filename nil t)) ; Full path
        (filename (dired-get-filename t t))) ; File name for display
    (message "Opening %s..." filename)
    (call-process "open" nil 0 nil file)
    (message "Opening %s done" filename)))

(defun pgw/copy-mla-file ()
  "Copy MLA_OrgFile.org to current directory for use in school essays."
  (interactive)
  (copy-file "~/Dropbox/org/templates/school/MLA_OrgFile.org" default-directory)
  )

(when (eq system-type 'darwin)
  (defun pgw/lookup-dictionary ()
    "Function to open a dictionary searching the highlighted word
No spaces are allowed in the input of this function"
    (interactive)
    (let ((word (read-from-minibuffer "Word query: ")))
      (call-process "open" nil nil nil (concat "dict://" word)))
    )
  (global-set-key (kbd "M-#") 'pgw/lookup-dictionary)
  )

(defun internet-up-p (&optional host)
  (= 0 (call-process "ping" nil nil nil "-c" "1" "-W" "1"
                     (if host host "1.1.1.1"))))

(defun pgw/org-get-link-at-point ()
  "Get the link from an org heading"
  (interactive)
  (let* ((context (org-element-context))
         (link (if (eq (car context) 'link)
                   (org-element-property :path context)
                 nil)))
    (if link (kill-new (concat (org-element-property :type context) ":" link)))))

(global-set-key (kbd "C-c s-l") 'pgw/org-get-link-at-point)

(defun make-shell (name)
  "Create a shell buffer named NAME."
  (interactive "sName: ")
  (setq name (concat "$" name))
  (eshell 4)
  (rename-buffer name))

(use-package all-the-icons)

(use-package doom-themes
  :config
  ;; Global settings (defaults)
  (setq doom-themes-enable-bold t    ; if nil, bold is universally disabled
      doom-themes-enable-italic t) ; if nil, italics is universally disabled

  ;; Load the theme (doom-one, doom-molokai, etc); keep in mind that each theme
  ;; may have their own settings.
  (load-theme 'doom-outrun-electric t)

  ;; Enable flashing mode-line on errors
  (doom-themes-visual-bell-config)

  ;; Enable custom neotree theme (all-the-icons must be installed!)
  ;; (doom-themes-neotree-config)
  ;; or for treemacs users
  (setq doom-themes-treemacs-theme "doom-colors") ; use the colorful treemacs theme
  (doom-themes-treemacs-config)

  ;; Doom themes fontifies #hashtags and @at-tags by default.
  ;; To disable this:
  (setq doom-org-special-tags nil)

  ;; Corrects (and improves) org-mode's native fontification.
  (doom-themes-org-config)
  )

(load-theme 'modus-operandi)

(setq frame-resize-pixelwise t)

(when (fboundp 'windmove-default-keybindings)
  (global-set-key (kbd "H-h") (ignore-error-wrapper 'windmove-left))
  (global-set-key (kbd "H-l") (ignore-error-wrapper 'windmove-right))
  (global-set-key (kbd "H-k") (ignore-error-wrapper 'windmove-up))
  (global-set-key (kbd "H-j") (ignore-error-wrapper 'windmove-down))
  )

;; Disabled, Doesn't really work for me - going to use s-left and s-right instead
;; (use-package framemove
;;   :load-path "custom_load"
;;   :config
;;   (require 'framemove)
;;   (global-set-key (kbd "C-e-<down>")  'fm-down-frame)
;;   (global-set-key (kbd "C-s-<up>")    'fm-up-frame)
;;   (global-set-key (kbd "C-s-<left>")  'fm-left-frame)
;;   (global-set-key (kbd "C-s-<right>") 'fm-right-frame)
;;   (setq framemove-hook-into-windmove t)
;;   )

(use-package rotate
  :load-path "site-lisp/emacs-rotate")

(setq pgw/default-font "Menlo")
(setq pgw/default-font-size 12)
(setq pgw/current-font-size pgw/default-font-size)

(setq pgw/font-change-increment 1.1)

(defun pgw/font-code ()
  "Return a string representing the current font (like \"Inconsolata-14\")."
  (concat pgw/default-font "-" (number-to-string pgw/current-font-size)))

(defun pgw/set-font-size ()
  "Set the font to `pgw/default-font' at `pgw/current-font-size'.
Set that for the current frame, and also make it the default for
other, future frames."
  (interactive)
  (let ((font-code (pgw/font-code)))
    (if (assoc 'font default-frame-alist)
        (setcdr (assoc 'font default-frame-alist) font-code)
      (add-to-list 'default-frame-alist (cons 'font font-code)))
    (set-frame-font font-code)))

(defun pgw/reset-font-size ()
  "Change font size back to `pgw/default-font-size'."
  (interactive)
  (setq pgw/current-font-size pgw/default-font-size)
  (pgw/set-font-size))

(defun pgw/increase-font-size ()
  "Increase current font size by a factor of `pgw/font-change-increment'."
  (interactive)
  (setq pgw/current-font-size
        (ceiling (* pgw/current-font-size pgw/font-change-increment)))
  (pgw/set-font-size))

(defun pgw/decrease-font-size ()
  "Decrease current font size by a factor of `pgw/font-change-increment', down to a minimum size of 1."
  (interactive)
  (setq pgw/current-font-size
        (max 1
             (floor (/ pgw/current-font-size pgw/font-change-increment))))
  (pgw/set-font-size))

(define-key global-map (kbd "C-)") 'pgw/reset-font-size)
(define-key global-map (kbd "C-H-0") 'pgw/set-font-size)
(define-key global-map (kbd "C-+") 'pgw/increase-font-size)
(define-key global-map (kbd "C-=") 'pgw/increase-font-size)
(define-key global-map (kbd "C-_") 'pgw/decrease-font-size)
(define-key global-map (kbd "C--") 'pgw/decrease-font-size)

(add-hook 'emacs-startup-hook
          (lambda () (interactive) (pgw/reset-font-size)))

(set-face-attribute 'variable-pitch nil :family "Avenir Next")

(use-package mixed-pitch
  :load-path "custom_load"
  :config
  ;; (set-face-attribute 'variable-pitch :height 160)
  (dolist (face '(line-number line-number-current-line org-list-dt org-link)) (add-to-list 'mixed-pitch-fixed-pitch-faces face))
  ;; (add-hook 'text-mode-hook 'mixed-pitch-mode)
  (global-set-key (kbd "C-x v f") 'mixed-pitch-mode)
  )

(use-package smart-mode-line
  :config
  (setq rm-blacklist '(" hl-p" " WK" " yas" " Undo-Tree" " hs")
        ;; sml/theme 'light
        sml/name-width 30
        )
  (add-to-list 'sml/replacer-regexp-list '("^~/Google Drive/OHS/\\([0-9]\\{2\\}\\)th Grade/Classes/Semester [0-9]/\\([0-9A-Z]*\\)/" ":\\2:"))
  (add-hook 'after-init-hook 'sml/setup)
  )

(use-package powerline
  :ensure t
  :config (powerline-default-theme))

(size-indication-mode 1)
(line-number-mode -1)

(setq display-time-format "%a %m/%d %H:%M")
(display-time-mode)

(setq battery-mode-line-format " [%b%p%%]")
(display-battery-mode)

(use-package helm
  :config
  (require 'helm-config)
  (helm-mode 1)
  (define-key global-map [remap find-file] 'helm-find-files)
  (define-key global-map [remap occur] 'helm-occur)
  (define-key global-map [remap list-buffers] 'helm-buffers-list)
  (define-key global-map [remap dabbrev-expand] 'helm-dabbrev)
  (define-key global-map [remap execute-extended-command] 'helm-M-x)
  (unless (boundp 'completion-in-region-function)
    (define-key lisp-interaction-mode-map [remap completion-at-point] 'helm-lisp-completion-at-point)
    (define-key emacs-lisp-mode-map       [remap completion-at-point] 'helm-lisp-completion-at-point))
  )

(use-package ivy
  :config
  (ivy-mode 1)
  (setq ivy-use-virtual-buffers t)
  (setq enable-recursive-minibuffers t)
  ;; enable this if you want `swiper' to use it
  ;; (setq search-default-mode #'char-fold-to-regexp)
  (global-set-key "\C-s" 'swiper)
  (global-set-key (kbd "C-c C-r") 'ivy-resume)
  (global-set-key (kbd "<f6>") 'ivy-resume)
  (global-set-key (kbd "M-x") 'counsel-M-x)
  (global-set-key (kbd "C-x C-f") 'counsel-find-file)
  (global-set-key (kbd "<f1> f") 'counsel-describe-function)
  (global-set-key (kbd "<f1> v") 'counsel-describe-variable)
  (global-set-key (kbd "<f1> o") 'counsel-describe-symbol)
  (global-set-key (kbd "<f1> l") 'counsel-find-library)
  (global-set-key (kbd "<f2> i") 'counsel-info-lookup-symbol)
  (global-set-key (kbd "<f2> u") 'counsel-unicode-char)
  (global-set-key (kbd "C-c g") 'counsel-git)
  (global-set-key (kbd "C-c j") 'counsel-git-grep)
  (global-set-key (kbd "C-c k") 'counsel-ag)
  (global-set-key (kbd "C-x l") 'counsel-locate)
  (global-set-key (kbd "C-S-o") 'counsel-rhythmbox)
  (define-key minibuffer-local-map (kbd "C-r") 'counsel-minibuffer-history))

;(setq org-agenda-include-diary t)
(setq diary-file "~/Dropbox/org/diary")

(appt-activate -1)
(setq appt-message-warning-time 15)
(setq diary-comment-start "##")

(setq org-directory "~/Dropbox/org")
(setq org-default-notes-file (concat org-directory "/inbox.org"))

(setq org-startup-indented t)

(setq org-todo-keywords
      '((sequence "NEXT(n)" "TODO(t)" "IN-PROGRESS(i)" "WAITING(w)" "|" "DONE(d)" "CANCELLED(c)" "DELEGATED(g)")))

(define-key global-map "\C-cc" 'org-capture)
  (global-set-key (kbd "H-c o") 
                  (lambda () (interactive) (find-file (concat org-directory "/school.org"))))
  (global-set-key (kbd "H-c p") 
                  (lambda () (interactive) (dired "~/Google Drive/OHS/11th Grade/Semester 2/")))
  (global-set-key (kbd "H-c i") 
                  (lambda () (interactive) (find-file (concat org-directory "/projects.org"))))
  (global-set-key (kbd "H-c v") 
                  (lambda () (interactive) (find-file (concat org-directory "/violin.org"))))
  (global-set-key (kbd "H-c n") 
                  (lambda () (interactive) (find-file (concat org-directory "/notes.org"))))
  (global-set-key (kbd "H-c m") 
                  (lambda () (interactive) (find-file (concat org-directory "/music.org"))))
  (global-set-key (kbd "H-c k") 
                  (lambda () (interactive) (find-file (concat org-directory "/links.org"))))

  ;;; Agenda key (C-c a) and other settings
  (global-set-key "\C-cl" 'org-store-link)
  (global-set-key "\C-ca" 'org-agenda)
  (global-set-key "\C-cc" 'org-capture)
  (global-set-key "\C-cb" 'org-switchb)

  (evil-define-key 'normal org-mode-map "<<" 'org-promote-subtree)
  (evil-define-key 'normal org-mode-map ">>" 'org-demote-subtree)

(setq org-tag-persistent-alist '(("email" . ?e)
                                 ("noexport" . ?N)))

(setq org-log-done 'time) ; Log when task marked as done

(setq pgw/refile-targets (file-expand-wildcards "~/Dropbox/org/*.org"))
(setq org-refile-targets '((nil :maxlevel . 9)
                           (org-agenda-files :maxlevel . 9)
                           (pgw/refile-targets :maxlevel . 9)))
(setq org-refile-use-outline-path 'file)
(setq org-outline-path-complete-in-steps nil)
(setq org-refile-allow-creating-parent-nodes 'confirm)

;; org-agenda-auto-exclude-function
(defun pgw/org-my-auto-exclude-function (tag)
  (if
      (string= tag "officehours")
      (concat "-" tag)))
(setq org-agenda-auto-exclude-function 'pgw/org-my-auto-exclude-function)

;(setq org-agenda-overriding-columns-format "%28ITEM %TODO %SCHEDULED %DEADLINE %TAGS")

;; Re-align tags when window shape changes
(add-hook 'org-agenda-mode-hook
          (lambda () (add-hook 'window-configuration-change-hook 'org-agenda-align-tags nil t)))

;(add-hook 'org-agenda-finalize-hook
;         'org-agenda-align-tags)

(setq org-deadline-warning-days 7)

(add-hook 'org-agenda-finalize-hook
          (lambda ()
            (display-line-numbers-mode -1)
            ))

;; Org entries
(setq org-agenda-max-entries nil)

(use-package org-super-agenda
  :config
  (org-super-agenda-mode)
  )
(setq org-agenda-custom-commands
      '(("z" "Super zaen view"
         ((agenda "" ((org-agenda-span 'day)
                      (org-super-agenda-groups
                       '((:name "Text"
                                :time-grid t
                                :date today
                                :todo "TODO"
                                :scheduled today
                                :deadline today
                                :order 1)
                         (:name "School Stuff"
                                :tag "OHS"
                                :order 2)
                         ))))
          (alltodo "" ((org-agenda-overriding-header "")
                       (org-super-agenda-groups
                        '((:name "Due Today"
                                 :deadline today
                                 :order 2)
                          (:name "OHS"
                                 :tag "OHS"
                                 :order 10)
                          (:name "Due Soon"
                                 :deadline future
                                 :order 8)
                          (:name "Overdue"
                                 :deadline past
                                 :order 9)
                          (:name "Issues"
                                 :tag "Issue"
                                 :order 12)
                          (:name "Emacs"
                                 :tag "Emacs"
                                 :order 13)
                          (:name "Waiting"
                                 :todo "WAITING"
                                 :order 20)
                          (:name "trivial"
                                 :priority<= "C"
                                 :tag "someday"
                                 :order 90)
                          (:discard (:habit t)
                                    )))))))
        )
      )

(defun pgw/year-month ()
  "Custom function to return date in format: YYYY-MM"
  (format-time-string "%Y-%m"))

(defun pgw/U ()
  "Custom function to return date in org inactive timestamp format"
  (format-time-string "[%Y-%m-%d %a]"))

(defun pgw/add-12 ()
  "Custom function return active org timestamp with exactly 24 hour difference"
  (format-time-string "%Y-%m-%d %a %H:%M" (time-add (current-time) 85500)))

(defun pgw/headline_date ()
  "Function to find the date as headline for Violin capture template"
  (goto-char (point-min))
  (let ((searchresults (search-forward (format-time-string "[%Y-%m-%d %a]") nil t)))
    (if searchresults
        'searchresults
      (error "Not found! Use Vc to create today's practice first.")
      )
    )
  )

(setq org-capture-templates
      '(
("i" "Inbox")
("ii" "Inbox Entry" entry (file "~/Dropbox/org/inbox.org")
"* NEXT %?
")
("il" "Inbox w/ Link" entry (file "~/Dropbox/org/inbox.org")
"* NEXT %?
%a
")
("in" "Quick Note" entry (file "~/Dropbox/org/inbox.org")
"* %?
%U")
("e" "Events")
("ef" "Emacs Event (Not synced)" entry (file "~/Dropbox/org/events.org")
 "* %?")
("ee" "Emacs Calendar (Limbo)" entry (file "~/Dropbox/org/events.org")
 "* %^{Title of event}
SCHEDULED: %^{Scheduled time + duration}T
:PROPERTIES:
:calendar-id: ihfv2u5n9uf5ksj5484vbe7mj4@group.calendar.google.com
:END:
:org-gcal:%?
:END:" :jump-to-captured t)
("ep" "Gmail Calendar (Limbo)" entry (file "~/Dropbox/org/events.org")
 "* %^{Title of event}
SCHEDULED: %^{Scheduled time + duration}T
:PROPERTIES:
:calendar-id: pierce.g.wang@gmail.com
:END:
:org-gcal:%?
:END:" :jump-to-captured t)
("es" "SFCM Calendar (Limbo)" entry (file "~/Dropbox/org/sfcm.org")
 "* %^{Title of event}
SCHEDULED: %^{Scheduled time + duration}T
:PROPERTIES:
:calendar-id: taiu2dsr8o29c09m7nn1n21t9o@group.calendar.google.com
:END:
:org-gcal:%?
:END:" :jump-to-captured t)
("L" "Link" entry (file+headline "~/Dropbox/org/links.org" "!Inbox")
"* [[%?%:link][%:description]]
:PROPERTIES:
:CREATED:  %U
:END:" :prepend t)
("g" "Manual" entry (file "~/Dropbox/org/notes.org")
"* %?
:PROPERTIES:
:CREATED:  %U
:END:" :empty-lines 1)
("b" "Book" entry (file+headline "~/Dropbox/org/notes.org" "Books")
 "* %^{RATING}p%^{Book Title}")
("j" "Journal" entry
(file+olp+datetree "~/Dropbox/org/orgjournal.org.gpg")
"* %?
:PROPERTIES:
:LOGGED: %^{Logged Time}U
:END:
" :kill-buffer t)
("m" "Mail")
("mt" "Mail task" entry
 (file "~/Dropbox/org/inbox.org")
 "* NEXT %? :email:
:PROPERTIES:
:EMAIL: %a
:SENDER: %:from
:END:\n")
("mn" "Mail note" entry
 (file "~/Dropbox/org/inbox.org")
 "* %? :email:
:PROPERTIES:
:EMAIL: %a
:SENDER: %:from
:END:\n")
("S" "School")
("St" "School Tasks")
("Stj" "OCS15 - T/Th" entry
 (file+headline "~/Dropbox/org/school.org" "_OCS15_")
 "* NEXT %?
DEADLINE: %^{Deadline}T\n")
("Stm" "UM51A - T/Th" entry
 (file+headline "~/Dropbox/org/school.org" "_UM51A_")
 "**** NEXT %?
DEADLINE: %^{Deadline}T\n")
("Sts" "OPS10 - M/W" entry
 (file+headline "~/Dropbox/org/school.org" "_OPS10_")
 "* NEXT %?
DEADLINE: %^{Deadline}T\n")
("Stp" "OP051 - M/W" entry
 (file+headline "~/Dropbox/org/school.org" "_OP051_")
 "* NEXT %?
DEADLINE: %^{Deadline}T\n")
("Stc" "OCRA1 - M/W" entry
 (file+headline "~/Dropbox/org/school.org" "_OCRA1_")
 "* NEXT %?
DEADLINE: %^{Deadline}T\n")
("Sr" "School Readings")
("Srj" "OCS15 - T/Th" entry
 (file+headline "~/Dropbox/org/school.org" "_OCS15_")
 "* NEXT %?
DEADLINE: <%<%Y-%m-%d %a 07:15>>\n")
("Srm" "UM51A - T/Th" entry
 (file+headline "~/Dropbox/org/school.org" "_UM51A_")
 "**** NEXT %?
DEADLINE: <%<%Y-%m-%d %a 08:30>>\n")
("Srs" "OPS10 - M/W" entry
 (file+headline "~/Dropbox/org/school.org" "_OPS10_")
 "* NEXT %?
DEADLINE: <%<%Y-%m-%d %a 11:00>>\n")
("Srp" "OP051 - M/W" entry
 (file+headline "~/Dropbox/org/school.org" "_OP051_")
 "* NEXT %?
DEADLINE: <%<%Y-%m-%d %a 14:45>>\n")
("Src" "OCRA1 - M/W" entry
 (file+headline "~/Dropbox/org/school.org" "_OCRA1_")
 "* NEXT %?
DEADLINE: <%<%Y-%m-%d %a 09:45>>\n")
("M" "Music")
("Mc" "Conducting Homework" entry
 (file+headline "~/Dropbox/org/music.org" "Homework")
 "* TODO Conducting Homework
DEADLINE: %^t
- %?")
("V" "Violin")
("Vc" "Create Practice Entry" entry
 (file+olp "~/Dropbox/org/violin.org" "Practice Log")
 "* [%<%Y-%m-%d %a>]
%t%?")
("Vd" "Add practice details" item
 (file+function "~/Dropbox/org/violin.org" pgw/headline_date)
 "%?")
("f" "Fun")
("fc" "Cookie Clicker Save" entry
 (file+olp "~/Dropbox/org/notes.org" "Cookie Clicker Run [2020-09-14 Mon]")
 "* %U
%?
: %c
")
("q" "Quotes" entry
 (file+olp "~/Dropbox/org/notes.org" "Quotes")
 "* %?
:PROPERTIES:
:DATE:     %U
:END:
%^{FROM}p
")))

;; Set to the name of the file where new notes will be stored
(setq org-mobile-inbox-for-pull "~/Dropbox/Apps/MobileOrg/index.org")
;; Set to <your Dropbox root directory>/MobileOrg.
(setq org-mobile-directory "~/Dropbox/Apps/MobileOrg")

(use-package org-crypt
  :load-path "elpa/org-9.2.3"
  :config
  (org-crypt-use-before-save-magic)
  (setq org-tags-exclude-from-inheritance (quote ("crypt")))

  (setq org-crypt-key "3C44F187958295E4")
  ;; GPG key to use for encryption
  ;; Either the Key ID or set to nil to use symmetric encryption.

  (setq auto-save-default nil)
  ;; Auto-saving does not cooperate with org-crypt.el: so you need
  ;; to turn it off if you plan to use org-crypt.el quite often.
  ;; Otherwise, you'll get an (annoying) message each time you
  ;; start Org.

  ;; To turn it off only locally, you can insert this:
  ;;
  ;; # -*- buffer-auto-save-file-name: nil; -*-
  :bind (("C-c s-d e" . org-encrypt-entry)
         ("C-c s-d d" . org-decrypt-entry))
  )

(with-eval-after-load 'org
  (org-babel-do-load-languages 'org-babel-load-languages
                               '((python . t)
                                 )))

;;; org-drill
(use-package org-drill
  :load-path "custom_load")

(require 'ox-latex)

(use-package org-superstar
  :config
  (setq org-superstar-prettify-item-bullets 'nil)
  :hook (org-mode . org-superstar-mode))

(use-package org-noter
  :after org
  :ensure t
  :config
  (setq org-noter-default-notes-file-names '("notes.org")
        org-noter-notes-search-path '("~/Dropbox/org/notes"))
  )

(use-package org-gcal
  :ensure t
  :demand t
  :bind (("C-c s-g p" . org-gcal-post-at-point)
         ("C-c s-g s" . org-gcal-sync)
         ("C-c s-g f" . org-gcal-fetch)
         ("C-c s-g d" . org-gcal-delete-at-point)
         ("C-c s-g b s" . org-gcal-sync-buffer)
         ("C-c s-g b f" . org-gcal-sync-buffer))
  :config
  (setq org-gcal-client-id pgw/org-gcal-client-id
        org-gcal-client-secret pgw/org-gcal-client-secret
        org-gcal-file-alist pgw/org-gcal-file-alist)
  (setq org-gcal-notify-p nil)
  (setq org-gcal-remove-api-cancelled-events t))

(setq org-reveal-root "file:///Users/piercewang/Documents/projects/revealjs/reveal.js-4.1.0")

(use-package tex
  :ensure auctex
  :defer t
  :config
  (setq TeX-auto-save t))

(unless (with-no-warnings (find "Times" org-latex-classes :key 'car
                                :test 'equal))
  (add-to-list 'org-latex-classes
               '("Times"
                 "\\documentclass[12pt]{article}
\\usepackage{fontspec}
\\setmainfont{Times New Roman}
\\usepackage{hyperref}"
                 ("\\section{%s}" . "\\section*{%s}")
                 ("\\subsection{%s}" . "\\subsection*{%s}")
                 ("\\subsubsection{%s}" . "\\subsubsection*{%s}")
                 ("\\paragraph{%s}" . "\\paragraph*{%s}")
                 ("\\subparagraph{%s}" . "\\subparagraph*{%s}"))))

;; (define-key evil-normal-state-map (kbd "<S-return>") [?m ?` ?o escape ?` ?`])
;; (define-key evil-normal-state-map (kbd "<s-S-return>") [?m ?` ?O escape ?` ?`])
(define-key evil-motion-state-map (kbd "k") 'evil-previous-visual-line)
(define-key evil-motion-state-map (kbd "j") 'evil-next-visual-line)
(define-key evil-motion-state-map (kbd "g k") 'evil-previous-line)
(define-key evil-motion-state-map (kbd "g j") 'evil-next-line)
(define-key evil-insert-state-map (kbd "C-a") 'beginning-of-visual-line)
(define-key evil-insert-state-map (kbd "C-e") 'end-of-visual-line)

(setq auto-mode-alist
      (cons '("\\.m$" . octave-mode) auto-mode-alist))
(add-hook 'octave-mode-hook
          (lambda ()
            (abbrev-mode 1)
            (auto-fill-mode 1)
            (if (eq window-system 'x)
                (font-lock-mode 1))))

(use-package projectile)
(use-package flycheck)
(use-package yasnippet :config (yas-global-mode))
(use-package lsp-mode :hook ((lsp-mode . lsp-enable-which-key-integration))
  :config (setq lsp-completion-enable-additional-text-edit nil))
(use-package hydra)
(use-package company)
(use-package lsp-ui)
(use-package lsp-java :config (add-hook 'java-mode-hook 'lsp))
(use-package dap-mode :after lsp-mode :config (dap-auto-configure-mode))
(use-package dap-java :ensure nil)
(use-package lsp-ivy)
(use-package lsp-treemacs)

(defun my-macro-query (arg)
  "Prompt for input using minibuffer during kbd macro execution.
With prefix argument, allows you to select what prompt string to use.
If the input is non-empty, it is inserted at point."
  (interactive "P")
  (let* ((query (lambda () (kbd-macro-query t)))
         (prompt (if arg (read-from-minibuffer "PROMPT: ") "Input: "))
         (input (unwind-protect
                    (progn
                      (add-hook 'minibuffer-setup-hook query)
                      (read-from-minibuffer prompt))
                  (remove-hook 'minibuffer-setup-hook query))))
    (unless (string= "" input) (insert input))))
(global-set-key "\C-xQ" 'my-macro-query)

(calendar-set-date-style 'iso)

(require 'tetris)
(define-key tetris-mode-map (kbd "z") 'tetris-rotate-prev)
(define-key tetris-mode-map (kbd "x") 'tetris-rotate-next)

(use-package retris
  :load-path "site-lisp/retris")

(use-package 2048-game
  :bind (:map 2048-mode-map
              ("h" . 2048-left)
              ("j" . 2048-down)
              ("k" . 2048-up)
              ("l" . 2048-right)))

(use-package which-key
  :config
  (which-key-mode)
  (setq which-key-popup-type 'side-window)
  (setq which-key-side-window-location 'bottom)
  )

(global-set-key (kbd "C-v") (lambda () (interactive) (scroll-up-command 1)))
(global-set-key (kbd "M-v") (lambda () (interactive) (scroll-down-command 1)))

(use-package ibuffer
  :config
  (global-set-key (kbd "C-x C-b") 'ibuffer))
(setq ibuffer-saved-filter-groups
      '(("default"
         ("emacs-config" (or (filename . "/.emacs.d/")
                             (filename . ".emacs.d/init.el")))
         ("OHS" (filename . "/Google Drive/OHS/"))
         ("Org" (filename . "/Dropbox/org/"))
         ("planner" (or
                    (name . "\*Calendar\*")
                    (name . "\*Org Agenda\*")
                    (name . "^diary$")))
         ;; ("Helm" (name . "\*helm.*"))
         ("Magit" (mode . Magit))
         ("ERC" (mode . erc-mode))
         ("Help" (or (name . "\*Help\*")
                     (name . "\*info\*")
                     (name . "\*GNU Emacs\*"))))))

(add-hook 'ibuffer-mode-hook
          (lambda ()
            (ibuffer-switch-to-saved-filter-groups "default")))
(define-key ibuffer-mode-map (kbd "P") nil)

(use-package bufler
  :bind (("C-x C-b" . bufler))
         ;; ("C-x b" . bufler-switch-buffer))
  :config
  (setf bufler-groups
        (bufler-defgroups
          (group
           ;; Subgroup collecting all named workspaces.
           (auto-workspace))
          (group
           ;; Subgroup collecting all `help-mode' and `info-mode' buffers.
           (group-or "*Help/Info*"
                     (mode-match "*Help*" (rx bos "help-"))
                     (mode-match "*Info*" (rx bos "info-"))))
          (group
           ;; Subgroup collecting all special buffers (i.e. ones that are not
           ;; file-backed), except `magit-status-mode' buffers (which are allowed to fall
           ;; through to other groups, so they end up grouped with their project buffers).
           (group-and "*Special*"
                      (lambda (buffer)
                        (unless (or (funcall (mode-match "Magit" (rx bos "magit-status"))
                                             buffer)
                                    (funcall (mode-match "Dired" (rx bos "dired"))
                                             buffer)
                                    (funcall (auto-file) buffer))
                          "*Special*")))
           (group
            ;; Subgroup collecting these "special special" buffers
            ;; separately for convenience.
            (name-match "**Special**"
                        (rx bos "*" (or "Messages" "Warnings" "scratch" "Backtrace") "*")))
           (group
            ;; Subgroup collecting all other Magit buffers, grouped by directory.
            (mode-match "*Magit* (non-status)" (rx bos (or "magit" "forge") "-"))
            (auto-directory))
           ;; Remaining special buffers are grouped automatically by mode.
           (auto-mode))
          ;; All buffers under "~/.emacs.d" (or wherever it is).
          (dir user-emacs-directory)
          (group
           ;; Subgroup collecting buffers in `org-directory' (or "~/org" if
           ;; `org-directory' is not yet defined).
           (dir (if (bound-and-true-p org-directory)
                    org-directory
                  "~/org"))
           (dir "~/Dropbox/org/notes/")
           (dir "~/Dropbox/org/notes/college/essays/" 1)
           (group
            ;; Subgroup collecting indirect Org buffers, grouping them by file.
            ;; This is very useful when used with `org-tree-to-indirect-buffer'.
            (auto-indirect)
            (auto-file))
           ;; Group remaining buffers by whether they're file backed, then by mode.
           (group-not "*special*" (auto-file))
           (auto-mode))
          (group
           ;; Subgroup for OHS things
           (dir "~/Google Drive/OHS/")
           (dir "~/Google Drive/OHS/12th Grade/Classes/" 1)
           (dir "~/Google Drive/OHS/11th Grade/" 2)
           ;; Group remaining buffers by whether they're file backed, then by mode.
           (group-not "*special*" (auto-file))
           (auto-mode))
          (dir "/Volumes/" 1)
          (group
           ;; Subgroup collecting buffers in a projectile project.
           (auto-projectile))
          (group
           ;; Subgroup collecting buffers in a version-control project,
           ;; grouping them by directory.
           (auto-project))
          ;; Group remaining buffers by directory, then major mode.
          (auto-directory)
          (auto-mode))))

(use-package dired-quick-sort
  :load-path "custom_load"
  :config
  (dired-quick-sort-setup)
  )

(setq dired-listing-switches "-alh")

(use-package mu4e-alert
  :ensure t
  :after mu4e
  :init
  (setq mu4e-alert-interesting-mail-query
        (concat
         "flag:unread maildir:/pierce.wang.violin/INBOX "
         "OR "
         "flag:unread maildir:/pierce.g.wang/INBOX"
         ))
  (mu4e-alert-set-default-style 'notifier)
  (add-hook 'after-init-hook #'mu4e-alert-enable-notifications)
  (add-hook 'after-init-hook #'mu4e-alert-enable-mode-line-display)
  (defun pgw/fetch-mail-and-mu4e ()
    (interactive)
    (if (internet-up-p)
        (mu4e-update-mail-and-index t))
    )
  ;; (run-with-timer 60 300 'pgw/fetch-mail-and-mu4e)
  )

(global-unset-key (kbd "C-x m"))
(global-set-key (kbd "C-x m n") (lambda () "Open mu4e in a new frame" (interactive) (make-frame '((name . "Mail: mu4e"))) (mu4e)))
(global-set-key (kbd "C-x m b") (lambda () "Open mu4e in the background" (interactive) (mu4e t)))
(global-set-key (kbd "C-x m m") 'mu4e)
(global-set-key (kbd "C-x m c") 'mu4e-compose-new)

(defun pgw/date-block (absolute y1 m1 d1 y2 m2 d2)
  "Block date entry. An adapted version of the `diary-block'
function from the diary-lib."
  (let ((date1 (calendar-absolute-from-gregorian
                (diary-make-date y1 m1 d1)))
        (date2 (calendar-absolute-from-gregorian
                (diary-make-date y2 m2 d2)))
        (d absolute))
    (and (<= date1 d) (<= d date2))))

(defun pgw/date-date (absolute year month day)
  "Check for equality of date"
  (equal absolute (calendar-absolute-from-gregorian (diary-make-date year month day))))

(defun pgw/check-ohs-class (absolute classname semesters days times fallstart fallend springstart mononfri springend holidays noclasses)
  "Returns a list with formatted strings: (classname curdate
headline). These can then be used to create the headline. The curdate
is in the form of a list"
  (let* ((dayname (calendar-day-of-week (calendar-gregorian-from-absolute absolute)))
         (curdate (calendar-gregorian-from-absolute absolute))
         (periods '("06:00-07:15"
                    "07:15-08:30"
                    "08:30-09:45"
                    "09:45-11:00"
                    "11:00-12:15"
                    "12:15-13:30"
                    "13:30-14:45"
                    "14:45-16:00"
                    "16:00-17:15"
                    "17:15-18:30"
                    "18:30-19:45"
                    "19:45-21:00"
                    "21:00-22:15"))
         (time (if (equal (type-of times) 'integer) ;; Checks if the times argument is an integer or list of times as strings
                   (nth (1- times) periods)
               (nth (- (length days) (length (memq dayname days))) times))))
    (when (and (cond ((equal days '(1 3)) (or (memq dayname '(1 3)) (pgw/date-date absolute (nth 0 mononfri) (nth 1 mononfri) (nth 2 mononfri)))) ;; Account for MLK Monday on Friday
                     (t (memq dayname days)))
               (or (if (memq 1 semesters) (pgw/date-block absolute (nth 0 fallstart) (nth 1 fallstart) (nth 2 fallstart)
                                                         (nth 0 fallend) (nth 1 fallend) (nth 2 fallend)))
                   (if (memq 2 semesters) (pgw/date-block absolute (nth 0 springstart) (nth 1 springstart) (nth 2 springstart)
                                                          (nth 0 springend) (nth 1 springend) (nth 2 springend)))))
      (if (equal (type-of times) 'integer) ;; Classes will always be in periods, OH and other events will not
          (when (and (not (memq 't
                                (mapcar (lambda (holiday) (if (> (length holiday) 3)
                                                              (pgw/date-block absolute (nth 0 holiday) (nth 1 holiday) (nth 2 holiday) (nth 3 holiday) (nth 4 holiday) (nth 5 holiday))
                                                            (pgw/date-date absolute (nth 0 holiday) (nth 1 holiday) (nth 2 holiday))))
                                        holidays)))
                     (not (memq 't
                                (mapcar (lambda (noclass) (if (> (length noclass) 3)
                                                              (pgw/date-block absolute (nth 0 noclass) (nth 1 noclass) (nth 2 noclass) (nth 3 noclass) (nth 4 noclass) (nth 5 noclass))
                                                            (pgw/date-date absolute (nth 0 noclass) (nth 1 noclass) (nth 2 noclass))))
                                        noclasses))))
            (list classname curdate time))
        (when (not (memq 't
                         (mapcar (lambda (holiday) (if (> (length holiday) 3)
                                                       (pgw/date-block absolute (nth 0 holiday) (nth 1 holiday) (nth 2 holiday) (nth 3 holiday) (nth 4 holiday) (nth 5 holiday))
                                                     (pgw/date-date absolute (nth 0 holiday) (nth 1 holiday) (nth 2 holiday))))
                                 holidays)))
          (list classname curdate time))))))

(defun pgw/create-entry (classname semesters days times &optional desc)
  "Creates headlines for class schedule.
CLASSNAME: a string with the class name (to appear on agenda)
SEMESTERS: a list of integers. e.g. for both just a first semester:
'(1) or for both semesters '(1 2)
DAYS: the days of the class. Normally it will be M/W or T/Th but in
order to have flexibility, the function takes an input of another list
of integers representing days of the week. Monday starts on 1 and
Sunday is 0
TIMES: Either an integer with the period number or a cons list
containing a list of the times which should be the same length as the
list of days

optional DESC: string containing a description for the event

This function uses the variable `pgw/ohs-schoolyear-dates' for the value of holidays"
  (let ((current (calendar-absolute-from-gregorian (diary-make-date 2020 8 19)))
        (desc (if desc (setq desc (format "\n%s\n" desc)) (setq desc "")))
        (fallstart (gethash "fallstart" pgw/ohs-schoolyear-dates))
        (fallend (gethash "fallend" pgw/ohs-schoolyear-dates))
        (springstart (gethash "springstart" pgw/ohs-schoolyear-dates))
        (mononfri (gethash "mononfri" pgw/ohs-schoolyear-dates))
        (springend (gethash "springend" pgw/ohs-schoolyear-dates))
        (holidays (gethash "holidays" pgw/ohs-schoolyear-dates))
        (noclasses (gethash "noclasses" pgw/ohs-schoolyear-dates)))
    (goto-char (point-max))
    (insert (format "\n* %s" classname))
    (while (pgw/date-block current (nth 0 fallstart) (nth 1 fallstart) (nth 2 fallstart)
                           (nth 0 springend) (nth 1 springend) (nth 2 springend)) ; Make sure we're within starting and ending dates of school
      (let ((info (pgw/check-ohs-class current classname semesters days times fallstart fallend springstart mononfri springend holidays noclasses)))
        (when info
          (let* ((headline (nth 0 info))
                 (days-of-week '("Sun" "Mon" "Tue" "Wed" "Thu" "Fri" "Sat"))
                 (fulldate (nth 1 info))
                 (year (nth 2 fulldate))
                 (month (nth 0 fulldate))
                 (day (nth 1 fulldate))
                 (dayofweek (nth (calendar-day-of-week fulldate) days-of-week))
                 (time (nth 2 info)))
            (goto-char (point-max))
            ;; (insert (format "\n** %s\n:PROPERTIES:\n:TIMEZONE: UTC\n:END:\n<%d-%02d-%02d %s %s>\n%s"
            ;;                 headline year month day dayofweek time desc)))))
            (insert (format "\n** %s\n<%d-%02d-%02d %s %s>\n%s"
                            headline year month day dayofweek time desc)))))
      (setq current (+ current 1)))))

(setq pgw/ohs-schoolyear-dates
      #s(hash-table
         size 7
         test equal
         data ("fallstart" (2020 8 19)
               "fallend" (2020 12 19)
               "springstart" (2021 1 4)
               "mononfri" (2021 1 19)
               "springend" (2021 5 13)
               "holidays" ((2020 9 7 2020 9 8) ;; Labor Day
                           (2020 11 25 2020 11 27) ;; Thanksgiving Holiday
                           (2020 12 19 2021 1 3) ;; Winter Closure
                           (2021 1 18 2021 1 19) ;; MLK Holiday
                           (2021 2 15) ;; Presidents Day
                           (2021 2 16) ;; Reading Day (No classes)
                           (2021 3 22 2021 3 26) ;; Spring Break
                           (2021 5 31 2021 6 1)) ;; Memorial Day Holiday
               "noclasses" ((2020 10 28 2020 10 30) ;; Parent-Teacher Conferences (no classes)
                            (2020 12 9 2020 12 11) ;; Study Days (no classes)
                            (2020 12 14 2020 12 19) ;; Fall Semester Finals
                            (2021 1 4 2021 1 8) ;; Reading Week
                            (2021 5 17 2021 5 19) ;; Study Days
                            (2021 5 20 2021 5 21) ;; Spring Semester Finals
                            (2021 5 24 2021 5 27) ;; Spring Semester Finals
                            ))))

(pgw/create-entry "UM51A: Linear Algebra" '(1 2) '(1 3) 3 "Adobe connect class link")

(global-set-key (kbd "C-c s-g o") (lambda () (interactive) (start-process-shell-command "Running ~/QScripts/syncgcal.sh" nil "bash ~/QScripts/syncgcal.sh")))