;;; utils -- Summary
;;; Commentary:

(require 'cl)

;;; Code:

(defun fwoar/doc-for-resource-type (resource-type)
  (cl-format nil
             "https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/~{~a~^-~}"
             (list* "aws" "resource"
                    (cdr (s-split "::" (s-downcase resource-type))))))
(defun fwoar/document-cf (min max)
  "Jump to AWS Cloudformation docs for a resource type.

MIN: the point in the buffer where the resource type starts
MAX: the point in the buffer where the resource type ends

This uses (interactive \"r\") to automagically populate the arguments
from the selected region."
  (interactive "r")
  (browse-url
   (fwoar/doc-for-resource-type
    (buffer-substring min max))))

(defun read-sexps-in-buffer (buffer)
  (with-temp-buffer
    (save-excursion
      (insert "(")
      (insert-buffer buffer)
      (goto-char (point-max))
      (insert "\n)"))
    (read (current-buffer))))

(defun read-sexps-in-file (fn)
  (with-temp-buffer
    (save-excursion
      (insert "(")
      (insert-file fn)
      (goto-char (point-max))
      (insert "\n)"))
    (read (current-buffer))))

(defun read-strings-in-file (fn)
  (with-temp-buffer
    (insert-file fn)
    (mark-whole-buffer)
    (flush-lines "^[[:space:]]*$")
    (goto-char (point-min))
    (remove "" (s-lines (buffer-string)))))

(defun op--collect-args (body)
  (cl-flet ((walker (body &optional args)
                    (if (null body)
                        args
                      (if (symbolp body)
                          (when (eql ?\_ (elt (symbol-name body) 0))
                            (cons body args))
                        (if (listp body)
                            (append (op--collect-args (car body))
                                    (op--collect-args (cdr body))
                                    ))))))
    (sort (walker body)
          (lambda (a b)
            (< (string-to-number (subseq (symbol-name a) 1))
               (string-to-number (subseq (symbol-name b) 1)))))))

(defmacro op (&rest body)
  `(lambda ,(op--collect-args body)
     ,@body))

(defun blank-line-p ()
  (= (current-indentation)
     (- (line-end-position) (line-beginning-position))))

(defun helm-generate-lisp-skeleton ()
  (interactive)
  (let ((skeletons '(("defunction" . skel-defun)
                     ("defmacro" . skel-defmacro)
                     ("defsystem" . skel-defsystem)
                     ("defpackage" . skel-defpackage)
                     ("defparameter" . skel-defparameter)
                     ("defvar" . skel-defvar))))
    (funcall (helm-comp-read "code template: " skeletons))
    (evil-insert 1)))

(defun create-system-files ()
  (interactive)
  (save-excursion
    (mark-defun)
    (mapcar (lambda (it) (save-buffer (find-file (format "%s.lisp" (cadr it)))))
            (getf (cddar (read-from-string
                          (buffer-substring (point)
                                            (mark))))
                  :components)))
  (pop-mark))

(defmacro comment (&rest _))

(comment
 (defun paredit-wiggle-back ()
   (paredit-forward)
   (paredit-backward))

 (defmacro defparedit-wrapper (name invoked-wrapper)
   `(defun ,name ()
      (interactive)
      (paredit-wiggle-back)
      (,invoked-wrapper))))

(defun set-exec-path-from-shell-PATH ()
  "Set up Emacs' `exec-path' and PATH environment variable to match
  that used by the user's shell.

  This is particularly useful under Mac OSX, where GUI apps are not
  started from a shell."
  (interactive)
  (let ((path-from-shell
         (replace-regexp-in-string
          "[ \t\n]*$" ""
          (shell-command-to-string
           (concat "zsh -c '"
                   "  source ~/.zsh.d/dependencies/utils.zsh;"
                   "  source ~/.zsh.d/dependencies/path-setup.zsh;"
                   "  echo $PATH"
                   "'")))))
    (setenv "PATH" path-from-shell)
    (setq exec-path (split-string path-from-shell path-separator))))

(defmacro ensure-use-packages (&rest packages)
  (list* 'progn
         (mapcar (lambda (pck)
                   `(use-package ,(car pck)
                      :ensure t
                      ,@(cdr pck)))
                 packages)))

(defmacro fwoar/defvaralias! (var val-var)
  `(progn
     (setq ,var ,val-var)
     (defvaralias ',var ',val-var)))

(defun setup-indentation ()
  (setq-default indent-tabs-mode nil
                tab-width 2)
  (fwoar/defvaralias! c-basic-offset tab-width)
  (fwoar/defvaralias! sh-basic-offset tab-width)
  (fwoar/defvaralias! js2-basic-offset tab-width)
  (fwoar/defvaralias! sgml-basic-offset tab-width)
  (fwoar/defvaralias! cperl-indent-level tab-width)
  nil)

(defun start-server ()
  (unless (fboundp 'server-running-p)
    (require 'server))
  (let ((server-name (if fwoar.is-ordinary
                         server-name
                       "notes")))
    (unless (server-running-p)
      (server-start))))

(defun post-init ()
  ;;(centaur-tabs-mode 1)
  (evil-mode 1)

  (setup-indentation)
  (start-server)

  (if (version<= "26.0.50" emacs-version)
      (global-display-line-numbers-mode)
    (setq linum-format "%5d\u2502")
    (global-linum-mode))
  (set-exec-path-from-shell-PATH)
  ;; NOTE: this must be here...
  (global-company-mode 1))

(defvar fwoar.is-ordinary)

(defun cold-boot ()
  ""
  (run-with-idle-timer 5 t 'garbage-collect)
  (setq fwoar.is-ordinary (not (string= invocation-name "EmacsNotes")))
  (add-hook 'after-init-hook 'post-init)
  (electric-indent-mode -1)
  (comment
   (electric-pair-mode -1))
  (add-hook 'before-save-hook 'delete-trailing-whitespace)

  (comment
   (when-let ((ls-executable (executable-find "gls")))
     (setq insert-directory-program ls-executable)))

  (setq default-directory "~/emacs-home/")
  (make-directory default-directory t)

  (setq vc-follow-symlinks t)

  (require 'package)

  (setq package-archives '(("gnu" . "http://elpa.gnu.org/packages/")
                           ("nongnu" . "https://elpa.nongnu.org/nongnu/")
                           ("melpa" . "https://melpa.org/packages/")
                           ("melpa-stable" . "http://stable.melpa.org/packages/"))
        package-archive-priorities '(("melpa-stable" . 1)
                                     ("gnu" . 0)
                                     ("melpa" . 2)
                                     ("nongnu" . 3)))

  (package-initialize 'no-activate)
  (when (not (package-installed-p 'use-package))
    (package-refresh-contents)
    (package-install 'use-package))

  (setq browse-url-browser-function 'browse-url-default-browser
        history-delete-duplicates t)

  (require 'use-package))