;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2022 Philip McGrath <philip@philipmcgrath.com>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix 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 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix 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 GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (guix build elm-build-system)
  #:use-module ((guix build gnu-build-system) #:prefix gnu:)
  #:use-module (guix build utils)
  #:use-module (guix build union)
  #:use-module (ice-9 ftw)
  #:use-module (ice-9 rdelim)
  #:use-module (ice-9 regex)
  #:use-module (ice-9 match)
  #:use-module (ice-9 popen)
  #:use-module (ice-9 vlist)
  #:use-module (json)
  #:use-module (srfi srfi-1)
  #:use-module (srfi srfi-26)
  #:use-module (srfi srfi-71)
  #:export (%standard-phases
            patch-application-dependencies
            patch-json-string-escapes
            read-offline-registry->vhash
            elm-build))

;;; Commentary:
;;;
;;; Elm draws a sharp distinction between "projects" with `{"type":"package"}`
;;; vs. `{"type":"application"}` in the "elm.json" file: see
;;; <https://github.com/elm/compiler/blob/master/docs/elm.json/package.md> and
;;; <https://github.com/elm/compiler/blob/master/docs/elm.json/application.md>.
;;; For now, `elm-build-system` is designed for "package"s: packaging
;;; "application"s requires ad-hoc replacements for some phases---but see
;;; `patch-application-dependencies`, which helps to work around a known issue
;;; discussed below.  It would be nice to add more streamlined support for
;;; "application"s one we have more experience building them in Guix.  For
;;; example, we could incorporate the `uglifyjs` advice from
;;; <https://github.com/elm/compiler/blob/master/hints/optimize.md>.
;;;
;;; We want building an Elm "package" to produce:
;;;
;;;   - a "docs.json" file with extracted documentation; and
;;;
;;;   - an "artifacts.dat" file with compilation results for use in building
;;;     "package"s and "application"s.
;;;
;;; Unfortunately, there isn't an entry point to the Elm compiler that builds
;;; those files directly.  Building with `elm make` does something different,
;;; more oriented toward development, testing, and building "application"s.
;;; We work around this limitation by staging the "package" we're building as
;;; though it were already installed in ELM_HOME, generating a trivial Elm
;;; "application" that depends on the "package", and building the
;;; "application", which causes the files for the "package" to be built.
;;;
;;; Much of the ceremony involved is to avoid using `elm` in ways that would
;;; make it try to do network IO beyond the bare minimum functionality for
;;; which we've patched a replacement into our `elm`.  On the other hand, we
;;; get to take advantage of the very regular structure required of Elm
;;; packages.
;;;
;;; *Known issue:* Elm itself supports multiple versions of "package"s
;;; coexisting simultaneously under ELM_HOME, but we do not support this yet.
;;; Sometimes, parallel versions coexisting causes `elm` to try to write to
;;; built "artifacts.dat" files.  For now, two workarounds are possible:
;;;
;;;  - Use `patch-application-dependencies` to rewrite an "application"'s
;;;    "elm.json" file to refer to the versions of its inputs actually
;;;    packaged in Guix.
;;;
;;;  - Use a Guix package transformation to rewrite your "application"'s
;;;    dependencies recursively, so that only one version of each Elm
;;;    "package" is included in your "application"'s build environment.
;;;
;;; Patching `elm` more extensively---perhaps adding an `elm guix`
;;; subcommand`---might let us address these issues more directly.
;;;
;;; Code:
;;;

(define %essential-elm-packages
  ;; elm/json isn't essential in a fundamental sense,
  ;; but it's required for a {"type":"application"},
  ;; which we are generating to trigger the build
  '("elm/core" "elm/json"))

(define* (target-elm-version #:optional elm)
  "Return the version of ELM or whichever 'elm' is in $PATH.
Return #false if it cannot be determined."
  (let* ((pipe (open-pipe* OPEN_READ
                           (or elm "elm")
                           "--version"))
         (line (read-line pipe)))
    (and (zero? (close-pipe pipe))
         (string? line)
         line)))

(define* (prepare-elm-home #:key native-inputs inputs #:allow-other-keys)
  "Set the ELM_HOME environment variable and populate the indicated directory
with the union of the Elm \"package\" inputs.  Also, set GUIX_ELM_VERSION to
the version of the Elm compiler in use."
  (let* ((elm (search-input-file (or native-inputs inputs) "/bin/elm"))
         (elm-version (target-elm-version elm)))
    (setenv "GUIX_ELM_VERSION" elm-version)
    (mkdir "../elm-home")
    (with-directory-excursion "../elm-home"
      (union-build elm-version
                   (search-path-as-list
                    (list (string-append "share/elm/" elm-version))
                    (map cdr inputs))
                   #:create-all-directories? #t)
      (setenv "ELM_HOME" (getcwd)))))

(define* (stage #:key native-inputs inputs  #:allow-other-keys)
  "Extract the installable files from the Elm \"package\" into a staging
directory and link it into the ELM_HOME tree.  Also, set GUIX_ELM_PKG_NAME and
GUIX_ELM_PKG_VERSION to the name and version, respectively, of the Elm package
being built, as defined in its \"elm.json\" file."
  (let* ((elm-version (getenv "GUIX_ELM_VERSION"))
         (elm-home (getenv "ELM_HOME"))
         (info (call-with-input-file "elm.json" json->scm))
         (name (assoc-ref info "name"))
         (version (assoc-ref info "version"))
         (rel-dir (string-append elm-version "/packages/" name "/" version))
         (staged-dir (string-append elm-home "/../staged/" rel-dir)))
    (setenv "GUIX_ELM_PKG_NAME" name)
    (setenv "GUIX_ELM_PKG_VERSION" version)
    (mkdir-p staged-dir)
    (mkdir-p (string-append elm-home "/" (dirname rel-dir)))
    (symlink staged-dir
             (string-append elm-home "/" rel-dir))
    (copy-recursively "src" (string-append staged-dir "/src"))
    (install-file "elm.json" staged-dir)
    (install-file "README.md" staged-dir)
    (when (file-exists? "LICENSE")
      (install-file "LICENSE" staged-dir))))

(define (patch-json-string-escapes file)
  "Work around a bug in the Elm compiler's JSON parser by attempting to
replace REVERSE-SOLIDUS--SOLIDUS escape sequences in FILE with unescaped
SOLIDUS characters."
  ;; https://github.com/elm/compiler/issues/2255
  (substitute* file
    (("\\\\/")
     "/")))

(define (directory-list dir)
  "Like DIRECTORY-LIST from 'racket/base': lists the contents of DIR, not
including the special \".\" and \"..\" entries."
  (scandir dir (lambda (f)
                 (not (member f '("." ".."))))))

(define* (make-offline-registry-file #:key inputs #:allow-other-keys)
  "Generate an \"offline-package-registry.json\" file and set
GUIX_ELM_OFFLINE_REGISTRY_FILE to its path, cooperating with a patch to `elm`
to avoid attempting to download a list of all published Elm package names and
versions from the internet."
  (let* ((elm-home (getenv "ELM_HOME"))
         (elm-version (getenv "GUIX_ELM_VERSION"))
         (registry-file
          (string-append elm-home "/../offline-package-registry.json"))
         (registry-alist
          ;; here, we don't need to look up entries, so we build the
          ;; alist directly, rather than using a vhash
          (with-directory-excursion
              (string-append elm-home "/" elm-version "/packages")
            (append-map (lambda (org)
                          (with-directory-excursion org
                            (map (lambda (repo)
                                   (cons (string-append org "/" repo)
                                         (list->vector (directory-list repo))))
                                 (directory-list "."))))
                        (directory-list ".")))))
    (call-with-output-file registry-file
      (cut scm->json registry-alist <>))
    (patch-json-string-escapes registry-file)
    (setenv "GUIX_ELM_OFFLINE_REGISTRY_FILE" registry-file)))

(define (read-offline-registry->vhash)
  "Return a vhash mapping Elm \"package\" names to lists of available version
strings."
  (alist->vhash
   (call-with-input-file (getenv "GUIX_ELM_OFFLINE_REGISTRY_FILE")
     json->scm)))

(define (find-indirect-dependencies registry-vhash root-pkg root-version)
  "Return the recursive dependencies of ROOT-PKG, an Elm \"package\" name, at
version ROOT-VERSION as an alist mapping Elm \"package\" names to (single)
versions.  The resulting alist will not include entries for
%ESSENTIAL-ELM-PACKAGES or for ROOT-PKG itself.  The REGISTRY-VHASH is used in
conjunction with the ELM_HOME environment variable to find dependencies."
  (with-directory-excursion
      (string-append (getenv "ELM_HOME")
                     "/" (getenv "GUIX_ELM_VERSION")
                     "/packages")
    (define (get-dependencies pkg version acc)
      (let* ((elm-json-alist
              (call-with-input-file
                  (string-append pkg "/" version "/elm.json")
                json->scm))
             (deps-alist
              (assoc-ref elm-json-alist "dependencies"))
             (deps-names
              (filter-map (match-lambda
                            ((name . range)
                             (and (not (member name %essential-elm-packages))
                                  name)))
                          deps-alist)))
        (fold register-dependency acc deps-names)))
    (define (register-dependency pkg acc)
      ;; Using vhash-cons unconditionally would add duplicate entries,
      ;; which would then cause problems when we must emit JSON.
      ;; Plus, we can avoid needlessly duplicating work.
      (if (vhash-assoc pkg acc)
          acc
          (match (vhash-assoc pkg registry-vhash)
            ((_ . #(version))
             ;; in the rare case that multiple versions are present,
             ;; just picking an arbitrary one seems to work well enough for now
             (get-dependencies pkg version (vhash-cons pkg version acc))))))
    (vlist->list
     (get-dependencies root-pkg root-version vlist-null))))

(define* (patch-application-dependencies #:key inputs #:allow-other-keys)
  "Rewrites the \"elm.json\" file in the working directory---which must be of
`\"type\":\"application\"`, not `\"type\":\"package\"`---to refer to the
dependency versions actually provided via Guix.  The
GUIX_ELM_OFFLINE_REGISTRY_FILE environment variable is used to find available
versions."
  (let* ((registry-vhash (read-offline-registry->vhash))
         (rewrite-dep-version
          (match-lambda
            ((name . _)
             (cons name (match (vhash-assoc name registry-vhash)
                          ((_ . #(version)) ;; no dot
                           version))))))
         (rewrite-direct/indirect
          (match-lambda
            ;; a little checking to avoid confusing misuse with "package"
            ;; project dependencies, which have a different shape
            (((and key (or "direct" "indirect"))
              . alist)
             `(,key ,@(map rewrite-dep-version alist)))))
         (rewrite-json-section
          (match-lambda
            (((and key (or "dependencies" "test-dependencies"))
              . alist)
             `(,key ,@(map rewrite-direct/indirect alist)))
            ((k . v)
             (cons k v))))
         (rewrite-elm-json
          (cut map rewrite-json-section <>)))
    (with-atomic-file-replacement "elm.json"
      (lambda (in out)
        (scm->json (rewrite-elm-json (json->scm in))
                   out)))
    (patch-json-string-escapes "elm.json")))

(define* (configure #:key native-inputs inputs #:allow-other-keys)
  "Generate a trivial Elm \"application\" with a direct dependency on the Elm
\"package\" currently being built."
  (let* ((info (call-with-input-file "elm.json" json->scm))
         (name (getenv "GUIX_ELM_PKG_NAME"))
         (version (getenv "GUIX_ELM_PKG_VERSION"))
         (elm-home (getenv "ELM_HOME"))
         (registry-vhash (read-offline-registry->vhash))
         (app-dir (string-append elm-home "/../fake-app")))
    (mkdir-p (string-append app-dir "/src"))
    (with-directory-excursion app-dir
      (call-with-output-file "elm.json"
        (lambda (out)
          (scm->json
           `(("type" . "application")
             ("source-directories" . #("src")) ;; intentionally no dot
             ("elm-version" . ,(getenv "GUIX_ELM_VERSION"))
             ("dependencies"
              ("direct"
               ,@(map (lambda (pkg)
                        (match (vhash-assoc pkg registry-vhash)
                          ((_ . #(pkg-version))
                           (cons pkg
                                 (if (equal? pkg name)
                                     version
                                     pkg-version)))))
                      (if (member name %essential-elm-packages)
                          %essential-elm-packages
                          (cons name %essential-elm-packages))))
              ("indirect"
               ,@(if (member name %essential-elm-packages)
                     '()
                     (find-indirect-dependencies registry-vhash
                                                 name
                                                 version))))
             ("test-dependencies"
              ("direct")
              ("indirect")))
           out)))
      (patch-json-string-escapes  "elm.json")
      (with-output-to-file "src/Main.elm"
        ;; the most trivial possible elm program
        (lambda ()
          (display "module Main exposing (..)
main : Program () () ()
main = Platform.worker
 { init = \\_ -> ( (), Cmd.none )
 , update = \\_ -> \\_ -> ( (), Cmd.none )
 , subscriptions = \\_ -> Sub.none }"))))))

(define* (build #:key native-inputs inputs #:allow-other-keys)
  "Run `elm make` to build the Elm \"application\" generated by CONFIGURE."
  (with-directory-excursion (string-append (getenv "ELM_HOME") "/../fake-app")
    (invoke (search-input-file (or native-inputs inputs) "/bin/elm")
            "make"
            "src/Main.elm")))

(define* (check #:key tests? #:allow-other-keys)
  "Does nothing, because the `elm-test` executable has not yet been packaged
for Guix."
  (when tests?
    (display "elm-test has not yet been packaged for Guix\n")))

(define* (install #:key outputs #:allow-other-keys)
  "Installs the contents of the directory generated by STAGE, including any
files added by BUILD, to the Guix package output."
  (copy-recursively
   (string-append (getenv "ELM_HOME") "/../staged")
   (string-append (assoc-ref outputs "out") "/share/elm")))

(define* (validate-compiled #:key outputs #:allow-other-keys)
  "Checks that the files \"artifacts.dat\" and \"docs.json\" have been
installed."
  (let ((base (string-append "/share/elm/"
                             (getenv "GUIX_ELM_VERSION")
                             "/packages/"
                             (getenv "GUIX_ELM_PKG_NAME")
                             "/"
                             (getenv "GUIX_ELM_PKG_VERSION")))
        (expected '("artifacts.dat" "docs.json")))
    (for-each (lambda (name)
                (search-input-file outputs (string-append base "/" name)))
              expected)))

(define %standard-phases
  (modify-phases gnu:%standard-phases
    (add-after 'unpack 'prepare-elm-home prepare-elm-home)
    (delete 'bootstrap)
    (add-after 'patch-source-shebangs 'stage stage)
    (add-after 'stage 'make-offline-registry-file make-offline-registry-file)
    (replace 'configure configure)
    (delete 'patch-generated-file-shebangs)
    (replace 'build build)
    (replace 'check check)
    (replace 'install install)
    (add-before 'validate-documentation-location 'validate-compiled
      validate-compiled)))

(define* (elm-build #:key inputs (phases %standard-phases)
                    #:allow-other-keys #:rest args)
  "Builds the given Elm project, applying all of the PHASES in order."
  (apply gnu:gnu-build #:inputs inputs #:phases phases args))
