// Package build makes the release: the files a site serves under
// /<version>/ and a static page links from one tag.
//
// Dist is the whole of it, a pure function of the tree it is handed,
// so the same tree at the same version is the same bytes and the same
// SHA256SUMS on anyone's machine. cmd/fiesta writes what Dist returns.
package build

import (
	"bytes"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"io/fs"
	"sort"
	"strings"
)

// Banner is the one comment the release keeps, at the top of every
// stylesheet and script: the version, the licence and where to read
// more. Its /*! opener is the form minifiers keep by convention.
func Banner(version string) string {
	return "/*! Fiesta " + version + " | MPL-2.0 | https://fiesta.rastrillo.org */\n"
}

// OneLinkLimit is the most a one-file theme may weigh gzipped: 25 KiB.
// It is what a static page that links fiesta.css alone pays, so it is
// the figure the size gate holds every bundle under.
const OneLinkLimit = 25 * 1024

// Gzipped is the length of b compressed at gzip level 6, the level a
// server or edge that compresses on the fly typically uses.
func Gzipped(b []byte) int { return gzipped(b) }

// defaultTheme is the theme fiesta.css carries; every other theme's
// one-file form is fiesta-<theme>.css.
const defaultTheme = "day"

// svgNS is the namespace a standalone SVG document declares. The
// inline icons leave it out, since HTML supplies it, and an <img> or
// a CSS url() will not draw an SVG without it.
const svgNS = "http://www.w3.org/2000/svg"

// bundleName is the one-file theme's file name for a theme.
func bundleName(theme string) string {
	if theme == defaultTheme {
		return "fiesta.css"
	}
	return "fiesta-" + theme + ".css"
}

// bundlesIn is the one-file theme the dist owes for every theme it
// carries: each top-level .css that is neither tokens.css, shell.css
// nor a bundle is a theme's own file, and its bundle is bundleName of
// it. Derived from the dist rather than listed, so a theme added to
// css/themes/ cannot ship without its bundle passing the gate.
func bundlesIn(dist map[string][]byte) []string {
	var names []string
	for name := range dist {
		if strings.Contains(name, "/") || !strings.HasSuffix(name, ".css") ||
			name == "tokens.css" || name == "shell.css" || name == bundleName(defaultTheme) || strings.HasPrefix(name, "fiesta-") {
			continue
		}
		names = append(names, bundleName(strings.TrimSuffix(name, ".css")))
	}
	sort.Strings(names)
	return names
}

// Dist builds the release from src, which needs LICENSE, css/, js/,
// icons/ and i18n/ and is read for nothing else, keyed by path
// relative to the version directory:
//
//   - fiesta.css, fiesta-<theme>.css: the banner, then tokens.css and
//     the theme joined by a newline, stripped of comments;
//   - tokens.css, <theme>.css, shell.css: the banner and the stripped
//     file;
//   - <script>.js: the banner and the stripped script;
//   - i18n/<lang>.json as committed, and i18n/<lang>.js, which adds
//     the table to self.fiestaStrings;
//   - icons.svg, a sprite of one <symbol id="rst-icon-<slug>"> per
//     icon, and icons/<slug>.svg, the inline icon with its xmlns;
//   - LICENSE, NOTICE (the icons' Lucide notice), and SHA256SUMS.
func Dist(src fs.FS, version string) (map[string][]byte, error) {
	out := map[string][]byte{}
	banner := []byte(Banner(version))
	read := func(path string) ([]byte, error) {
		b, err := fs.ReadFile(src, path)
		if err != nil {
			return nil, fmt.Errorf("the tree has no %s: %w", path, err)
		}
		return b, nil
	}
	list := func(dir, suffix string) ([]string, error) {
		entries, err := fs.ReadDir(src, dir)
		if err != nil {
			return nil, fmt.Errorf("the tree has no %s/: %w", dir, err)
		}
		var names []string
		for _, e := range entries {
			if !e.IsDir() && strings.HasSuffix(e.Name(), suffix) {
				names = append(names, strings.TrimSuffix(e.Name(), suffix))
			}
		}
		if len(names) == 0 {
			return nil, fmt.Errorf("the tree's %s/ holds no %s file", dir, suffix)
		}
		sort.Strings(names)
		return names, nil
	}

	license, err := read("LICENSE")
	if err != nil {
		return nil, err
	}
	out["LICENSE"] = license
	notice, err := read("icons/LICENSE-lucide.txt")
	if err != nil {
		return nil, err
	}
	out["NOTICE"] = notice

	tokens, err := read("css/tokens.css")
	if err != nil {
		return nil, err
	}
	out["tokens.css"] = append(append([]byte{}, banner...), stripCSSComments(tokens)...)
	shell, err := read("css/shell.css")
	if err != nil {
		return nil, err
	}
	out["shell.css"] = append(append([]byte{}, banner...), stripCSSComments(shell)...)
	themes, err := list("css/themes", ".css")
	if err != nil {
		return nil, err
	}
	for _, theme := range themes {
		css, err := read("css/themes/" + theme + ".css")
		if err != nil {
			return nil, err
		}
		out[theme+".css"] = append(append([]byte{}, banner...), stripCSSComments(css)...)
		joined := append(append(append([]byte{}, tokens...), '\n'), css...)
		out[bundleName(theme)] = append(append([]byte{}, banner...), stripCSSComments(joined)...)
	}

	scripts, err := list("js", ".js")
	if err != nil {
		return nil, err
	}
	for _, name := range scripts {
		js, err := read("js/" + name + ".js")
		if err != nil {
			return nil, err
		}
		out[name+".js"] = append(append([]byte{}, banner...), stripJSComments(js)...)
	}

	langs, err := list("i18n", ".json")
	if err != nil {
		return nil, err
	}
	for _, lang := range langs {
		table, err := read("i18n/" + lang + ".json")
		if err != nil {
			return nil, err
		}
		out["i18n/"+lang+".json"] = table
		out["i18n/"+lang+".js"] = []byte(`(self.fiestaStrings = self.fiestaStrings || {})["` + lang + `"] = ` + string(table) + ";\n")
	}

	slugs, err := list("icons", ".svg")
	if err != nil {
		return nil, err
	}
	var sprite bytes.Buffer
	sprite.WriteString(`<svg xmlns="` + svgNS + `">` + "\n")
	for _, slug := range slugs {
		svg, err := read("icons/" + slug + ".svg")
		if err != nil {
			return nil, err
		}
		children, err := iconChildren(svg)
		if err != nil {
			return nil, fmt.Errorf("icons/%s.svg: %w", slug, err)
		}
		sprite.WriteString(`<symbol id="rst-icon-` + slug + `" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">`)
		sprite.Write(children)
		sprite.WriteString("</symbol>\n")
		out["icons/"+slug+".svg"] = bytes.Replace(svg, []byte("<svg"), []byte(`<svg xmlns="`+svgNS+`"`), 1)
	}
	sprite.WriteString("</svg>\n")
	out["icons.svg"] = sprite.Bytes()

	names := make([]string, 0, len(out))
	for name := range out {
		names = append(names, name)
	}
	sort.Strings(names)
	var sums bytes.Buffer
	for _, name := range names {
		sum := sha256.Sum256(out[name])
		sums.WriteString(hex.EncodeToString(sum[:]) + "  " + name + "\n")
	}
	out["SHA256SUMS"] = sums.Bytes()
	return out, nil
}

// iconChildren is what sits between an inline icon's <svg> root tags:
// the paths the sprite's symbol wraps.
func iconChildren(svg []byte) ([]byte, error) {
	s := bytes.TrimSpace(svg)
	open := bytes.IndexByte(s, '>')
	if !bytes.HasPrefix(s, []byte("<svg")) || open < 0 || !bytes.HasSuffix(s, []byte("</svg>")) {
		return nil, fmt.Errorf("not an <svg> element")
	}
	return bytes.TrimSpace(s[open+1 : len(s)-len("</svg>")]), nil
}

// CheckSize is the size gate: every theme the dist carries has its
// one-file bundle, and each gzips to under OneLinkLimit, or the error
// names the first that does not and gives both figures, in bytes and
// in KiB. A bundle the dist does not hold fails it too, and so does a
// dist with no theme at all; a gate that passed on absence would be
// no gate.
func CheckSize(dist map[string][]byte) error {
	bundles := bundlesIn(dist)
	if len(bundles) == 0 {
		return fmt.Errorf("the dist carries no theme, so there is no one-file theme to hold to the limit")
	}
	for _, name := range bundles {
		b, ok := dist[name]
		if !ok {
			return fmt.Errorf("%s is not in the dist", name)
		}
		if g := Gzipped(b); g >= OneLinkLimit {
			return fmt.Errorf("%s is %d bytes gzipped (%.1f KiB); the one-link limit is %d (%.1f KiB)", name, g, float64(g)/1024, OneLinkLimit, float64(OneLinkLimit)/1024)
		}
	}
	return nil
}