;;; -*- lexical-binding: t -*-
;;
;; this file:
;;   https://dataswamp.org/~incal/emacs-init/sort-incal.el

(require 'dwim) ; https://dataswamp.org/~incal/emacs-init/dwim.el
(require 'edit)
(require 'erc)
(require 'seq)
(require 'sort)

(setq sort-fold-case t)

(defun sort-region (&optional beg end)
  (interactive (use-region))
  (or beg (setq beg (point-min)))
  (or end (setq end (point-max)))
  (sort-lines nil beg end) )

(defalias 'sortb #'sort-region)

(defun sort-paragraph ()
  (interactive)
  (let ((beg (progn (backward-paragraph) (point)))
        (end (progn (forward-paragraph)  (point))) )
    (sort-lines nil beg end) ))

(defalias 'sort-block #'sort-paragraph)

(defun sort-year-field (&optional beg end)
  (interactive (use-region))
  (or beg (setq beg (point-min)))
  (or end (setq end (point-max)))
  (sort-regexp-fields nil  "^.*$" "[[:digit:]]\\{4\\}" beg end)
  (save-buffer) )

(defun sort-second-field (&optional beg end)
  (interactive (use-region))
  (or beg (setq beg (point-min)))
  (or end (setq end (point-max)))
  (sort-numeric-fields 2 beg end) )

(defalias 's2f #'sort-second-field)

(defun sort-lines-length (&optional beg end)
  (interactive (use-region))
  (or beg (setq beg (point-min)))
  (or end (setq end (point-max)))
  (save-excursion
    (save-restriction
      (narrow-to-region beg end)
      (goto-char (point-min))
      (sort-subr nil
        #'forward-line
        #'end-of-line nil nil
        (lambda (a b)
          (> (- (cdr a) (car a))
             (- (cdr b) (car b)) ))))))

(defalias 'sll #'sort-lines-length)

(defun sort-lines-random (&optional beg end)
  (interactive (use-region))
  (or beg (setq beg (point-min)))
  (or end (setq end (point-max)))
  (save-excursion
    (save-restriction
      (narrow-to-region beg end)
      (goto-char (point-min))
      (sort-subr nil
        #'forward-line
        #'end-of-line nil nil
        (lambda (_ __)
          (zerop (random 2)) )))))

(defalias 'r #'sort-lines-random)

;; test here:
;;   aaa
;;   ccc
;;   bbb
;;   ddd

(defun sort-whole-lines (beg end)
  (interactive "r")
  (save-excursion
    (let ((s (progn (goto-char beg) (line-beginning-position)))
          (e (progn (goto-char end) (line-end-position))) )
      (sort-lines nil s e) )))

(defun insert-string-list (string-list)
  (when string-list
    (insert (format "%s" (car string-list)))
    (dolist (s (cdr string-list))
      (insert (format " %s" s)))))

(defun sort-line-words (beg end &optional set-delim)
  (interactive "r\nP")
  (let*((str       (region-to-string))
        (delim-str (when set-delim
                     (read-string "delimiter: ") ))
        (str-list  (split-string str delim-str))
        (sorted    (erc-sort-strings str-list)) )
    (kill-region beg end)
    (if set-delim
        (progn
          (dolist (s (nreverse (cdr (nreverse sorted))))
            (insert (format "%s%s" s delim-str)))
          (insert (format "%s" (car (last sorted)))))
      (insert-string-list sorted) )))

;; sort me: a is just string test this
;; sorted:  a is just string test this
;;
;; and me with a dash delim: this-is-just-a-test-string

(defun scramble (beg end)
  "Shuffle chars in region from BEG to END."
  (interactive "r")
  (when (use-region-p)
    (save-excursion
      (let*((str        (region-to-string))
            (chars      (delete "" (split-string str "")))
            (rand-chars (sort chars (lambda (_ __) (zerop (random 2))))) )
        (delete-region beg end)
        (dolist (c rand-chars)
          (insert c) )))))

(provide 'sort-incal)