improve directory `completing-read` asking

[youtube-dl.el.git] / youtube-dl.el

;;; youtube-dl.el --- Manages a youtube-dl queue -*- lexical-binding: t; -*-

;; Copyright (C) 2021 stardiviner <numbchild@gmail.com>

;; Original Author: Christopher Wellons <wellons@nullprogram.com>
;; URL: https://github.com/skeeto/youtube-dl-emacs
;; Version: 1.0
;; Package-Requires: ((emacs "29.1") (transient "0.4.0") (s "1.13.1"))

;; This file is not part of GNU Emacs.
;;
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with this program; if not, you can either send email to this
;; program's maintainer or write to: The Free Software Foundation,
;; Inc.; 59 Temple Place, Suite 330; Boston, MA 02111-1307, USA.

;;; Commentary:

;; This package manages a video download queue for the youtube-dl
;; command line program, which serves as its back end. It manages a
;; single youtube-dl subprocess to download one video at a time. New
;; videos can be queued at any time.

;; The `youtube-dl' command queues a URL for download. Failures are
;; retried up to `youtube-dl-max-failures'. Items can be paused or set
;; to be downloaded at a slower download rate (`youtube-dl-slow-rate-limit').

;; The `youtube-dl-download-playlist' command queues an entire playlist, just
;; as if you had individually queued each video on the playlist.

;; The `youtube-dl-list' command displays a list of all active video
;; downloads. From this list, items under point can be canceled (d),
;; paused (p), slowed (s), and have its priority adjusted ([ and ]).

;;; Code:

(require 'json)
(require 'cl-lib)
(require 'hl-line)
(require 'notifications)
(require 'org-element)
(require 'org-attach)
(require 's) ; for `s-truncate'


(defgroup youtube-dl ()
  "Download queue for the `youtube-dl' command line program."
  :group 'external)

(defcustom youtube-dl-download-directory "~/Downloads/"
  "Directory in which to run `youtube-dl'."
  :group 'youtube-dl
  :type 'directory)

(defcustom youtube-dl-program
  ;; "yt-dlp" is a fork of "youtube-dl".
  (let ((program (cond
                  ((executable-find "yt-dlp") "yt-dlp")
                  ((executable-find "youtube-dl") "youtube-dl"))))
    (if (or (file-exists-p program) (file-regular-p program))
        (file-name-base program)
      program))
  "The name of the program invoked for downloading YouTube videos.
NOTE: It's specified by program name instead of program path."
  :type 'string
  :safe #'stringp
  :group 'youtube-dl)

(defcustom youtube-dl-extra-arguments
  '("--newline" "--no-warnings" "--embed-metadata")
  "Arguments to be send to `youtube-dl'.
Instead of --limit-rate use custom option `youtube-dl-slow-rate-limit'."
  :type '(repeat string)
  :safe #'listp
  :group 'youtube-dl)

(defcustom youtube-dl-omit-mtime t
  "Whether to omit timestamp from the `Last-modified' header for downloaded files."
  :type 'boolean
  :safe #'booleanp
  :group 'youtube-dl)

(defcustom youtube-dl-restrict-filenames t
  "Whether to restrict downloaded filenames to only ASCII characters."
  :type 'boolean
  :safe #'booleanp
  :group 'youtube-dl)

(defcustom youtube-dl-proxy ""
  "Specify the proxy for `youtube-dl' command.
For example:

127.0.0.1:8118
socks5://127.0.0.1:1086"
  :type 'string
  :safe #'stringp
  :group 'youtube-dl)

(defcustom youtube-dl-proxy-url-list '()
  "A list of URL domains which should use proxy for `youtube-dl'."
  :type 'list
  :safe #'listp
  :group 'youtube-dl)

(defcustom youtube-dl-auto-show-list t
  "Auto show the \"*youtube-dl list*\" buffer."
  :type 'boolean
  :safe #'booleanp
  :group 'youtube-dl)

(defcustom youtube-dl-process-model 'multiple-processes
  "Determine youtube-dl.el downloading process model."
  :safe #'symbolp
  :type '(choice (symbol :tag "single process only" 'single-process)
                 (symbol :tag "multiple processes" 'multiple-processes)))

(defcustom youtube-dl-max-failures 8
  "Maximum number of retries for a single video."
  :type 'integer
  :safe #'numberp
  :group 'youtube-dl)

(defcustom youtube-dl-slow-rate-limit "2M"
  "Download rate for slow item (corresponding to option --limit-rate)."
  :type 'string
  :safe #'stringp
  :group 'youtube-dl)

(defcustom youtube-dl-notify nil
  "Whether raise notifications."
  :type 'boolean
  :safe #'booleanp
  :group 'youtube-dl)

(defcustom youtube-dl-destination-illegal-filename-chars-regex "[#$%+!<>&*|{}?=@:/\\\"'`]"
  "Specify the regex of invalid destination filename.
This will avoid `youtube-dl' can't save invalid filename caused error.
https://www.mtu.edu/umc/services/websites/writing/characters-avoid/"
  :type 'string
  :safe #'stringp
  :group 'youtube-dl)

(defcustom youtube-dl-auto-close-list-buffer nil
  "Non-nil means auto close the \"*youtube-dl list*\" buffer."
  :type 'boolean
  :safe #'booleanp
  :group 'youtube-dl)

;;; TEST:
;; (replace-regexp-in-string
;;  youtube-dl-destination-illegal-filename-chars-regex "-"
;;  "[#$%+!<>&*|{}?=@:/\\\"'`]")

(defface youtube-dl-active
  '((t :inherit font-lock-function-name-face :foreground "forest green"))
  "Face for highlighting the active download item."
  :group 'youtube-dl)

(defface youtube-dl-slow
  '((t :inherit font-lock-variable-name-face :foreground "orange"))
  "Face for highlighting the slow (S) tag."
  :group 'youtube-dl)

(defface youtube-dl-pause
  '((t :inherit font-lock-type-face :foreground "gray"))
  "Face for highlighting the pause (P) tag."
  :group 'youtube-dl)

(defface youtube-dl-priority
  '((t :inherit font-lock-keyword-face :foreground "light blue"))
  "Face for highlighting the priority marker."
  :group 'youtube-dl)

(defface youtube-dl-failure
  '((t :inherit font-lock-warning-face :foreground "red"))
  "Face for highlighting the failure marker."
  :group 'youtube-dl)

(defvar-local youtube-dl--log-item nil
  "Item currently being displayed in the log buffer.")

(cl-defstruct (youtube-dl-item (:constructor youtube-dl-item--create)
                               (:copier nil))
  "Represents a single video to be downloaded with youtube-dl."
  url            ; Video URL (string)
  vid            ; Video ID (integer)
  directory      ; Working directory for youtube-dl (string or nil)
  destination    ; Preferred destination file (string or nil)
  running        ; Status indicator of process (boolean)
  failures       ; Number of video download failures (integer)
  priority       ; Download priority (integer)
  title          ; Listing display title (string or nil)
  percentage     ; Current download percentage (string or nil)
  total-size     ; Total download size (string or nil)
  log            ; All program output (list of strings)
  log-end        ; Last log item (list of strings)
  paused-p       ; Non-nil if download is paused (boolean)
  slow-p         ; Non-nil if download should be rate limited (boolean)
  rate-limit     ; Download rate limit (e.g. 50K or 2M)
  buffer         ; the process buffer name
  process        ; the process object
  finished-p     ; Non-nil if the process is finished (boolean)
  download-rate  ; Download rate in bytes per second (e.g. 50K or 2M)
  eta            ; ETA time (e.g. 01:01:57)
  type           ; media type: video, audio, subtitle, thumbnail etc.
  )

(defvar youtube-dl-items ()
  "List of all items still to be downloaded.")

(defvar youtube-dl-process nil
  "The currently active `youtube-dl' process.")

(defun youtube-dl--process-buffer-name (vid)
  "Return the process buffer name which constructed with VID."
  (format " *youtube-dl vid:%s*" vid))

(defun youtube-dl--proxy-append (url &optional option value)
  "Decide whether append proxy OPTION & VALUE in `youtube-dl' command based on URL."
  (let ((domain (url-domain (url-generic-parse-url url))))
    (if (and (member domain youtube-dl-proxy-url-list) ; <-- whether toggle proxy?
             (not (string-empty-p youtube-dl-proxy)))
        (if option                      ; <-- whether has command-line option?
            (list "--proxy" youtube-dl-proxy option value)
          (list "--proxy" youtube-dl-proxy))
      (if option                        ; <-- return original arguments for no proxy
          (list option value)
        nil                             ; <-- return nothing for url no need proxy
        ))))

(defun youtube-dl--next ()
  "Returns the next item to be downloaded."
  (let (best best-score)
    (dolist (item youtube-dl-items best)
      (let* ((failures (youtube-dl-item-failures item))
             (priority (youtube-dl-item-priority item))
             (paused-p (youtube-dl-item-paused-p item))
             (score (- priority failures)))
        (when (and (not paused-p)
                   (< failures youtube-dl-max-failures))
          (cond ((null best)
                 (setf best item
                       best-score score))
                ((> score best-score)
                 (setf best item
                       best-score score))))))))

(defun youtube-dl--current ()
  "Return the item currently being downloaded."
  (when youtube-dl-process
    (plist-get (process-plist youtube-dl-process) :item)))

(defun youtube-dl--remove (item)
  "Remove ITEM from the queue and kill process."
  (let ((proc (youtube-dl-item-process item)))
    (when (process-live-p proc) ; `kill-process' only when `proc' is still alive.
      (kill-process proc)))
  (setf youtube-dl-items (cl-delete item youtube-dl-items)))

(defun youtube-dl--add (item)
  "Add ITEM to the queue."
  (setf youtube-dl-items (nconc youtube-dl-items (list item))))

(defvar youtube-dl--timer-item nil
  "A global variable for passing ITEM into `youtube-dl--run' in `run-with-timer'.")

(defun youtube-dl-notify ()
  "Raise a system notify and play a notify sound."
  (cl-case system-type
    (gnu/linux
     (notifications-notify :title "youtube-dl.el" :body "Download finished."))
    (darwin
     (ns-do-applescript
      (format "display notification \"%s\" with title \"%s\" sound name \"Blow\"" "youtube-dl.el" "Download finished.")))
    (windows-nt nil)))

(defun youtube-dl--sentinel (proc status)
  "The sentinel function with arguments of process PROC and STATUS."
  (when-let ((item (plist-get (process-plist proc) :item)))
    ;; (setf youtube-dl-process proc) ; dont' need to set current process.
    (cond
     ;; process status is finished.
     ((equal status "finished\n")
      ;; mark item structure property `:running' to `nil'.
      (setf (youtube-dl-item-running item) nil)
      (setf (youtube-dl-item-finished-p item) t)
      (youtube-dl--remove item)
      (when youtube-dl-notify
        (youtube-dl-notify)))
     ;; detect whether process is in "pause" process status?
     ((youtube-dl-item-paused-p item)
      ;; mark item structure property `:running' to `nil'.
      (setf (youtube-dl-item-running item) nil)
      (message "[youtube-dl] process %s is paused." proc))
     ;; when process downloading failed, then retry downloading.
     ((equal status "killed: 9\n")
      ;; mark item structure property `:running' to `nil'.
      (setf (youtube-dl-item-running item) nil)
      (message "[youtube-dl] process %s is killed." proc))
     (t
      ;; mark item structure property `:running' to `nil'.
      (setf (youtube-dl-item-running item) nil)
      (cl-incf (youtube-dl-item-failures item))
      ;; record log output to process buffer
      (let ((buf (youtube-dl--log-buffer item))
            (inhibit-read-only t))
        (with-current-buffer buf
          (print status buf)
          (print (process-plist proc) buf)))
      ;; re-run process
      (if (<= (youtube-dl-item-failures item) 10)
          (youtube-dl--run)
        (setq youtube-dl--timer-item item)
        (run-with-timer (* 60 5) nil #'youtube-dl--run)
        (message "[youtube-dl] delay process %s" proc))))))

(defun youtube-dl--progress (output)
  "Return the download progress for the given OUTPUT.
Progress lines that straddle output chunks are lost. That's fine
since this is just used for display purposes.

Return list: (\"34.6%\" \"~2.61GiB\" \"929.50KiB/s\")."
  (let ((start 0)
        (progress nil))
    (cond
     ;; [download]  34.6% of ~2.61GiB at 929.50KiB/s ETA 01:01:57
     ;;             +---+    +------+    +---------+     +------+
     ((or (string-equal youtube-dl-program "youtube-dl")
          (string-equal (file-name-nondirectory youtube-dl-program) "youtube-dl"))
      (while (string-match "\\[download\\] +\\([^ ]+%\\) +of *~? *\\([^ ]+\\) +at +\\([^ ]+\\) +ETA +\\([^ \n]+\\)" output start)
        (let ((percent (match-string 1 output))
              (total-size (match-string 2 output))
              (download-rate (match-string 3 output))
              (eta (match-string 4 output)))
          (setf progress (list percent total-size download-rate eta)
                start (match-end 0)))))
     ((or (string-equal youtube-dl-program "yt-dlp")
          (string-equal (file-name-nondirectory youtube-dl-program) "yt-dlp"))
      ;; The output has non-ASCII shell color codes. Disable it with command-line option "--no-colors".
      ;; [download]   0.4% of ~ 314.23MiB at    7.54KiB/s ETA 11:48:26 (frag 0/216)
      ;;              +--+      +-------+       +-------+     +------+
      (while (string-match "\\[download\\] +\\([^ ]+%\\) +of *~? *\\([^ ]+\\) +at +\\([^ ]+\\) +ETA +\\([^ \n]+\\)" output start)
        (let ((percent (match-string 1 output))
              (total-size (match-string 2 output))
              (download-rate (match-string 3 output))
              (eta (match-string 4 output)))
          ;; filter out not correct matched data.
          ;; DEBUG:
          ;; (message "[DEBUG] [youtube-dl] download-rate regexp matched: >>> %s <<<" download-rate)
          ;; (message "[DEBUG] [youtube-dl] eta regexp matched: >>> %s <<<" eta)
          (unless (or (string-equal-ignore-case total-size "Unknown.*")
                      (string-equal-ignore-case eta "Unknown.*") ; [download]   0.0% of    2.14MiB at  Unknown B/s ETA Unknown
                      )
            (setf progress (list percent total-size download-rate eta)
                  start (match-end 0)))))))
    ;; DEBUG:
    ;; (when progress
    ;;   (cl-destructuring-bind (percentage total-size download-rate eta) progress
    ;;     (message "[DEBUG] [youtube-dl] progress: percent: %s, total-size: %s, speed: %s, eta: %s."
    ;;              percentage total-size download-rate eta)))
    progress))

(defun youtube-dl--get-destination (url)
  "Return the destination filename for the given `URL' (if any).
The destination filename may potentially straddle two output
chunks, but this is incredibly unlikely. It's only used for
display purposes anyway.

$ youtube-dl --get-filename <URL>"
  (message "[youtube-dl] getting video destination.")
  (let* ((get-destination-buffer " *youtube-dl-get-destination*")
         (get-destination-error-buffer " *youtube-dl-get-destination error*")
         (destination))
    ;; clear destination buffer content to clear destination history.
    (progn
      (when (buffer-live-p (get-buffer get-destination-buffer))
        (with-current-buffer get-destination-buffer (erase-buffer)))
      (when (buffer-live-p (get-buffer get-destination-error-buffer))
        (with-current-buffer get-destination-error-buffer (erase-buffer))))
    ;; retrieve destination
    (make-process
     :command (list youtube-dl-program "--get-filename" url)
     :sentinel (lambda (proc event)
                 (if (string= event "finished\n")
                     (setq destination
                           (replace-regexp-in-string ; replace illegal filename characters in `destination'.
                            youtube-dl-destination-illegal-filename-chars-regex "-"
                            (replace-regexp-in-string
                             "\\ +\\[.*\\]" "" ; delete trailing [...] in filename.
                             (replace-regexp-in-string
                              "\n" ""   ; delete trailing "\n" character.
                              (with-current-buffer get-destination-buffer (buffer-string))))))
                   (let* ((buffer-str (with-current-buffer get-destination-error-buffer (buffer-string)))
                          (match-regex "\\(ERROR\\|Error\\): \\(.*\\)")
                          (error-p (string-match-p match-regex buffer-str))
                          (matched-str (when (string-match match-regex buffer-str) (match-string 2 buffer-str))))
                     (if error-p
                         (progn
                           (message "[youtube-dl] `youtube-dl--get-destination' error!\n%s" matched-str)
                           ;; TODO:
                           ;; (funcall 'youtube-dl--get-destination url)
                           )
                       (progn
                         (message "[youtube-dl] get output filename success.")
                         ;; (kill-process proc)
                         ;; (kill-buffer (process-buffer proc))
                         )))))
     :name "youtube-dl-get-destination"
     :buffer get-destination-buffer
     :stderr get-destination-error-buffer)
    
    (setq destination-not-returned t)
    (dotimes (i 10)
      (when destination-not-returned
        (sleep-for 1)
        (if destination (setq destination-not-returned nil))))
    
    ;; Prompt for user the destination interactively.
    (unless destination
      (setq destination (substring-no-properties (read-string "[youtube-dl] input destination: "))))
    
    (when destination
      (kill-new destination)             ; copy to Emacs kill-ring for later operation.
      (message "[youtube-dl] have got destination : %s" destination)
      destination)))

;;; TEST:
;; (youtube-dl--get-destination "https://www.pornhub.com/view_video.php?viewkey=ph603b575e00170")

(defun youtube-dl--filter (proc output)
  "The filter function of process PROC applied on OUTPUT."
  (if (plist-get (process-plist proc) :item)
      (let* ((item (plist-get (process-plist proc) :item))
             (progress (youtube-dl--progress output))
             (destination (youtube-dl-item-destination item)))
        ;; Append to program log.
        (let ((logged (list output)))
          (if (and (youtube-dl-item-log item) (youtube-dl-item-log-end item)) ; make sure not nil.
              (setf (cdr (youtube-dl-item-log-end item)) logged
                    (youtube-dl-item-log-end item) logged)
            (setf (youtube-dl-item-log item) logged
                  (youtube-dl-item-log-end item) logged)))
        ;; Update progress information.
        (when progress
          (cl-destructuring-bind (percentage total-size download-rate eta) progress
            (setf (youtube-dl-item-percentage item) percentage
                  (youtube-dl-item-total-size item) total-size
                  (youtube-dl-item-download-rate item) download-rate
                  (youtube-dl-item-eta item) eta)))
        ;; monitor process output whether error occurred?
        (let* ((item-log-end (youtube-dl-item-log-end item))
               (log-end-str (cond
                             ((stringp item-log-end) item-log-end)
                             ((listp item-log-end) (car (last item-log-end)))))
               (error-hander (lambda () (setf (youtube-dl-item-running item) nil)
                               (message "[youtube-dl] ✖ <proc: %s>, destination: %s"
                                        (youtube-dl-item-process item) (youtube-dl-item-destination item))))
               (running-handler (lambda () (setf (youtube-dl-item-running item) t)))
               (finished-handler (lambda () (setf (youtube-dl-item-running item) nil)
                                   (message "[youtube-dl] ✔ %s downloaded." (youtube-dl-item-destination item)))))
          (when (stringp log-end-str)
            (cond
             ;; progress finished when percentage is 100%.
             ((or (string-equal (youtube-dl-item-percentage item) "100%")
                  (string-match "\\[download\\]\\ *100%.*" log-end-str)) ; ".*100%.*"
              (funcall finished-handler))
             ;; process exited abnormally with code 1
             ((string-match "exited abnormally with code 1" log-end-str)
              (funcall error-hander))
             ;; file already downloaded
             ((string-match "ERROR: Fixed output name but more than one file to download:.*" log-end-str)
              ;; (funcall error-hander)
              (message "[youtube-dl] ERROR: Already has existing downloading process or output file! (%s)" (youtube-dl-item-destination item)))
             ;; any other errors
             ((string-match "ERROR:.*" log-end-str)
              (funcall error-hander))
             (t (funcall running-handler)))))
        ;; DEBUG:
        ;; (message "[DEBUG] [youtube-dl] destination/title: %s" destination)
        ;; Set item title to destination if it's empty.
        (unless (youtube-dl-item-title item)
          (setf (youtube-dl-item-title item) destination))
        ;; write output to process associated buffer.
        (with-current-buffer (process-buffer proc)
          (let ((moving (= (point) (process-mark proc)))
                ;; avoid process buffer read-only issue for `insert'.
                (inhibit-read-only t))
            (save-excursion
              ;; Insert the text, advancing the process marker.
              (goto-char (process-mark proc))
              (insert output)
              (set-marker (process-mark proc) (point)))
            (if moving (goto-char (process-mark proc)))))
        (youtube-dl--redisplay))))

(defun youtube-dl--construct-command (item)
  "Construct full command of `youtube-dl' with arguments from ITEM."
  (let ((url (youtube-dl-item-url item))
        (slow-p (youtube-dl-item-slow-p item))
        (rate-limit (youtube-dl-item-rate-limit item))
        (destination (youtube-dl-item-destination item)))
    (append
     (list youtube-dl-program "--newline")
     youtube-dl-extra-arguments
     (when youtube-dl-omit-mtime (list "--no-mtime"))
     (when youtube-dl-restrict-filenames (list "--restrict-filenames"))
     ;; Disable non-ASCII shell color codes in output.
     (cond
      ((string-equal youtube-dl-program "youtube-dl") '("--no-color"))
      ((string-equal youtube-dl-program "yt-dlp") '("--no-colors")))
     (youtube-dl--proxy-append url)
     (when slow-p `("--rate-limit" ,rate-limit))
     (when destination `("--output" ,destination))
     `("--" ,url))))

(defun youtube-dl--run-single-process (&optional item)
  "Start `youtube-dl' ITEM downloading in single process."
  (let ((item (youtube-dl--next))
        (current-item (youtube-dl--current)))
    (if (eq item current-item)
        (youtube-dl--redisplay) ; do nothing, just display the youtube-dl-list buffer.
      (if youtube-dl-process
          (progn
            ;; Switch to higher priority job, but offset error count first.
            (cl-decf (youtube-dl-item-failures current-item))
            (kill-process youtube-dl-process)) ; sentinel will clean up
        ;; No subprocess running, start a one.
        (let* ((url (substring-no-properties (youtube-dl-item-url item)))
               (directory (youtube-dl-item-directory item))
               (destination (youtube-dl-item-destination item))
               (vid (youtube-dl-item-vid item))
               (proc-buffer-name (youtube-dl--process-buffer-name vid))
               (default-directory
                (if directory
                    (concat (directory-file-name directory) "/")
                  (concat (directory-file-name youtube-dl-download-directory) "/")))
               (_ (mkdir default-directory t))
               (slow-p (youtube-dl-item-slow-p item))
               (rate-limit (or (youtube-dl-item-rate-limit item) youtube-dl-slow-rate-limit))
               (proc (make-process
                      :name proc-buffer-name
                      :command (let ((command (youtube-dl--construct-command item)))
                                 ;; Insert complete command into process buffer for debugging.
                                 (with-current-buffer (get-buffer-create proc-buffer-name)
                                   (insert (format "Command: %s" command)))
                                 command)
                      :sentinel #'youtube-dl--sentinel
                      :filter #'youtube-dl--filter
                      :buffer proc-buffer-name)))
          (set-process-plist proc (list :item item))
          (setf youtube-dl-process proc)
          ;; mark item structure property `:running' to `t'.
          (setf (youtube-dl-item-running item) t))))
    (youtube-dl--redisplay)))

(defun youtube-dl--run-multiple-processes (&optional item)
  "Start `youtube-dl' downloading ITEM in multiple processes."
  (let* ((item (or item
                   youtube-dl--timer-item ; use item from `run-with-timer'.
                   (with-current-buffer (youtube-dl--list-buffer)
                     (nth (1- (line-number-at-pos)) youtube-dl-items))))
         (current-item (youtube-dl--current)) ; `youtube-dl-process' currently actived process.
         (proc (youtube-dl-item-process item)))
    (unless (and item (youtube-dl-item-running item)) ; whether item structure property `:running' is `t'?
      (let* ((url (substring-no-properties (youtube-dl-item-url item)))
             (directory (youtube-dl-item-directory item))
             (destination (youtube-dl-item-destination item))
             (vid (youtube-dl-item-vid item))
             (proc-buffer-name (youtube-dl--process-buffer-name vid))
             (default-directory
              (if directory
                  (concat (directory-file-name directory) "/")
                (concat (directory-file-name youtube-dl-download-directory) "/")))
             (_ (mkdir default-directory t))
             (slow-p (youtube-dl-item-slow-p item))
             (rate-limit (or (youtube-dl-item-rate-limit item) youtube-dl-slow-rate-limit))
             (failures (youtube-dl-item-failures item))
             (proc (when (<= failures 10) ; re-run process only when failures <= 10.
                     (make-process
                      :name proc-buffer-name
                      :command (let ((command (youtube-dl--construct-command item)))
                                 ;; Insert complete command into process buffer for debugging.
                                 (let ((inhibit-read-only t))
                                   (with-current-buffer (get-buffer-create proc-buffer-name)
                                     (insert (format "Command: %s" command))))
                                 command)
                      :sentinel #'youtube-dl--sentinel
                      :filter #'youtube-dl--filter
                      :buffer proc-buffer-name))))
        ;; clear temporary item variable `youtube-dl--timer-item'.
        (setq youtube-dl--timer-item nil)
        (when (processp proc)
          ;; set process property list.
          (set-process-plist proc (list :item item))
          ;; assign `proc' object to item slot `:process'.
          (setf (youtube-dl-item-process item) proc)
          ;; set current youtube-dl process variable.
          (setf youtube-dl-process proc)
          ;; mark item structure property `:running' to `t'.
          (setf (youtube-dl-item-running item) t))))
    (youtube-dl--redisplay)))

(defun youtube-dl--run (&optional item)
  "Start `youtube-dl' ITEM downloading."
  ;; if single process model, then start download next item.
  ;; if multiple processes model, then don't start next item `youtube-dl--run'.
  (cl-case youtube-dl-process-model
    (single-process (youtube-dl--run-single-process item))
    (multiple-processes (youtube-dl--run-multiple-processes item))))

(defun youtube-dl--get-vid (url)
  "Get video `URL' video vid with `youtube-dl' option `--get-id'."
  (message "[youtube-dl] getting video vid.")
  (let* ((parsed-url (url-generic-parse-url url))
         (domain (url-domain parsed-url))
         (parameters (url-filename parsed-url)))
    ;; URL domain matching with regexp to extract vid.
    (pcase domain
      ("bilibili.com"           ; "/video/BV1B8411L7te/", "/video/BV1uj411N7cp?spm_id_from=..0.0"
       (when (string-match "/video/\\([^/?&]*\\)" parameters)
         (match-string 1 parameters)))
      ("pornhub.com"            ; "/view_video.php?viewkey=ph6238f9c7cc9e2"
       (when (string-match "/view_video\\.php\\?viewkey=\\([^/?&]*\\)" parameters)
         (match-string 1 parameters)))
      ("youtube.com"            ; "/watch?v=q-iLEteyeUQ", "/watch?v=48JlgiBpw_I&t=311s"
       (or (when (string-match "/watch\\?v=\\([^/?&]*\\)" parameters)
             (match-string 1 parameters))
           (when (string-match "\\(?:\\.be/\\|v=\\|v%3D\\|/shorts/\\|^\\)\\([-_a-zA-Z0-9]\\{11\\}\\)" url)
             (match-string 1 url))))
      ("hobby.porn" ; "https://hobby.porn/video/<vid>/"
       (when (string-match "/video/\\([^/?&]*\\)" parameters)
         (let ((vid (match-string 1 parameters)))
           (if (length> vid 15)
               (truncate-string-to-width (md5 (match-string 1 parameters)) 15)
             vid))))
      (_ (progn
           (let* ((output (with-temp-buffer
                            (apply #'call-process
                                   youtube-dl-program
                                   nil t nil
                                   (youtube-dl--proxy-append url "--get-id" url))
                            (buffer-string)))
                  (output-lines-list (seq-remove 'string-blank-p (string-lines output)))
                  (error-p (string-match-p "ERROR" output))
                  (warning-p (string-match-p "WARNING" (car output-lines-list))))
             (cond
              ;; "ERROR: Unsupported URL: ..."
              ((string-match-p "ERROR: Unsupported URL:" output)
               (user-error "[youtube-dl] Unsupported URL: %s" url))
              ;; ERROR: [SpankBang] 7z268: Unable to download webpage: HTTP Error 403: Forbidden (caused by <HTTPError 403: Forbidden>)
              ((string-match-p "Unable to download webpage: HTTP Error 403: Forbidden" output)
               (user-error "[youtube-dl] Unable to download webpage: HTTP Error 403: Forbidden"))
              ;; "WARNING: [generic] Falling back on generic information extractor"
              ((or (string-equal-ignore-case (car output-lines-list) "WARNING: Falling back on generic information extractor")
                   (string-equal-ignore-case (car output-lines-list) "WARNING: [generic] Falling back on generic information extractor")
                   warning-p)
               (truncate-string-to-width (car (last output-lines-list 1)) 15))
              (error-p
               (error (format "[youtube-dl] `youtube-dl--get-vid' retrive video vid error!\n%s" output)))
              ;; TEST: (youtube-dl--get-vid "https://www.youtube.com/watch?v=VROjLiq9LeQ")
              ;; ("VrAfJvZGGXE")
              ((length= output-lines-list 1) (truncate-string-to-width (car output-lines-list) 15))
              ;; TEST: (youtube-dl--get-vid "https://hobby.porn/video/<vid>")
              ;; ("WARNING: [generic] Falling back on generic information extractor" "<vid>")
              ((length= output-lines-list 2) (truncate-string-to-width (cadr output-lines-list) 15))
              ;; TEST: (youtube-dl--get-vid "https://hanime1.me/watch?v=22454")
              ;; ("WARNING: Falling back on generic information extractor." "watch?v=22454" "")
              ((length= output-lines-list 3) (truncate-string-to-width (car (last output-lines-list 1)) 15))
              ;; get vid failed, use URL string regex matching instead.
              (t
               ;; truncate `vid' length to avoid breaking `youtube-dl-list' buffer the `vid' column width.
               ;; TEST: (youtube-dl--get-vid "https://www.youtube.com/watch?v=1234567890abcdefghijklmnopqrstuvwxyz")
               (truncate-string-to-width parameters 15)))))))))

;;; TEST:
;; (let ((parameters "/video/BV1B8411L7te/"))
;;   (when (string-match "/video/\\([^/]*\\)" parameters)
;;     (match-string 1 parameters)))
;;
;; (youtube-dl--get-vid "https://www.youtube.com/watch?v=<vid>")
;; (youtube-dl--get-vid "https://www.pornhub.com/view_video.php?viewkey=<vid>")
;; (youtube-dl--get-vid "https://hobby.porn/video/<vid>/")

;;;###autoload
(cl-defun youtube-dl
    (url &key title (priority 0) directory destination paused slow)
  "Queues URL for download using `youtube-dl', returning the new item.
Download to DIRECTORY default in ~/Downloads/ with TITLE as filename.
Download in PRIORITY in downloading queue."
  (interactive
   (list (substring-no-properties
          (read-from-minibuffer
           "URL: " (or (thing-at-point 'url)
                       (when (eq major-mode 'org-mode)
                         (org-element-property :raw-link (org-element-context)))
                       (when interprogram-paste-function
                         (funcall interprogram-paste-function)))))))
  ;; remove this ID failure only on youtube.com, use URL as ID. or use youtube-dl extracted title, or hash on URL.
  (let* ((vid (youtube-dl--get-vid url))
         (destination (or destination (youtube-dl--get-destination url)))
         (title (or title
                    (replace-regexp-in-string (format "-%s.*" vid) "" destination)
                    (car (split-string destination "-"))))
         (type (youtube-dl--get-type-for-extension (file-name-extension destination)))
         (proc-buffer-name (youtube-dl--process-buffer-name vid))
         (full-dir (expand-file-name (or directory youtube-dl-download-directory)))
         (item (youtube-dl-item--create :url url
                                        :vid vid
                                        :failures 0
                                        :priority priority
                                        :paused-p paused
                                        :slow-p slow
                                        :rate-limit nil
                                        :directory full-dir
                                        :destination destination
                                        :title title
                                        :type type
                                        :buffer proc-buffer-name
                                        :process nil)))
    (prog1 item
      (unless (youtube-dl-item-running item)
        (youtube-dl--add item)          ; Add ITEM to the queue.
        (youtube-dl--run item)          ; Start ITEM in the queue.
        (when youtube-dl-auto-show-list
          (youtube-dl-list))))))

(defalias 'youtube-dl-download-video 'youtube-dl)

(defun youtube-dl--playlist-list (playlist)
  "For each video in PLAYLIST, return one plist with :index, :vid, and :title."
  (with-temp-buffer
    (when (zerop (call-process youtube-dl-program nil t nil
                               "--ignore-config"
                               "--dump-json"
                               "--flat-playlist"
                               playlist))
      (goto-char (point-min))
      (cl-loop with json-object-type = 'plist
               for index upfrom 1
               for video = (ignore-errors (json-read))
               while video
               collect (list :index index
                             :vid   (plist-get video :vid)
                             :title (plist-get video :title))))))

(defun youtube-dl--playlist-reverse (list)
  "Return a copy of LIST with the indexes reversed."
  (let ((max (cl-loop for entry in list
                      maximize (plist-get entry :index))))
    (cl-loop for entry in list
             for index = (plist-get entry :index)
             for copy = (copy-sequence entry)
             collect (plist-put copy :index (- (1+ max) index)))))

(defun youtube-dl--playlist-cutoff (list n)
  "Return a sorted copy of LIST with all items except where :index < N."
  (let ((key (lambda (v) (plist-get v :index)))
        (filter (lambda (v) (< (plist-get v :index) n)))
        (copy (copy-sequence list)))
    (cl-delete-if filter (cl-stable-sort copy #'< :key key))))

;;;###autoload
(cl-defun youtube-dl-download-playlist
    (url &key directory (first 1) paused (priority 0) reverse slow)
  "Add entire playlist URL to download queue, with index prefixes.

:directory PATH -- Destination DIRECTORY for all videos.
:first INDEX -- Start downloading from a given one-based FIRST index.
:paused BOOL -- Start all download entries as PAUSED.
:priority PRIORITY -- Use this PRIORITY for all download entries.
:reverse BOOL -- REVERSE video numbering, solve problem of reversed playlists.
:slow BOOL -- Start all download entries in SLOW mode."
  (interactive
   (list (read-from-minibuffer
          "URL: "
          (when interprogram-paste-function
            (funcall interprogram-paste-function)))))
  (message "[youtube-dl] fetching playlist ...")
  (let ((videos (youtube-dl--playlist-list url)))
    (if (null videos)
        (error "Failed to fetch playlist (%s)" url)
      (let* ((max (cl-loop for entry in videos
                           maximize (plist-get entry :index)))
             (width (1+ (floor (log max 10))))
             (prefix-format (format "%%0%dd" width)))
        (when reverse
          (setf videos (youtube-dl--playlist-reverse videos)))
        (dolist (video (youtube-dl--playlist-cutoff videos first))
          (let* ((index (plist-get video :index))
                 (prefix (format prefix-format index))
                 (title (format "%s-%s" prefix (plist-get video :title)))
                 (dest (format "%s-%s" prefix "%(title)s-%(id)s.%(ext)s")))
            (youtube-dl (plist-get video :url)
                        :title title
                        :priority priority
                        :directory directory
                        :destination dest
                        :paused paused
                        :slow slow)))))))

;;; The list user interface:

(defvar youtube-dl--list-buffer-name " *youtube-dl list*"
  "The buffer name of `youtube-dl-list-mode'.")

(defun youtube-dl--list-buffer ()
  "Returns the queue listing buffer."
  (if-let ((buf (get-buffer-create youtube-dl--list-buffer-name)))
      (with-current-buffer buf
        ;; TODO: use `tabulated-list-mode'.
        ;; (tabulated-list-mode)
        (youtube-dl-list-mode)
        (current-buffer))))

(defun youtube-dl--log-buffer (&optional item)
  "Returns a `youtube-dl' log buffer for ITEM."
  (when item
    (let* ((name (youtube-dl-item-buffer item))
           (buffer (get-buffer-create name)))
      (with-current-buffer buffer
        (unless (eq major-mode 'special-mode)
          (special-mode))
        (setf youtube-dl--log-item item)
        (setf (youtube-dl-item-log item) item)
        (current-buffer)))))

;; refresh youtube-dl-list buffer (2).
(defun youtube-dl-list-redisplay ()
  "Immediately redraw the queue list buffer."
  (interactive)
  (with-current-buffer (youtube-dl--list-buffer)
    (let ((save-point (point))
          (window (get-buffer-window (current-buffer))))
      (youtube-dl--fill-listing)
      (goto-char save-point)
      (when window
        (set-window-point window save-point))
      (when hl-line-mode
        (hl-line-highlight)))))

;; refresh youtube-dl-list buffer (1).
(defun youtube-dl--redisplay ()
  "Redraw the queue list buffer only if visible."
  (let ((log-buffer (youtube-dl--log-buffer)))
    (when log-buffer
      (with-current-buffer log-buffer
        (let ((inhibit-read-only t)
              (saved-point (point))
              (saved-point-max (point-max))
              (window (get-buffer-window log-buffer)))
          (erase-buffer)
          (mapc #'insert (youtube-dl-item-log youtube-dl--log-item))
          (when window
            (set-window-point window (if (< saved-point saved-point-max)
                                         saved-point
                                       (point-max))))))))
  (when (get-buffer-window (youtube-dl--list-buffer))
    (youtube-dl-list-redisplay)))

(defun youtube-dl--pointed-item ()
  "Get item under point. But signal an error if no item under point."
  (unless (eq (current-buffer) (youtube-dl--list-buffer))
    (user-error "The operation is ONLY available in `%s' buffer" youtube-dl--list-buffer-name))
  (let ((item (nth (1- (line-number-at-pos)) youtube-dl-items)))
    (if item item (error "[youtube-dl] No item at point"))))

(defun youtube-dl-list-log ()
  "Display the log of the video under point."
  (interactive)
  (let* ((item (youtube-dl--pointed-item))
         (buffer (youtube-dl--log-buffer item)))
    (if item
        (progn
          (display-buffer buffer)
          (select-window (get-buffer-window buffer))
          (youtube-dl--redisplay))
      (error "[youtube-dl] Current item under point return nil"))))

(defun youtube-dl-list-kill-log ()
  "Kill the `youtube-dl' log buffer."
  (interactive)
  (let ((buffer (youtube-dl--log-buffer)))
    (when buffer
      (kill-buffer buffer))))

(defun youtube-dl-list-yank ()
  "Copy the URL of the video under point to the clipboard."
  (interactive)
  (when-let* ((item (youtube-dl--pointed-item))
              (url (youtube-dl-item-url item)))
    (kill-new url)
    (message "[youtube-dl] yanked %s" url)))

(defun youtube-dl-list-kill ()
  "Remove the selected item from the queue without deleting downloaded files."
  (interactive)
  (when-let* ((_ youtube-dl-items) ; avoid `youtube-dl-items' is `nil'.
              (item (youtube-dl--pointed-item))
              (proc (youtube-dl-item-process item)))
    (youtube-dl--remove item)
    (youtube-dl-list-redisplay)
    (message "[youtube-dl] process %s is killed." proc)))

(defun youtube-dl-list-pause (&optional item)
  "Pause downloading of ITEM under point."
  (interactive)
  (let* ((item (or item (youtube-dl--pointed-item)))
         (proc (youtube-dl-item-process item))
         (paused-p (youtube-dl-item-paused-p item)))
    (unless (and item paused-p)
      ;; kill the process, but keep item on list buffer for pause status.
      (when (process-live-p proc) (kill-process proc))
      ;; after killed process, also setting item structure status properties.
      (setf (youtube-dl-item-paused-p item) t)
      (setf (youtube-dl-item-running item) nil))
    (youtube-dl-list-redisplay)
    (message "[youtube-dl] process %s is paused." proc)))

(defun youtube-dl-list-resume (&optional item)
  "Resume failure/paused downloading ITEM under point."
  (interactive)
  (when-let* ((item (or item (youtube-dl--pointed-item)))
              (proc (youtube-dl-item-process item)))
    (when item
      (setf (youtube-dl-item-failures item) 0)
      (cond
       ((youtube-dl-item-paused-p item)
        (setf (youtube-dl-item-paused-p item) nil)
        (youtube-dl--run))
       ((not (youtube-dl-item-running item))
        (youtube-dl--run))
       (t
        (setf (youtube-dl-item-running item) nil)
        (youtube-dl--run)
        ;; (user-error (format "[youtube-dl] Can't resume process %s correctly. Try resume again." proc))
        ))
      (youtube-dl-list-redisplay)
      (message "[youtube-dl] process %s is resumed." proc))))

(defun youtube-dl-list-toggle-pause (&optional item)
  "Toggle pause downloading of ITEM under point."
  (interactive)
  (let* ((item (or item (youtube-dl--pointed-item)))
         (paused-p (youtube-dl-item-paused-p item)))
    (if (and item paused-p)
        (youtube-dl-list-resume item)
      (youtube-dl-list-pause item))))

(defun youtube-dl-list-toggle-pause-all ()
  "Toggle pause downloading of all items."
  (interactive)
  (let* ((item (youtube-dl--pointed-item))
         (paused-p (youtube-dl-item-paused-p item))))
  (if paused-p
      (dolist (item youtube-dl-items)
        (youtube-dl-list-pause item))
    (dolist (item youtube-dl-items)
      (youtube-dl-list-resume item))))

(defun youtube-dl-list-toggle-slow (item &optional rate-limit)
  "Set slow RATE-LIMIT on ITEM under point."
  (interactive (youtube-dl--pointed-item))
  (when item
    (let ((proc (youtube-dl-item-process item))
          (slow-p (youtube-dl-item-slow-p item))
          (rate-limit (substring-no-properties
                       (or rate-limit
                           (completing-read "[youtube-dl] limit download rate (e.g. 100K): "
                                            '("20K" "50K" "100K" "200K" "500K" "1M" "2M"))))))
      ;; restart with a slower download rate.
      (when (process-live-p proc) (kill-process proc))
      (setf (youtube-dl-item-slow-p item) (not slow-p))
      (setf (youtube-dl-item-rate-limit item) rate-limit)
      (youtube-dl--run)))
  (youtube-dl-list-redisplay))

(defun youtube-dl-list-toggle-slow-all ()
  "Set slow rate on all items."
  (interactive)
  (let* ((count (length  youtube-dl-items))
         (slow-count (cl-count-if #'youtube-dl-item-slow-p youtube-dl-items))
         (target (< slow-count (- count slow-count)))
         (rate-limit (completing-read "[youtube-dl] limit download rate (e.g. 100K): "
                                      '("20K" "50K" "100K" "200K" "500K" "1M" "2M"))))
    (dolist (item youtube-dl-items)
      (youtube-dl-list-toggle-slow item rate-limit)))
  (youtube-dl--redisplay))

(defun youtube-dl-list-priority-modify (delta)
  "Change priority of item under point by DELTA."
  (when-let ((item (youtube-dl--pointed-item)))
    (cl-incf (youtube-dl-item-priority item) delta)
    (youtube-dl--run)))

(defun youtube-dl-list-priority-up ()
  "Decrease priority of item under point."
  (interactive)
  (youtube-dl-list-priority-modify 1))

(defun youtube-dl-list-priority-down ()
  "Increase priority of item under point."
  (interactive)
  (youtube-dl-list-priority-modify -1))

(defun youtube-dl-list-next-item ()
  "Move to next item in listing buffer."
  (interactive)
  (unless (zerop (forward-line 1)) (user-error "End of buffer"))
  (unless (eobp) (beginning-of-line)))

(defun youtube-dl-list-prev-item ()
  "Move to previous item in listing buffer."
  (interactive)
  (when (<= (line-number-at-pos) 1)
    (user-error "Beginning of buffer"))
  (forward-line -1)
  (beginning-of-line))

(defvar youtube-dl-list-mode-map
  (let ((map (make-sparse-keymap)))
    (prog1 map
      (define-key map "a" #'youtube-dl)
      (define-key map "g" #'youtube-dl-list-redisplay)
      (define-key map "l" #'youtube-dl-list-log)
      (define-key map "L" #'youtube-dl-list-kill-log)
      (define-key map "y" #'youtube-dl-list-yank)
      (define-key map "k" #'youtube-dl-list-kill)
      (define-key map "p" #'youtube-dl-list-toggle-pause)
      (define-key map "P" #'youtube-dl-list-toggle-pause-all)
      (define-key map "r" #'youtube-dl-list-resume)
      (define-key map "s" #'youtube-dl-list-toggle-slow)
      (define-key map "S" #'youtube-dl-list-toggle-slow-all)
      (define-key map "]" #'youtube-dl-list-priority-up)
      (define-key map "[" #'youtube-dl-list-priority-down)
      (define-key map [down] #'youtube-dl-list-next-item)
      (define-key map [up]   #'youtube-dl-list-prev-item)
      (define-key map "q" #'youtube-dl-list-close-window)))
  "Keymap for `youtube-dl-list-mode'.")

(defun youtube-dl-list-close-window ()
  "Close the \"*youtube-dl list*\" buffer window."
  (interactive)
  (delete-window (get-buffer-window youtube-dl--list-buffer-name)))

(defvar-local youtube-dl-list--auto-close-window-timer nil
  "A timer to auto close \"*youtube-dl list*\" window.")

(defun youtube-dl-list--auto-close-window ()
  "Auto close \"*youtube-dl list*\" buffer after finished all downloading."
  (when (equal (length youtube-dl-items) 0)
    (when-let ((buf (get-buffer-window (youtube-dl--list-buffer))))
      (delete-window buf)
      (when (timerp youtube-dl-list--auto-close-window-timer)
        (cancel-timer youtube-dl-list--auto-close-window-timer)))))

(defvar youtube-dl-list--format
  ;;   (percentage download-rate)
  ;;             v
  ;;space,vid,progress  size    eta    fails
  ;;|    |      |        |       |       |    status
  ;;|    |      |        |       |       |      |   title
  ;;v    v      v        v       v       v      v    v
  "%s%-16s %-22.22s %-10.10s %-6.6s %-7.7s %-8.8s %s"
  "Define the `youtube-dl-list-mode' `header-line-format' and list item format.")

(define-derived-mode youtube-dl-list-mode special-mode "youtube-dl"
  "Major mode for listing the `youtube-dl' download queue."
  :group 'youtube-dl
  (use-local-map youtube-dl-list-mode-map)
  (hl-line-mode)
  (setq-local truncate-lines t) ; truncate long line text.
  (setf header-line-format
        (propertize
         (format youtube-dl-list--format
                 (propertize " " 'display '((space :align-to 0))) ; space
                 "       vid " "|       progress" "|   size" "| ETA" "| fails" "| status"
                 (concat "| title " (make-string 100 (string-to-char " "))))
         'face '(:inverse-video t :extend t))))

(defface youtube-dl-type-video
  '((t :foreground "green"))
  "Face for video type."
  :group 'youtube-dl)

(defface youtube-dl-type-audio
  '((t :foreground "DeepSkyBlue"))
  "Face for audio type."
  :group 'youtube-dl)

(defface youtube-dl-type-subtitle
  '((t :foreground "dark gray"))
  "Face for subtitle type."
  :group 'youtube-dl)

(defface youtube-dl-type-thumbnail
  '((t :foreground "pink"))
  "Face for thumbnail type."
  :group 'youtube-dl)

(defun youtube-dl--face-for-type (type)
  "Return the face for TYPE."
  (cl-case type
    (video 'youtube-dl-type-video)
    (audio 'youtube-dl-type-audio)
    (subtitle 'youtube-dl-type-subtitle)
    (thumbnail 'youtube-dl-type-thumbnail)))

(defun youtube-dl--get-type-for-extension (extension)
  "Return media type depend on EXTENSION."
  (cond
   ((member extension '("avi" "rmvb" "ogg" "ogv" "mp4" "mkv" "mov" "webm" "flv" "ts" "mpg"))
    'video)
   ((member extension '("flac" "mp3" "wav" "m4a"))
    'audio)
   ((member extension '("ass" "srt" "sub" "vtt" "ssf"))
    'subtitle)
   ((member extension '("heic" "svg" "webp" "png" "gif" "tiff" "jpeg" "jpg" "xpm" "xbm" "pbm"))
    'thumbnail)))

;;; refresh youtube-dl-list buffer (3).
(defun youtube-dl--fill-listing ()
  "Erase and redraw the queue in the queue listing buffer."
  (with-current-buffer (youtube-dl--list-buffer)
    (let* ((inhibit-read-only t)
           (active (youtube-dl--current)))
      (erase-buffer)
      (dolist (item youtube-dl-items)
        (let ((vid (youtube-dl-item-vid item))
              (running (youtube-dl-item-running item))
              (failures (youtube-dl-item-failures item))
              (priority (youtube-dl-item-priority item))
              (percentage (youtube-dl-item-percentage item))
              (download-rate (youtube-dl-item-download-rate item))
              (paused-p (youtube-dl-item-paused-p item))
              (slow-p (youtube-dl-item-slow-p item))
              (rate-limit (youtube-dl-item-rate-limit item))
              (total-size (youtube-dl-item-total-size item))
              (eta (youtube-dl-item-eta item))
              (type (youtube-dl-item-type item))
              (title (youtube-dl-item-title item))
              (url (youtube-dl-item-url item)))
          (insert
           (propertize
            (format (concat youtube-dl-list--format "\n")
                    ;; space
                    " "
                    ;; (propertize " " 'display '((space :align-to 0)))
                    ;; vid
                    (if running         ; update `:running' property every time process update.
                        (propertize vid 'face 'default)
                      (propertize vid 'face 'youtube-dl-pause))
                    ;; progress (percentage download-rate)
                    (if (and percentage download-rate)
                        (propertize (format "⦼%-5.5s ⇩%-17.17s " percentage download-rate) 'face 'youtube-dl-active)
                      (propertize (format "⦼%-5.5s ⇩%-17.17s " percentage download-rate) 'face 'youtube-dl-pause))
                    ;; size
                    (or (propertize (format "%s" total-size) 'face 'youtube-dl-pause) "-")
                    ;; eta
                    (or (propertize (format "%s" eta) 'face 'youtube-dl-pause) "?")
                    ;; failure
                    (if (= failures 0)
                        ""
                      (propertize (format " [%d] " failures) 'face 'youtube-dl-failure))
                    ;; priority
                    ;; (if (= priority 0)
                    ;;     ""
                    ;;   (propertize (format "%+d " priority) 'face 'youtube-dl-priority))
                    ;; status
                    (concat
                     (if slow-p (propertize "SLOW" 'face 'youtube-dl-slow))
                     (if rate-limit (propertize (format "≤ %s" rate-limit) 'face 'youtube-dl-slow))
                     (if paused-p (propertize "PAUSE" 'face 'youtube-dl-pause)))
                    ;; title
                    (or (propertize title 'face (youtube-dl--face-for-type type)) ""))
            'url url)))))))

;;;###autoload
(defun youtube-dl-list ()
  "Display a list of all videos queued for download."
  (interactive)
  (youtube-dl--fill-listing)
  ;; set timer to auto close `youtube-dl--list-buffer' "*youtube-dl list*" buffer after finished all downloading.
  (when (and youtube-dl-auto-close-list-buffer
             (buffer-live-p (youtube-dl--list-buffer)))
    (with-current-buffer (youtube-dl--list-buffer)
      (unless (timerp youtube-dl-list--auto-close-window-timer)
        (setq-local youtube-dl-list--auto-close-window-timer
                    (run-with-timer 0 20 #'youtube-dl-list--auto-close-window)))
      ;; jump to beginning of buffer.
      (goto-char (point-min))))
  (display-buffer (youtube-dl--list-buffer)))

;;;###autoload
(defun youtube-dl-download-audio (url)
  "Download audio format of URL."
  (interactive
   (list (read-from-minibuffer
          "URL: " (or (thing-at-point 'url)
                      (when interprogram-paste-function
                        (funcall interprogram-paste-function))))))
  (let ((youtube-dl-extra-arguments
         (append youtube-dl-extra-arguments '("--extract-audio" "--audio-format" "mp3" "--embed-thumbnail"))))
    (youtube-dl url)))

;;;###autoload
(defun youtube-dl-download-subtitle (url)
  "Download video subtitle of URL."
  (interactive
   (list (read-from-minibuffer
          "URL: " (or (thing-at-point 'url)
                      (when interprogram-paste-function
                        (funcall interprogram-paste-function))))))
  (let ((youtube-dl-extra-arguments
         (append youtube-dl-extra-arguments
                 '("--skip-download"
                   "--write-sub" ; write subtitle file
                   "--write-auto-sub" ; write auto generated subtitle file
                   "--sub-lang" "en,zh-Hans" ; use --list-subs for a list of available language tags.
                   "--sub-format" "ass/srt/best" ; ass/srt/best, srt, vtt, ttml, srv3, srv2, srv1
                   ))))
    (youtube-dl url)))

;;;###autoload
(defun youtube-dl-download-thumbnail (url)
  "Download video thumbnail of URL."
  (interactive
   (list (read-from-minibuffer
          "URL: " (or (thing-at-point 'url)
                      (when interprogram-paste-function
                        (funcall interprogram-paste-function))))))
  (let ((youtube-dl-extra-arguments
         (append youtube-dl-extra-arguments '("--skip-download" "--write-thumbnail"))))
    (youtube-dl url)))

;;;###autoload
(defun youtube-dl-download-to-directory (url)
  "Download video of URL to a interactively selected directory.

Available options:
- current working directory
- `org-attach' directory"
  (interactive
   (list (read-from-minibuffer
          "URL: " (or (thing-at-point 'url)
                      (when interprogram-paste-function
                        (funcall interprogram-paste-function))
                      (car (ignore-errors (org-entry-get-multivalued-property nil "URL")))))))
  (let* ((video-or-audio? (yes-or-no-p "[youtube-dl] download video [y] or audio [n] ? "))
         (youtube-dl-extra-arguments (if video-or-audio?
                                         (append youtube-dl-extra-arguments
                                                 '("--embed-metadata" "--embed-thumbnail"))
                                       (append youtube-dl-extra-arguments
                                               '("--extract-audio" "--audio-format" "mp3" "--embed-thumbnail"))))
         (destination (read-string "[youtube-dl] Input filename: "
                                   (let ((destination (youtube-dl--get-destination url)))
                                     (if (eq major-mode 'org-mode)
                                         (concat (substring-no-properties (org-get-heading t t t t))
                                                 "."
                                                 (if video-or-audio?
                                                     (or (file-name-extension destination) "mp4")
                                                   "mp3"))
                                       destination))))
         (title (file-name-base destination))
         (directory (let* ((dir-org-attach (when (eq major-mode 'org-mode)
                                             (if (org-attach-dir) (org-attach-dir)
                                               (org-attach-dir-get-create))))
                           (dir-list (list dir-org-attach
                                           default-directory
                                           youtube-dl-download-directory)))
                      (completing-read "[youtube-dl] Select download directory: "
                                       dir-list 'stringp nil nil nil dir-org-attach nil))))
    (youtube-dl url :destination destination :title title :directory directory)
    ;; use `org-insert-link'
    ;; (if (string-empty-p destination)
    ;;     (org-insert-link t)
    ;;   (org-insert-link nil (expand-file-name destination directory) destination))
    ;; or use `org-insert-last-stored-link'
    (cl-case org-attach-store-link-p
      (attached
       (push (list (concat "attachment:" destination) destination) org-stored-links))
      (file
       (push (list (concat "file:" (file-name-concat (org-attach-dir) destination)) destination) org-stored-links)))
    (message "[youtube-dl] You can press [C-c C-l] `org-insert-last-stored-link' to insert link.")
    ;; insert last stored link when on empty line
    (when (equal (line-beginning-position) (line-end-position))
      (call-interactively 'org-insert-last-stored-link))))


(provide 'youtube-dl)

;;; youtube-dl.el ends here