;;; eplot.el --- Manage and Edit Wordpress Posts -*- lexical-binding: t -*-

 ;; Copyright (C) 2024 Free Software Foundation, Inc.

 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>

 ;; Keywords: charts

 ;; Package: eplot

 ;; Version: 1.0

 ;; Package-Requires: ((emacs "29.0.59") (pcsv "0.0"))

 ;; eplot 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.

 ;;; Commentary:

 ;; The main entry point is `M-x eplot' in a buffer with time series

 ;; data.

 ;;

 ;; If installing manually, put something like the following in your

 ;; Emacs init file (but adjust the path to where you've put eplot):

 ;; 

 ;; (push "~/src/eplot/" load-path)

 ;; (autoload 'eplot "eplot" nil t)

 ;; (autoload 'eplot-mode "eplot" nil t)

 ;; (unless (assoc "\\.plt" auto-mode-alist)

 ;;   (setq auto-mode-alist (cons '("\\.plt" . eplot-mode) auto-mode-alist)))

 ;; This requires the pcsv package to parse CSV files.

 ;;; Code:

 (require 'svg)

 (require 'cl-lib)

 (require 'face-remap)

 (require 'eieio)

 (require 'iso8601)

 (require 'transient)

 (defvar eplot--user-defaults nil)

 (defvar eplot--chart-headers nil)

 (defvar eplot--plot-headers nil)

 (defvar eplot--transient-settings nil)

 (defvar eplot--colors

   '("aliceblue" "antiquewhite" "aqua" "aquamarine" "azure" "beige" "bisque"

     "black" "blanchedalmond" "blue" "blueviolet" "brown" "burlywood"

     "cadetblue" "chartreuse" "chocolate" "coral" "cornflowerblue" "cornsilk"

     "crimson" "cyan" "darkblue" "darkcyan" "darkgoldenrod" "darkgray"

     "darkgreen" "darkgrey" "darkkhaki" "darkmagenta" "darkolivegreen"

     "darkorange" "darkorchid" "darkred" "darksalmon" "darkseagreen"

     "darkslateblue" "darkslategray" "darkslategrey" "darkturquoise"

     "darkviolet" "deeppink" "deepskyblue" "dimgray" "dimgrey" "dodgerblue"

     "firebrick" "floralwhite" "forestgreen" "fuchsia" "gainsboro" "ghostwhite"

     "gold" "goldenrod" "gray" "green" "greenyellow" "grey" "honeydew" "hotpink"

     "indianred" "indigo" "ivory" "khaki" "lavender" "lavenderblush" "lawngreen"

     "lemonchiffon" "lightblue" "lightcoral" "lightcyan" "lightgoldenrodyellow"

     "lightgray" "lightgreen" "lightgrey" "lightpink" "lightsalmon"

     "lightseagreen" "lightskyblue" "lightslategray" "lightslategrey"

     "lightsteelblue" "lightyellow" "lime" "limegreen" "linen" "magenta"

     "maroon" "mediumaquamarine" "mediumblue" "mediumorchid" "mediumpurple"

     "mediumseagreen" "mediumslateblue" "mediumspringgreen" "mediumturquoise"

     "mediumvioletred" "midnightblue" "mintcream" "mistyrose" "moccasin"

     "navajowhite" "navy" "oldlace" "olive" "olivedrab" "orange" "orangered"

     "orchid" "palegoldenrod" "palegreen" "paleturquoise" "palevioletred"

     "papayawhip" "peachpuff" "peru" "pink" "plum" "powderblue" "purple" "red"

     "rosybrown" "royalblue" "saddlebrown" "salmon" "sandybrown" "seagreen"

     "seashell" "sienna" "silver" "skyblue" "slateblue" "slategray" "slategrey"

     "snow" "springgreen" "steelblue" "tan" "teal" "thistle" "tomato"

     "turquoise" "violet" "wheat" "white" "whitesmoke" "yellow" "yellowgreen"))

 (defun eplot-set (header value)

   "Set the default value of HEADER to VALUE.

 To get a list of all possible HEADERs, use the `M-x

 eplot-list-chart-headers' command.

 Also see `eplot-reset'."

   (let ((elem (or (assq header eplot--chart-headers)

 		  (assq header eplot--plot-headers))))

     (unless elem

       (error "No such header type: %s" header))

     (eplot--add-default header value)))

 (defun eplot--add-default (header value)

   ;; We want to preserve the order defaults have been added, so that

   ;; we can apply them in the same order.  This makes a difference

   ;; when we're dealing with specs that have inheritence.

   (setq eplot--user-defaults (delq (assq header eplot--user-defaults)

 				   eplot--user-defaults))

   (setq eplot--user-defaults (list (cons header value))))

 (defun eplot-reset (&optional header)

   "Reset HEADER to defaults.

 If HEADER is nil or not present, reset everything to defaults."

   (if header

       (setq eplot--user-defaults (delq (assq header eplot--user-defaults)

 				       eplot--user-defaults))

     (setq eplot--user-defaults nil)))

 (unless (assoc "\\.plt" auto-mode-alist)

   (setq auto-mode-alist (cons '("\\.plt" . eplot-mode) auto-mode-alist)))

 ;;; eplot modes.

 (defvar-keymap eplot-mode-map

   "C-c C-c" #'eplot-update-view-buffer

   "C-c C-p" #'eplot-switch-view-buffer

   "C-c C-e" #'eplot-list-chart-headers

   "C-c C-v" #'eplot-customize

   "C-c C-l" #'eplot-create-controls

   "TAB" #'eplot-complete)

 ;; # is working overtime in the syntax here:

 ;;  It can be a color like Color: #e0e0e0, and

 ;;  it can be a setting like 33 # Label: Apples,

 ;;  when it starts a line it's a comment.

 (defvar eplot-font-lock-keywords

   `(("^[ \t\n]*#.*" . font-lock-comment-face)

     ("^[^ :\n]+:" . font-lock-keyword-face)

     ("#[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]\\([0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]\\)?" . font-lock-variable-name-face)

     ("#.*" . font-lock-builtin-face)))

 (define-derived-mode eplot-mode text-mode "eplot"

   "Major mode for editing charts.

 Use the \\[eplot-list-chart-headers] command to get a list of all

 possible chart headers."

   (setq-local completion-at-point-functions

 	      (cons 'eplot--complete-header completion-at-point-functions))

   (setq-local font-lock-defaults

 	      '(eplot-font-lock-keywords nil nil nil)))

 (defun eplot-complete ()

   "Complete headers."

   (interactive)

   (cond

    ((let ((completion-fail-discreetly t))

       (completion-at-point))

     ;; Completion was performed; nothing else to do.

     nil)

    (t (indent-relative))))

 (defun eplot--complete-header ()

   (or

    ;; Complete headers names.

    (and (or (looking-at ".*:")

 	    (and (looking-at "[ \t]*$")

 		 (save-excursion

 		   (beginning-of-line)

 		   (not (looking-at "\\(.+\\):")))))

 	(lambda ()

 	  (let ((headers (mapcar

 			  (lambda (h)

 			    (if (looking-at ".*:")

 				(capitalize (symbol-name (car h)))

 			      (concat (capitalize (symbol-name (car h))) ": ")))

 			  (save-excursion

 			    ;; If we're after the headers, then we want

 			    ;; to complete over the plot headers.  Otherwise,

 			    ;; complete over the chart headers.

 			    (if (and (not (bobp))

 				     (progn

 				       (forward-line -1)

 				       (re-search-backward "^[ \t]*$" nil t)))

 				eplot--plot-headers

 			      eplot--chart-headers))))

 		(completion-ignore-case t))

 	    (completion-in-region (pos-bol) (line-end-position) headers)

 	    'completion-attempted)))

    ;; Complete header values.

    (let ((hname nil))

      (and (save-excursion

 	    (and (looking-at "[ \t]*$")

 		 (progn

 		   (beginning-of-line)

 		   (and (looking-at "\\(.+\\):")

 			(setq hname (intern (downcase (match-string 1)))))))

 	    (lambda ()

 	      (let ((valid (plist-get

 			    (cdr (assq hname (append eplot--plot-headers

 						     eplot--chart-headers)))

 			    :valid))

 		    (completion-ignore-case t))

 		(completion-in-region

 		 (save-excursion

 		   (search-backward ":" (pos-bol) t)

 		   (skip-chars-forward ": \t")

 		   (point))

 		 (line-end-position)

 		 (mapcar #'symbol-name valid))

 		'completion-attempted)))))))

 (define-minor-mode eplot-minor-mode

   "Minor mode to issue commands from an eplot data buffer."

   :lighter " eplot")

 (defvar-keymap eplot-minor-mode-map

   "H-l" #'eplot-eval-and-update)

 (defvar-keymap eplot-view-mode-map

   "s" #'eplot-view-write-file

   "w" #'eplot-view-write-scaled-file

   "c" #'eplot-view-customize

   "l" #'eplot-create-controls)

 (define-derived-mode eplot-view-mode special-mode "eplot view"

   "Major mode for displaying eplots."

   (setq-local revert-buffer-function #'eplot-update

 	      cursor-type nil))

 (defun eplot-view-write-file (file &optional width)

   "Write the current chart to a file.

 If you type in a file name that ends with something else than \"svg\",

 ImageMagick \"convert\" will be used to convert the image first.

 If writing to a PNG file, \"rsvg-conver\" will be used instead if

 it exists as this usually gives better results."

   (interactive "FWrite to file name: ")

   (when (and (file-exists-p file)

 	     (not (yes-or-no-p "File exists, overwrite? ")))

     (error "Not overwriting the file"))

   (save-excursion

     (goto-char (point-min))

     (let ((match

 	   (text-property-search-forward 'display nil

 					 (lambda (_ e)

 					   (and (consp e)

 						(eq (car e) 'image))))))

       (unless match

 	(error "Can't find an image in the current buffer"))

       (let ((svg (plist-get (cdr (prop-match-value match)) :data))

 	    (tmp " *eplot convert*")

 	    (executable (if width "rsvg-convert" "convert"))

 	    sfile ofile)

 	(unless svg

 	  (error "Invalid image in the current buffer"))

 	(with-temp-buffer

 	  (set-buffer-multibyte nil)

 	  (svg-print svg)

 	  (if (string-match-p "\\.svg\\'" file)

 	      (write-region (point-min) (point-max) file)

 	    (if (and (string-match-p "\\.png\\'" file)

 		     (executable-find "rsvg-convert"))

 		(setq executable "rsvg-convert")

 	      (unless (executable-find executable)

 		(error "%s isn't installed; can only save svg files"

 		       executable)))

 	    (when (and (equal executable "rsvg-convert")

 		       (not (string-match-p "\\.png\\'" file))

 		       (not (executable-find "convert")))

 	      (error "Can only write PNG files when scaling because \"convert\" isn't installed"))

 	    (unwind-protect

 		(progn

 		  (setq sfile (make-temp-file "eplot" nil ".svg")

 			ofile (make-temp-file "eplot" nil ".png"))

 		  (write-region (point-min) (point-max) sfile nil 'silent)

 		  ;; We don't use `call-process-region', because

 		  ;; convert doesn't seem to like that?

 		  (let ((code (if (equal executable "rsvg-convert")

 				  (apply

 				   #'call-process

 				   executable nil (get-buffer-create tmp) nil

 				   `(,(format "--output=%s"

 					      (expand-file-name ofile))

 				     ,@(and width

 					    `(,(format "--width=%d" width)

 					      "--keep-aspect-ratio"))

 				     ,sfile))

 				(call-process

 				 executable nil (get-buffer-create tmp) nil

 				 sfile file))))

 		    (eplot--view-error code tmp)

 		    (when (file-exists-p ofile)

 		      (if (string-match-p "\\.png\\'" file)

 			  (rename-file ofile file)

 			(let ((code (call-process "convert" nil tmp nil

 						  ofile file)))

 			  (eplot--view-error code tmp))))

 		    (message "Wrote %s" file)))

 	      ;; Clean-up.

 	      (when (get-buffer tmp)

 		(kill-buffer tmp))

 	      (when (file-exists-p sfile)

 		(delete-file sfile))

 	      (when (file-exists-p ofile)

 		(delete-file sfile)))))))))

 (defun eplot--view-error (code tmp)

   (unless (zerop code)

     (error "Error code %d: %s"

 	   code

 	   (with-current-buffer tmp

 	     (while (search-forward "[ \t\n]+" nil t)

 	       (replace-match " "))

 	     (string-trim (buffer-string))))))

 (defun eplot-view-write-scaled-file (width file)

   "Write the current chart to a rescaled to a file.

 The rescaling is done by \"rsvg-convert\", which has to be

 installed.  Rescaling is done when rendering, so this should give

 you a clear, non-blurry version of the chart at any size."

   (interactive "nWidth: \nFWrite to file: ")

   (eplot-view-write-file file width))

 (defun eplot-view-customize ()

   "Customize the settings for the chart in the current buffer."

   (interactive)

   (with-suppressed-warnings ((interactive-only eplot-customize))

     (eplot-customize)))

 (defvar eplot--data-buffer nil)

 (defvar eplot--current-chart nil)

 (defun eplot ()

   "Plot the data in the current buffer."

   (interactive)

   (eplot-update-view-buffer))

 (defun eplot-with-headers (header-file)

   "Plot the data in the current buffer using headers from a file."

   (interactive "fHeader file: ")

   (eplot-update-view-buffer

    (with-temp-buffer

      (insert-file-contents header-file)

      (eplot--parse-headers))))

 (defun eplot-switch-view-buffer ()

   "Switch to the eplot view buffer and render the chart."

   (interactive)

   (eplot-update-view-buffer nil t))

 (defun eplot-update-view-buffer (&optional headers switch)

   "Update the eplot view buffer based on the current data buffer."

   (interactive)

   ;; This is mainly useful during implementation.

   (if (and (eq major-mode 'emacs-lisp-mode)

 	   (get-buffer-window "*eplot*" t))

       (with-current-buffer "*eplot*"

 	(eplot-update)

 	(when-let ((win (get-buffer-window "*eplot*" t)))

 	  (set-window-point win (point-min))))

     ;; Normal case.

     (let* ((eplot--user-defaults (eplot--settings-table))

 	   (data (eplot--parse-buffer))

 	   (data-buffer (current-buffer))

 	   (window (selected-window)))

       (unless data

 	(user-error "No data in the current buffer"))

       (setq data (eplot--inject-headers data headers))

       (if (get-buffer-window "*eplot*" t)

 	  (set-buffer "*eplot*")

 	(if switch

 	    (pop-to-buffer-same-window "*eplot*")

 	  (pop-to-buffer "*eplot*")))

       (let ((inhibit-read-only t))

 	(erase-buffer)

 	(unless (eq major-mode 'eplot-view-mode)

 	  (eplot-view-mode))

 	(setq-local eplot--data-buffer data-buffer)

 	(let ((chart (eplot--render data)))

 	  (with-current-buffer data-buffer

 	    (setq-local eplot--current-chart chart)))

 	(insert "\n")

 	(when-let ((win (get-buffer-window "*eplot*" t)))

 	  (set-window-point win (point-min))))

       (select-window window))))

 (defun eplot--settings-table ()

   (if (not eplot--transient-settings)

       eplot--user-defaults

     (append eplot--user-defaults eplot--transient-settings)))

 (defun eplot--inject-headers (data headers)

   ;; It's OK not to separate the plot headers from the chart

   ;; headers.  Collect them here, if any.

   (when-let ((plot-headers

 	      (cl-loop for elem in (mapcar #'car eplot--plot-headers)

 		       for value = (eplot--vs elem headers)

 		       when value

 		       collect (progn

 				 ;; Remove these headers from the data

 				 ;; headers so that we don't get errors

 				 ;; on undefined headers.

 				 (setq headers (delq (assq elem headers)

 						     headers))

 				 (cons elem value)))))

     (dolist (plot (cdr (assq :plots data)))

       (let ((headers (assq :headers plot)))

 	(if headers

 	    (nconc headers plot-headers)

 	  (nconc plot (list (list :headers plot-headers)))))))

   (append data headers))

 (defun eplot-eval-and-update ()

   "Helper command when developing."

   (interactive nil emacs-lisp-mode)

   (save-some-buffers t)

   (elisp-eval-region-or-buffer)

   (eval-defun nil)

   (eplot-update-view-buffer))

 ;;; Parsing buffers.

 (defun eplot-update (&rest _ignore)

   "Update the plot in the current buffer."

   (interactive)

   (unless eplot--data-buffer

     (user-error "No data buffer associated with this eplot view buffer"))

   (let ((data (with-current-buffer eplot--data-buffer

 		(eplot--parse-buffer)))

 	(eplot--user-defaults (with-current-buffer eplot--data-buffer

 				(eplot--settings-table)))

 	(inhibit-read-only t))

     (erase-buffer)

     (let ((chart (eplot--render data)))

       (with-current-buffer eplot--data-buffer

 	(setq-local eplot--current-chart chart)))

     (insert "\n\n")))

 (defun eplot--parse-buffer ()

   (if (eq major-mode 'org-mode)

       (eplot--parse-org-buffer)

     (eplot--parse-eplot-buffer)))

 (defun eplot--parse-eplot-buffer ()

   (if (eplot--csv-buffer-p)

       (eplot--parse-csv-buffer)

     (let ((buf (current-buffer)))

       (with-temp-buffer

 	(insert-buffer-substring buf)

 	;; Remove comments first.

 	(goto-char (point-min))

 	(while (re-search-forward "^[ \t]*#" nil t)

 	  (delete-line))

 	(goto-char (point-min))

 	;; First headers.

 	(let* ((data (eplot--parse-headers))

 	       (plot-headers

 		;; It's OK not to separate the plot headers from the chart

 		;; headers.  Collect them here, if any.

 		(cl-loop for elem in (mapcar #'car eplot--plot-headers)

 			 for value = (eplot--vs elem data)

 			 when value

 			 collect (progn

 				   ;; Remove these headers from the data

 				   ;; headers so that we don't get errors

 				   ;; on undefined headers.

 				   (setq data (delq (assq elem data) data))

 				   (cons elem value))))

 	       plots)

 	  ;; Then the values.

 	  (while-let ((plot (eplot--parse-values nil plot-headers)))

 	    (setq plot-headers nil)

 	    (push plot plots))

 	  (when plots

 	    (push (cons :plots (nreverse plots)) data))

 	  data)))))

 (defun eplot--parse-headers ()

   (let ((data nil)

 	type value)

     (while (looking-at "\\([^\n\t :]+\\):\\(.*\\)")

       (setq type (intern (downcase (match-string 1)))

 	    value (substring-no-properties (string-trim (match-string 2))))

       (forward-line 1)

       ;; Get continuation lines.

       (while (looking-at "[ \t]+\\(.*\\)")

 	(setq value (concat value " " (string-trim (match-string 1))))

 	(forward-line 1))

       (if (eq type 'header-file)

 	  (setq data (nconc data

 			    (with-temp-buffer

 			      (insert-file-contents value)

 			      (eplot--parse-headers))))

 	;; We don't use `push' here because we want to preserve order

 	;; also when inserting headers from other files.

 	(setq data (nconc data (list (cons type value))))))

     data))

 (defun eplot--parse-values (&optional in-headers data-headers)

   ;; Skip past separator lines.

   (while (looking-at "[ \t]*\n")

     (forward-line 1))

   (let* ((values nil)

 	 ;; We may have plot-specific headers.

 	 (headers (nconc (eplot--parse-headers) data-headers))

 	 (data-format (or (eplot--vyl 'data-format headers)

 			  (eplot--vyl 'data-format in-headers)))

 	 (two-values (memq 'two-values data-format))

 	 (xy (or (memq 'year data-format)

 		 (memq 'date data-format)

 		 (memq 'time data-format)

 		 (memq 'xy data-format)))

 	 (data-column (or (eplot--vn 'data-column headers)

 			  (eplot--vn 'data-column in-headers))))

     (if-let ((data-file (eplot--vs 'data-file headers)))

 	(with-temp-buffer

 	  (insert-file-contents data-file)

 	  (setq values (cdr (assq :values (eplot--parse-values headers)))

 		headers (delq (assq 'data headers) headers)))

       ;; Now we come to the data.  The data is typically either just a

       ;; number, or two numbers (in which case the first number is a

       ;; date or a time).  Labels ans settings can be introduced with

       ;; a # char.

       (while (looking-at "\\([-0-9. \t]+\\)\\([ \t]*#\\(.*\\)\\)?")

 	(let ((numbers (match-string 1))

 	      (settings (eplot--parse-settings (match-string 3)))

 	      this)

 	  (setq numbers (mapcar #'string-to-number

 				(split-string (string-trim numbers))))

 	  ;; If we're reading two dimensionalish data, the first

 	  ;; number is the date/time/x.

 	  (when xy

 	    (setq this (list :x (pop numbers))))

 	  ;; Chop off all the numbers until we read the column(s)

 	  ;; we're using.

 	  (when data-column

 	    (setq numbers (nthcdr (1- data-column) numbers)))

 	  (when numbers

 	    (setq this (nconc this (list :value (pop numbers)))))

 	  (when two-values

 	    (setq this (nconc this (list :extra-value (pop numbers)))))

 	  (when settings

 	    (setq this (nconc this (list :settings settings))))

 	  (when (plist-get this :value)

 	    (push this values)))

 	(forward-line 1))

       (setq values (nreverse values)))

     (and values

 	 `((:headers . ,headers) (:values . ,values)))))

 (defun eplot--parse-settings (string)

   (when string

     (with-temp-buffer

       (insert (string-trim string) "\n")

       (goto-char (point-min))

       (while (re-search-forward "\\(.\\)," nil t)

 	(if (equal (match-string 1) "\\")

 	    (replace-match "," t t)

 	  (delete-char -1)

 	  (insert "\n")

 	  (when (looking-at "[ \t]+")

 	    (replace-match ""))))

       (goto-char (point-min))

       (eplot--parse-headers))))

 ;;; Accessing data.

 (defun eplot--vn (type data &optional default)

   (if-let ((value (cdr (assq type data))))

       (string-to-number value)

     default))

 (defun eplot--vs (type data &optional default)

   (or (cdr (assq type data)) default))

 (defun eplot--vy (type data &optional default)

   (if-let ((value (cdr (assq type data))))

       (intern (downcase value))

     default))

 (defun eplot--vyl (type data &optional default)

   (if-let ((value (cdr (assq type data))))

       (mapcar #'intern (split-string (downcase value)))

     default))

 (defmacro eplot-def (args doc-string)