;; -*- mode: Emacs-Lisp;tab-width: 8;indent-tabs-mode: nil; -*-

 (setq read-process-output-max (* 1024 1024))

 (setq gc-cons-threshold 100000000
       load-prefer-newer t
       inhibit-splash-screen t
       inhibit-startup-message t
       native-comp-debug 3)

 (message invocation-name)
 

 (require 'package)
 
 (setq package-archives
       '(("gnu" . "http://elpa.gnu.org/packages/")
         ("melpa" . "https://melpa.org/packages/")
         ("melpa-stable" . "http://stable.melpa.org/packages/")
         ("nongnu" . "https://elpa.nongnu.org/nongnu/"))
       package-archive-priorities '(("melpa-stable" . 1)
                                    ("gnu" . 0)
                                    ("melpa" . 3)
                                    ("nongnu" . 2)))
 
 ;; (package-initialize 'no-activate)
 (when (not (package-installed-p 'use-package))
   (package-refresh-contents)
   (package-install 'use-package))
 

 (let ((default-directory  "~/.emacs.d/lisp/"))
   (make-directory default-directory t)

   (add-to-list 'load-path (expand-file-name default-directory))

   (normal-top-level-add-subdirs-to-load-path)
   (load "utils"))
 

 (progn
   (define-key key-translation-map (kbd "M-7") (kbd "∘"))
   (define-key key-translation-map (kbd "M-8") (kbd "•"))
   (define-key key-translation-map (kbd "M-9") (kbd "λ")))
 

 (use-package s
   :ensure t)
 

 (cold-boot)

 (use-package nix-mode
   :ensure t)

 (use-package embark
   :ensure t

   :bind (:map global-map (("s-." . embark-act))))

 (use-package htmlize
   :ensure t)

 
 (use-package keyfreq
   :ensure t
   :diminish
   :config
   (keyfreq-mode 1)
   (keyfreq-autosave-mode 1))
 
 (use-package auto-package-update
   :ensure t)

 (use-package general
   :ensure t)

 (use-package flycheck
   :ensure t)

 (use-package company

   :ensure t
   :delight

   :bind (:map company-active-map
               (("C-c h" . company-quickhelp-manual-begin)
                ("M-." . company-show-location)
                ("\C-d" . company-show-doc-buffer)))

   :config

   (progn (define-key company-active-map (kbd "(") (kbd "RET SPC ("))

          (define-key company-active-map (kbd "{") (kbd "RET SPC {"))
          (define-key company-active-map (kbd "[") (kbd "RET [")))
 

   (setq company-backends '((company-clang
                             company-bbdb
                             company-nxml
                             company-css
                             ;;company-xcode
                             company-cmake
                             company-capf
                             ;;company-slime
                             )
                            company-files
                            (company-dabbrev-code
                             company-gtags
                             company-etags
                             company-keywords)
                            company-oddmuse

                            company-dabbrev)))

 
 (use-package company-posframe
   :ensure t

   :delight

   :after company
   :config

   (add-hook 'company-mode-hook (lambda () (company-posframe-mode 1)))
   (setq company-posframe-quickhelp-delay nil))
 

 (use-package jeison
   :ensure t)
 

 (use-package scala-mode
   :ensure t)
 

 (eval-and-compile
   (defvar *fwoar-git-repos*
     (file-name-as-directory
      (expand-file-name (car (file-expand-wildcards "~/git*_repos"))
                        "~"))))

 (eval-and-compile
   (defun fwoar-git-repo (name ssh-remote http-remote)
     (let ((dir-name (file-name-as-directory (expand-file-name name *fwoar-git-repos*))))
       (unless (file-exists-p dir-name)
         (ecase fwoar-git-mode
           (:ssh (magit-run-git-with-input "clone" ssh-remote dir-name))
           (:http (magit-run-git-with-input "clone" http-remote dir-name))))
       dir-name)))
 
 (defvar *dotfiles-repo*
   (fwoar-git-repo "dotfiles"
                   "git@git.fiddlerwoaroof.com:dotfiles.git"
                   "https://git.fiddlerwoaroof.com/git/dotfiles.git"))
 
 (defun fwoar/setup-load-path ()
   (let* ((new-load-path (cl-adjoin "~/.emacs.d/lisp/configurations/"
                                    load-path
                                    :test 'equal))
          (new-load-path (cl-adjoin (concat *dotfiles-repo*
                                            "emacs.d/lisp/configurations/")
                                    new-load-path
                                    :test 'equal))
          (new-load-path (cl-adjoin (concat *dotfiles-repo*
                                            "emacs.d/packages/")
                                    new-load-path
                                    :test 'equal)))
     (setq load-path new-load-path)))
 
 (fwoar/setup-load-path)
 

 (use-package fwoar-pastebin :ensure nil
   :custom
   (fwoar-pastebin-tramp-url (when (file-exists-p "~/.pastebin-name")

                               (car (fwoar:read-sexps-in-file "~/.pastebin-name"))))

   (fwoar-pastebin-web-url-pattern (when (file-exists-p "~/.pastebin-name")

                                     (cadr (fwoar:read-sexps-in-file "~/.pastebin-name")))))

 (use-package fwoar-yank-buffer
   :init (require 'fwoar-yank-buffer)
   :ensure nil)
 

 (use-package fwoar-json-navigator

   :after json-mode

   :init (require 'fwoar-json-navigator)
   :ensure nil)
 

 (defun fwoar/package-configuration (package)
   (fwoar/setup-load-path)
   (let* ((local-configs)
          (git-configs (concat *dotfiles-repo*
                               "emacs.d/lisp/configurations/"))
          (conf-file (concat (symbol-name package) "-conf.el"))
          (load-path (list* local-configs git-configs load-path)))
     conf-file))
 
 (defun load-package-configuration (package)
   (let ((conf-file (fwoar/package-configuration package)))
     (load conf-file)))
 

 (defmacro define-obsolete-function-alias ( obsolete-name current-name &optional when docstring)
   (declare (doc-string 4) (indent defun))
   `(progn
      (defalias ,obsolete-name ,current-name ,docstring)
      (make-obsolete ,obsolete-name ,current-name ,(or when "unspecified"))))
 

 (defun fwoar/load-local-packages ()
   (interactive)
   (mapc 'package-install-file
         (directory-files (format "%s/%s" *dotfiles-repo* "emacs.d/packages/")

                          t ".*[.]el$")))

 (use-package json-mode
   :ensure t)

 (unless (package-installed-p 'fwoar-functional-utils)
   (fwoar/load-local-packages))

 (defvar fwoar-git-mode :ssh)

 (when (locate-library "site-lisp")
   (load "site-lisp"))

 (load-package-configuration 'lsp)
 

 
 
 (fwoar/zenburn-with-color-variables
   (defface magit-keyword-feature
     `((t :foreground ,zenburn-green :inherit magit-keyword))
     "Face for parts of commit messages inside brackets."
     :group 'magit-faces)
   (defface magit-keyword-chore
     `((t :foreground ,zenburn-blue :inherit magit-keyword))
     "Face for parts of commit messages inside brackets."
     :group 'magit-faces)

   (defface magit-keyword-test
     `((t :foreground ,zenburn-blue-1 :inherit magit-keyword))
     "Face for parts of commit messages inside brackets."
     :group 'magit-faces)
   (defface magit-keyword-refactor
     `((t :foreground ,zenburn-green+1 :inherit magit-keyword))
     "Face for parts of commit messages inside brackets."
     :group 'magit-faces)

   (defface magit-keyword-misc
     `((t :foreground ,zenburn-fg-1 :inherit magit-keyword))
     "Face for parts of commit messages inside brackets."
     :group 'magit-faces)
   (defface magit-keyword-bug
     `((t :foreground ,zenburn-red :inherit magit-keyword))
     "Face for parts of commit messages inside brackets."
     :group 'magit-faces))
 

 (defvar fwoar::*magit-log-regexp-faces*
   '((magit-keyword-feature
      "^\\(\\(?:feat\\(?:ure\\)?(\\([^)]+?\\))\\)\\|\\(?:feat\\(ure\\)?\\>\\)\\)")
     (magit-keyword-chore "^\\(\\(?:chore(\\([^)]+?\\))\\)\\|\\(?:chore\\>\\)\\)")
     (magit-keyword-test "^\\(\\(?:test(\\([^)]+?\\))\\)\\|\\(?:test\\>\\)\\)")
     (magit-keyword-refactor "^\\(\\(?:refactor(\\([^)]+?\\))\\)\\|\\(?:refactor\\>\\)\\)")
     (magit-keyword-bug "^\\(\\(?:bug(\\([^)]+?\\))\\)\\|\\(?:bug\\>\\)\\)")
     (magit-keyword-test "^\\(\\(?:test(\\([^)]+?\\))\\)\\|\\(?:test\\>\\)\\)")
     ))
 

 (defun fwoar/propertize-magit-log (_rev msg)

   (cl-loop for (face regexp) in fwoar::*magit-log-regexp-faces*
            do (let ((boundary 0))
                 (while (string-match regexp msg boundary)
                   (setq boundary (match-end 0))
                   (magit--put-face (match-beginning 0) boundary face msg))))
 

   (let ((boundary 0))
     (while (string-match "^\\([^:\n\t]+\\):"  msg boundary)
       (setq boundary (match-end 0))
       (let ((group (match-string 1 msg)))
         (unless (or (> (length group) 20)
                     (s-starts-with? "feat" group)
                     (s-starts-with? "Merge" group)
                     (s-starts-with? "merge" group)
                     (s-starts-with? "chore" group)
                     (s-starts-with? "bug" group))
           (magit--put-face (match-beginning 0) (1- boundary)
                            'magit-keyword-misc msg))))))
 
 (use-package magit
   :ensure t
   :config
   ;; TODO: figure this out with transients
   ;;(magit-define-popup-action 'magit-dispatch-popup ?j "Browse remote" 'browse-at-remote)
   'magit-dispatch
 
   (advice-add 'magit-log-propertize-keywords :after
               'fwoar/propertize-magit-log))
 
 (use-package browse-at-remote
   :ensure t

   :custom
   (browse-at-remote-prefer-symbolic nil)

   :config

   (cl-pushnew '(:host "git.fiddlerwoaroof.com$" :type "gitlist")

               browse-at-remote-remote-type-regexps
               :test 'equal)
 
   (defun browse-at-remote--format-region-url-as-gitlist
       (repo-url ref relname start-line end-line)
     (unless (s-ends-with-p ".git" repo-url)
       (setf repo-url (format "%s.git" repo-url)))
     ;; gitlist doesn't support end-line
     (format "%s/blob/%s/%s#L%s" repo-url ref relname start-line))
   )

 
 
 (use-package aggressive-indent :ensure t)

 (load-package-configuration 'evil)

 (load-package-configuration 'helm)

 ;; (load-package-configuration 'projectile)

 ;; slime depends on fwoar-git-repo
 (load-package-configuration 'slime)

 (load-package-configuration 'cider)

 (global-company-mode 1)
 

 (defun fwoar/c-a-p ()
   (interactive)
   (save-excursion
     (cl-destructuring-bind (start . _end) (bounds-of-thing-at-point 'defun)
       (goto-char start)
       (sp-wrap-with-pair "(")
       (insert "comment\n")
       (sp-indent-defun ))))
 
 

 (comment
  (use-package multifiles
    :config
    (evil-define-key 'visual 'global (kbd "<leader>m") 'mf/mirror-region-in-multifile)))

 (use-package http
   :ensure t)
 (use-package graphql
   :ensure t)
 

 (load-package-configuration 'org)

 (use-package delight
   :ensure t)
 

 (use-package deadgrep
   :ensure t)
 

 (use-package deft
   :ensure t

   :after evil

   :config

   )

 (use-package emmet-mode
   :ensure t
   :config

   (define-key evil-insert-state-map (kbd "C-c ,") 'emmet-expand-line))

 (use-package lisp-skeletons
   :config
   (add-hook 'skeleton-end-hook 'skeleton-make-markers)
 
   (define-key evil-insert-state-map (kbd "C-c j") 'skeleton-next-position)
   (define-key evil-insert-state-map (kbd "C-c k") 'skeleton-prev-position)

   (evil-define-key 'normal 'global (kbd "<leader>g") 'fwoar:helm-generate-lisp-skeleton)
   (evil-define-key 'visual 'global (kbd "<leader>g") 'fwoar:helm-generate-lisp-skeleton))

 (use-package htmlize
   :ensure t)

 (load-package-configuration 'javascript)

 (use-package direnv
   :ensure t
   :config

   (direnv-mode 1)

   (add-hook 'js2-mode-hook 'direnv-mode)
   (add-hook 'typescript-mode-hook 'direnv-mode))

 (use-package cl-generic
   :ensure t)
 

 (defun intercept-print (f)
   (print f)
   f)
 

 (cl-defgeneric fwoar--find-system ())
 (defun fwoar-find-system ()
   (interactive)
   (fwoar--find-system))
 (evil-define-key 'normal 'global (kbd "<leader>O") 'fwoar-find-system)
 

 (cl-defgeneric fwoar--pl-selector ()

   (:method () (slime-selector)))

 (defun fwoar-pl-selector ()
   (interactive)
   (fwoar--pl-selector))

 (evil-define-key 'normal 'global (kbd "<leader>o") 'fwoar-pl-selector)

 (use-package imenu
   :config

   (evil-define-key 'normal 'global (kbd "<leader>d") 'helm-imenu-in-all-buffers))

 (defun fwoar--read-register-name ()
   (let ((overlay (make-overlay (point) (point)))
         (string "\""))
     (unwind-protect
         (progn
           ;; display " in the buffer while reading register
           (put-text-property 0 1 'face 'minibuffer-prompt string)
           (put-text-property 0 1 'cursor t string)
           (overlay-put overlay 'after-string string)
           (list (or evil-this-register (read-char))))
       (delete-overlay overlay))))
 

 
 (use-package cl-format :ensure t)
 

 (use-package eldoc :delight)
 

 (use-package css-eldoc :ensure t)
 
 (use-package csv-mode :ensure t)
 
 (use-package eldoc-eval :ensure t)
 

 (use-package highlight-parentheses
   :ensure t
   :delight
   :config

   (global-highlight-parentheses-mode 1))

 (defun fwoar/markdown-mode-hook ()
   (setf left-margin-width 10
         right-margin-width 10))
 (use-package markdown-mode
   :ensure t
   :config
   (add-hook 'markdown-mode-hook 'variable-pitch-mode)
   (add-hook 'markdown-mode-hook 'fwoar/markdown-mode-hook))

 
 (use-package rainbow-delimiters :ensure t)
 
 (use-package ripgrep :ensure t)
 
 (use-package smartparens :ensure t :ensure t :config

   (sp-pair "${" "}")

   (sp-with-modes sp--lisp-modes
     (sp-local-pair "'" nil :actions nil)
     (sp-local-pair "`" nil :actions nil))

   (add-hook 'smartparens-enabled-hook 'evil-smartparens-mode))
 
 (use-package web-mode :ensure t)

 (use-package yaml-mode :ensure t)

 (use-package yasnippet
   :ensure t
   :hook (prog-mode . yas-minor-mode)
   :config (yas-reload-all)
   )
 

 (use-package editorconfig
   :ensure t

   :delight (editorconfig-mode " ec")

   :config (editorconfig-mode 1))
 

 (defun fwoar--activate-treemacs ()
   (interactive)
   (if (treemacs-is-treemacs-window-selected?)
       (delete-window)
     (treemacs-select-window)))

 (defun fwoar--no-line-numbers ()

   (display-line-numbers-mode -1))

 (use-package treemacs
   :ensure t
   :config

   (setq treemacs-is-never-other-window t
         treemacs-no-png-images t)

   (global-set-key (kbd "s-e") 'fwoar--activate-treemacs)
   (global-set-key (kbd "s-1") 'fwoar--activate-treemacs)

   (add-hook 'treemacs-mode-hook 'fwoar--no-line-numbers)

   )

 
 (use-package treemacs-evil
   :after treemacs evil
   :ensure t)
 
 (use-package treemacs-icons-dired
   :after treemacs dired
   :ensure t
   :config (treemacs-icons-dired-mode))
 
 (use-package treemacs-magit
   :after treemacs magit
   :ensure t)

 (progn ;; emacs-lisp stuff
   (modify-syntax-entry ?- "w" emacs-lisp-mode-syntax-table)
   (modify-syntax-entry ?_ "w" emacs-lisp-mode-syntax-table)

   (put 'narrow-to-page 'disabled nil)
   )

 ;;)

 (global-set-key (kbd "s-v") 'yank)
 

 (setq custom-file "~/.emacs.d/custom.el")

 (when (file-exists-p custom-file)
   (load-file custom-file))

 ;;(setq gc-cons-threshold (* 100 1024))

 (put 'narrow-to-region
      'disabled
      nil)
 
 (global-set-key (kbd "C-x C-b")
                 'ibuffer)

 (defvar url-pattern (when (file-exists-p "~/.pastebin-name")

                       (car (fwoar:read-sexps-in-file "~/.pastebin-name"))))

 
 (defun delete-mru-window ()
   (interactive)
   (delete-window
    (get-mru-window nil nil t)))
 

 (add-to-list 'browse-url-filename-alist
              '("/Users/\\([^/]+\\)/\\(Sites\\|public_html\\)\\(/.*\\)" . "https://localhost/~\\1\\3"))
 

 (progn ;; narrowing
   (define-key global-map "\C-c]" "\C-u1\C-xnp")

   (define-key global-map "\C-c[" "\C-u-1\C-xnp\M-<"))

 (defun fwoar/zenburn-css ()
   (interactive)
   (mapcar (lambda (desc)

             (cl-destructuring-bind (name . value) desc

               (cl-format (current-buffer)
                          "--~a: ~a;~%"
                          (s-replace "+" "-plus-" name)
                          value)))

           fwoar-zenburn-default-colors-alist))

 (defun fwoar/camel-kebab (string)

   (let ((case-fold-search nil))
     (downcase
      (format "%c%s"
              (elt string 0)
              (or (when (> (length string) 1)
                    (s-replace-regexp "[A-Z]"
                                      "-\\&"
                                      string nil nil nil 1))
                  string)))))
 
 (defun fwoar/cc-camel-kebab (start end)
   (interactive "*r")
   (let ((target (buffer-substring start end)))
     (save-excursion
       (delete-region start end)

       (insert (fwoar/camel-kebab target)))))

 (defun fwoar--find-package-json ()
   (expand-file-name
    (locate-dominating-file default-directory
                            (lambda (n)
                              (directory-files n nil "^package.json$")))))
 
 (defun find-package-json (default-directory)
   (interactive "D")
   (message "pakcage json: %s"(fwoar--find-package-json))
   (find-file (concat (fwoar--find-package-json)
                      "/package.json")))
 
 (cl-defmethod fwoar--find-system (&context (major-mode (derived-mode js-mode)))
   (find-package-json default-directory))
 

 (comment
  (use-package org-brain :ensure t
    :init
    (setq org-brain-path "~/org-brain/")

    :config
    (eval-after-load 'evil
      '(evil-set-initial-state 'org-brain-visualize-mode 'emacs))

    (push '("B" "Brain" plain (function org-brain-goto-end)
            "* %i%?" :empty-lines 1)
          org-capture-templates)

    (setq org-id-track-globally t
          org-id-locations-file "~/.emacs.d/.org-id-locations"
          org-brain-visualize-default-choices 'all
          org-brain-title-max-length 0)))

 (setq diary-file (expand-file-name "~/diary"))

 
 (cl-defmacro fwoar/binding (setter target &body bindings)
   (declare (indent 2))
   (let ((target-sym (gensym)))
     `(let ((,target-sym ,target))
        ,(cons 'progn
               (mapcar (lambda (binding)
                         `(,setter ,target-sym ',(car binding) ,@(cdr binding)))
                       bindings)))))
 
 (defun make-info-window ()
   (setq mode-line-format nil)

   ;;(centaur-tabs-local-mode 1)

   (set-window-dedicated-p (selected-window) t)
   (when-let (w (window-in-direction 'above))
     (set-window-parameter w 'no-delete-other-windows t))
   (fwoar/binding set-window-parameter (selected-window)
     (no-other-window t)
     (no-delete-other-windows t))
   ())

 (comment
  (use-package prolog)
  (use-package ediprolog
    :after prolog
    :ensure t
    :config
    (define-key prolog-mode-map (kbd "C-j") 'ediprolog-dwim)))

 (progn
   (require 'ansi-color)
   (defun colorize-compilation-buffer ()
     (toggle-read-only)
     (ansi-color-apply-on-region compilation-filter-start (point))
     (toggle-read-only))
   (add-hook 'compilation-filter-hook 'colorize-compilation-buffer))

 (put 'list-timers 'disabled nil)

 (defun fwoar/center-defun ()
   (interactive)
   (cl-destructuring-bind (a . b) (bounds-of-thing-at-point 'defun)
     (save-excursion
       (let ((s (progn (goto-char a) (line-number-at-pos)))
             (e (progn (goto-char b) (line-number-at-pos))))
         (evil-scroll-line-to-center (+ s -1 (ceiling (- e s) 2)))))))
 

 (use-package which-key-posframe

   :ensure t
   :config

   (which-key-mode 1)
   (which-key-posframe-mode 1))

 (use-package nix-mode
   :ensure t)

 
 (define-derived-mode zsh-mode sh-mode "ZSH" "Mode for zsh scripts"
   (setq-local sh-shell "zsh"))