// Package gallery renders Fiesta's own gallery: the design system in
// every theme and twelve languages, with an Overview, a Tokens page,
// an Icons page, a page per family and a page per example, every
// state of every example in a frame of its own with its markup beside
// it. It is a development and test artefact: the accessibility drives
// scan what it renders, fiesta gallery writes it out for looking at,
// and internal/www mounts it on the site.
//
// Render returns the whole tree in memory, keyed by path relative to
// the tree root, and it is deterministic: the same tree from the same
// source every time, so two renders can be compared.
//
//	index.html                                  day/en/index.html again
//	<theme>/<locale>/index.html                 the Overview
//	<theme>/<locale>/tokens.html                the theme's palette and
//	                                            the structure every
//	                                            theme shares
//	<theme>/<locale>/icons.html                 every icon
//	<theme>/<locale>/<family>.html              one page per family
//	<theme>/<locale>/<example>.html             one page per example
//	<theme>/<locale>/frames/<example>/<state>.html
//	                                            one document per state,
//	                                            the example's own with
//	                                            the gallery's assets
//	                                            and dead links
//	<theme>/<locale>/demo.html, demo-dashboard.html, demo-requests.html,
//	demo-request.html                           the demo application
//	<theme>/<locale>/demo-modal.html            the modal route
//	assets/<name>.<hash>.<ext>, assets/<name>.<ext>
//	                                            every asset hashed and
//	                                            plain: css/, js/, the
//	                                            examples' pictures under
//	                                            images/, and gallery.css,
//	                                            gallery.js and frame.js
//
// Two kinds of URL. The gallery owns every stylesheet, script, image
// and frame URL and every link marked data-gallery-nav: each is an
// absolute path under the mount, and the tests check every one names a
// file the render wrote. A sample's own links and forms are the
// example's: the HTML tab shows them as written, and the frame
// documents rewrite each href and action to "#", with frame.js
// cancelling every submit, so a click or a submit inside a frame
// requests nothing.
package gallery

import (
	"bytes"
	_ "embed"
	"errors"
	"fmt"
	"html/template"
	"io/fs"
	"path"
	"regexp"
	"sort"
	"strings"

	"amadan.net/rastrillo/fiesta"
	"amadan.net/rastrillo/fiesta/example"
	"amadan.net/rastrillo/fiesta/internal/tokens"
)

// Options is what a caller decides about the tree.
type Options struct {
	// Mount is the URL path the tree is served from; "" means "/".
	// Every URL in the output is an absolute path under it, so a tree
	// rendered for one mount cannot be served at another.
	Mount string
}

// The gallery's own furniture, embedded beside this file so each is
// edited as what it is. None is part of the design system: no page
// but the gallery's own links them. The stylesheet and the script are
// each two source files, the chrome's and the preview widget's, joined
// at render into the one gallery.css and gallery.js every page loads.
//
//go:embed gallery.css
var galleryCSS []byte

//go:embed view.css
var viewCSS []byte

//go:embed gallery.js
var galleryJS []byte

//go:embed view.js
var viewJS []byte

//go:embed frame.js
var frameJS []byte

// cleanMount normalises the mount to "" for the root or a rooted,
// cleaned path with no slash at the end, so URLs are mount + "/" + rel
// in either case.
func cleanMount(mount string) string {
	if mount == "" {
		return ""
	}
	if !strings.HasPrefix(mount, "/") {
		mount = "/" + mount
	}
	clean := path.Clean(mount)
	if clean == "/" {
		return ""
	}
	return clean
}

// site is one render in progress: the source, the manifest, the mount
// and the output.
type site struct {
	src   fs.FS
	m     *example.Manifest
	mount string
	out   map[string][]byte
	// scheme is the header's scheme menu: the scheme-menu example's
	// standalone state, whose <html> attributes every gallery page
	// takes as well, so fiesta.js stores the choice where that state
	// says to.
	scheme template.HTML
	// schemes is the scheme menu in each locale it has been asked for,
	// through localMarkup, as the bar of every page in that locale
	// carries it.
	schemes   map[string]template.HTML
	htmlAttrs template.HTMLAttr
	// schemeScripts are the scripts that state's head asks for, by
	// file name.
	schemeScripts []string
	// prose is the design system's explanations, from examples/prose.json.
	prose    *prose
	families []family
	icons    []icon
	// tokens is each theme's token groups, palette then structure.
	tokens map[string][]tokens.Group
	// hashed maps each asset's plain name under assets/ to the hashed
	// name it is linked by.
	hashed map[string]string
	// tmpl is the parsed templates, one tree per locale.
	tmpl map[string]*template.Template
	// weighed is the release build of the source, each file weighed:
	// what Getting started lists and its rail links, built once here
	// rather than on each of the thousands of pages whose rail asks.
	weighed release
	// scene is the stage's scene, lifted once from the layout-stage
	// example for every staged sign-in frame.
	scene string
}

// family is one family of examples: its heading and the sentence
// under it, the rules quoted at its head, and its examples.
type family struct {
	Key      string
	Title    string
	Blurb    string
	Rules    []idiomRule
	Examples []example.Entry
}

type icon struct {
	Slug   string
	Markup template.HTML
}

// Render builds the whole tree in memory: path relative to the tree
// root to file content. src is fiesta.FS() or any tree laid out the
// same way.
func Render(src fs.FS, opts Options) (map[string][]byte, error) {
	s, err := newSite(src, opts.Mount)
	if err != nil {
		return nil, err
	}
	for _, theme := range s.themes() {
		for _, locale := range Locales {
			if err := s.theme(theme, locale); err != nil {
				return nil, fmt.Errorf("gallery: %s/%s: %w", theme, locale, err)
			}
		}
	}
	// The tree root is the default theme's English Overview again,
	// copied rather than aliased so callers get one slice per path.
	root, ok := s.out[s.themes()[0]+"/en/index.html"]
	if !ok {
		return nil, errors.New("gallery: no index to serve as the tree root")
	}
	if err := s.put("index.html", append([]byte(nil), root...)); err != nil {
		return nil, err
	}
	return s.out, nil
}

// newSite reads everything a render needs before a page is written:
// the manifest, the prose, the catalogs, the assets, the scheme menu,
// the families, the icons, the tokens, the weighed release and the
// stage's scene.
func newSite(src fs.FS, mount string) (*site, error) {
	m, err := example.Load(src)
	if err != nil {
		return nil, fmt.Errorf("gallery: %w", err)
	}
	s := &site{src: src, m: m, mount: cleanMount(mount), out: map[string][]byte{}, hashed: map[string]string{}}
	if s.prose, err = loadProse(src); err != nil {
		return nil, fmt.Errorf("gallery: %w", err)
	}
	if _, err := catalogs(); err != nil {
		return nil, fmt.Errorf("gallery: %w", err)
	}
	if _, err := sampleCatalogs(); err != nil {
		return nil, fmt.Errorf("gallery: %w", err)
	}
	if _, err := moneyTable(); err != nil {
		return nil, fmt.Errorf("gallery: i18n/money.json: %w", err)
	}
	if _, err := controlStrings(); err != nil {
		return nil, fmt.Errorf("gallery: %w", err)
	}
	if err := s.assets(); err != nil {
		return nil, fmt.Errorf("gallery: %w", err)
	}
	if err := s.schemeMenu(); err != nil {
		return nil, fmt.Errorf("gallery: %w", err)
	}
	s.families = groupFamilies(m.Examples)
	if err := s.explain(); err != nil {
		return nil, fmt.Errorf("gallery: %w", err)
	}
	if err := s.readIcons(); err != nil {
		return nil, fmt.Errorf("gallery: %w", err)
	}
	if err := s.readTokens(); err != nil {
		return nil, fmt.Errorf("gallery: %w", err)
	}
	if s.weighed, err = s.weighRelease(); err != nil {
		return nil, fmt.Errorf("gallery: %w", err)
	}
	if s.scene, err = s.stageScene(); err != nil {
		return nil, fmt.Errorf("gallery: %w", err)
	}
	return s, nil
}

// themes are the theme names, the default first.
func (s *site) themes() []string { return fiesta.ThemeNames() }

// put adds one file to the tree and refuses a second writer: a name
// one page took from another would replace a document with no test
// noticing.
func (s *site) put(name string, body []byte) error {
	if _, dup := s.out[name]; dup {
		return fmt.Errorf("gallery: %s is produced twice", name)
	}
	s.out[name] = body
	return nil
}

// url is the absolute URL of one file of the tree.
func (s *site) url(rel string) string { return s.mount + "/" + rel }

// The gallery's own assets, declared where their bytes are: the
// stylesheet and the script each the join of its two halves, and the
// frame's script.
func init() {
	declareAsset("gallery.css", func(*site) ([]byte, error) { return joined(galleryCSS, viewCSS), nil })
	declareAsset("gallery.js", func(*site) ([]byte, error) { return joined(galleryJS, viewJS), nil })
	declareAsset("frame.js", func(*site) ([]byte, error) { return frameJS, nil })
}

// assets writes every declared asset, hashed and plain, under assets/:
// exactly the names assetNames lists, nothing else.
func (s *site) assets() error {
	names, err := s.assetNames()
	if err != nil {
		return err
	}
	for _, name := range names {
		b, err := s.assetBody(name)
		if err != nil {
			return fmt.Errorf("%s: %w", name, err)
		}
		if err := s.putAsset(name, b); err != nil {
			return err
		}
	}
	for _, theme := range s.themes() {
		if _, ok := s.hashed["css/themes/"+theme+".css"]; !ok {
			return fmt.Errorf("no css/themes/%s.css in the source", theme)
		}
	}
	return nil
}

// joined is two source files as one, a newline between them.
func joined(a, b []byte) []byte {
	out := make([]byte, 0, len(a)+1+len(b))
	out = append(out, a...)
	out = append(out, '\n')
	return append(out, b...)
}

var (
	htmlTag     = regexp.MustCompile(`<html\b[^>]*>`)
	schemeStore = regexp.MustCompile(`\sdata-rst-scheme-store="[^"]*"`)
	scriptSrc   = regexp.MustCompile(`<script[^>]*\ssrc="\.\./\.\./js/([^"]+)"`)
	ariaCurrent = regexp.MustCompile(`\saria-current="true"`)
	formTag     = regexp.MustCompile(`(?s)<form\b.*?</form>`)
)

// schemeMenu reads the header's scheme menu from the scheme-menu
// example's standalone state: the [rst-scheme] element of its markup,
// whatever row holds it, the scripts its head asks for, and the
// attribute on its <html> that tells fiesta.js to remember the choice,
// which every gallery page carries too.
//
// The state ships with one scheme marked current; the gallery starts
// on System, with no scheme stored, so the mark is moved to the System
// button. Nothing else in the markup changes.
func (s *site) schemeMenu() error {
	const name = "scheme-menu"
	state, ok := s.m.Default(name)
	if !ok {
		return fmt.Errorf("the manifest has no %s example", name)
	}
	doc, err := example.Document(s.src, name, state)
	if err != nil {
		return err
	}
	tag := htmlTag.FindString(doc)
	store := schemeStore.FindString(tag)
	if store == "" {
		return fmt.Errorf("%s/%s carries no data-rst-scheme-store on its <html>", name, state)
	}
	s.htmlAttrs = template.HTMLAttr(strings.TrimSpace(store))
	for _, m := range scriptSrc.FindAllStringSubmatch(doc, -1) {
		s.schemeScripts = append(s.schemeScripts, m[1])
	}
	body, err := example.Markup(s.src, name, state)
	if err != nil {
		return err
	}
	// The menu alone: a state that shows it in a row (the column's
	// footer) would otherwise put that row inside the gallery's bar.
	markup, err := example.Element(body, "rst-scheme")
	if err != nil {
		return fmt.Errorf("%s/%s: %w", name, state, err)
	}
	if !ariaCurrent.MatchString(markup) {
		return fmt.Errorf("%s/%s marks no scheme current", name, state)
	}
	markup = ariaCurrent.ReplaceAllString(markup, "")
	marked := false
	markup = formTag.ReplaceAllStringFunc(markup, func(form string) string {
		if marked || !strings.Contains(form, `value="system"`) {
			return form
		}
		marked = true
		return strings.Replace(form, `<button type="submit"`, `<button type="submit" aria-current="true"`, 1)
	})
	if !marked {
		return fmt.Errorf("%s/%s has no form for the system scheme", name, state)
	}
	s.scheme = template.HTML(markup)
	return nil
}

// schemeIn is the scheme menu in the page's language: the lifted
// markup through localMarkup as the scheme-menu example's sample, made
// once per locale.
func (s *site) schemeIn(locale string) template.HTML {
	if m, ok := s.schemes[locale]; ok {
		return m
	}
	if s.schemes == nil {
		s.schemes = map[string]template.HTML{}
	}
	m := template.HTML(localMarkup(locale, "scheme-menu", string(s.scheme)))
	s.schemes[locale] = m
	return m
}

// groupFamilies lists the families in familyOrder, each with its
// examples in manifest order. A family the order does not name comes
// last, in the order the manifest first names it, and explain refuses
// it by name: the gallery's reading order is its own, not the
// manifest's.
func groupFamilies(entries []example.Entry) []family {
	var out []family
	at := map[string]int{}
	for _, e := range entries {
		i, ok := at[e.Family]
		if !ok {
			i = len(out)
			at[e.Family] = i
			out = append(out, family{Key: e.Family})
		}
		out[i].Examples = append(out[i].Examples, e)
	}
	rank := func(key string) int {
		for i, k := range familyOrder {
			if k == key {
				return i
			}
		}
		return len(familyOrder)
	}
	sort.SliceStable(out, func(i, j int) bool { return rank(out[i].Key) < rank(out[j].Key) })
	return out
}

// explain gives each family its heading and blurb from the prose, and
// puts each idiom rule at the head of the family that holds the idiom
// it names, which is the primitives. A family the prose has no heading
// for is an error: the page would have no name.
func (s *site) explain() error {
	at := map[string]int{}
	for i := range s.families {
		f := &s.families[i]
		if !inFamilyOrder(f.Key) {
			return fmt.Errorf("the manifest has a %s family, which familyOrder does not place", f.Key)
		}
		fp, ok := s.prose.Families[f.Key]
		if !ok || fp.Title == "" {
			return fmt.Errorf("%s has no title for the %s family", proseFile, f.Key)
		}
		f.Title, f.Blurb = fp.Title, fp.Blurb
		at[f.Key] = i
	}
	for _, rule := range s.prose.Pages.Idioms {
		name, _, ok := s.m.Idiom(rule.Idiom)
		if !ok {
			return fmt.Errorf("%s quotes a rule for the %s idiom, which the manifest does not have", proseFile, rule.Idiom)
		}
		e, _ := s.m.Entry(name)
		f := &s.families[at[e.Family]]
		f.Rules = append(f.Rules, rule)
	}
	return nil
}

// readIcons lists every icon in the source, by slug.
func (s *site) readIcons() error {
	entries, err := fs.ReadDir(s.src, "icons")
	if err != nil {
		return err
	}
	for _, e := range entries {
		if e.IsDir() || !strings.HasSuffix(e.Name(), ".svg") {
			continue
		}
		b, err := fs.ReadFile(s.src, "icons/"+e.Name())
		if err != nil {
			return err
		}
		s.icons = append(s.icons, icon{Slug: strings.TrimSuffix(e.Name(), ".svg"), Markup: template.HTML(b)})
	}
	sort.Slice(s.icons, func(i, j int) bool { return s.icons[i].Slug < s.icons[j].Slug })
	if len(s.icons) == 0 {
		return errors.New("no icons in the source")
	}
	return nil
}

// page is what every gallery page's template is executed with: every
// field any page renders, so the template and the bodies read one
// value.
type page struct {
	s *site
	// Theme and Locale place the page in the tree; Lang and Dir are
	// what its <html> says.
	Theme, Locale, Lang, Dir string
	// File is the page's name within its directory; Kind the page kind
	// it is, or the family of the example it is; Name its own name for
	// its <title> and <h1>; TitleID the id the <h1> carries, if any.
	File, Kind, Name, TitleID string
	// Home is the Overview's address and Up a content page's way back
	// on a phone: the Overview with this page's row as the fragment.
	Home, Up string
	// Body is the page's own markup.
	Body template.HTML
	// Prev and Next are the pair at the foot of the page; either is nil
	// at the ends of the sequence.
	Prev, Next *link
	// Routes is the Overview's way into every other page.
	Routes []route
	// Nav is the rail.
	Nav []navSection
	// Rows and Demos are the phone index, the Overview's alone.
	Rows  []indexRow
	Demos navSection
	// Bar is the theme, scheme and language controls.
	Bar controls
}

// Title is the document's <title>.
func (p page) Title() string {
	return p.s.say(p.Locale, "gallery.title", "page", p.Name, "theme", p.Theme)
}

// HTMLAttrs are the attributes every gallery page's <html> carries
// beyond lang and dir.
func (p page) HTMLAttrs() template.HTMLAttr { return p.s.htmlAttrs }

// Icon is one of Fiesta's icons, inline, for the gallery's own
// furniture.
func (p page) Icon(slug string) template.HTML { return p.s.iconMarkup(slug) }

// Scripts are the scripts every gallery page loads, for the scheme
// menu.
func (p page) Scripts() []string { return p.s.schemeScripts }

// Href is the URL of file in this page's theme and locale.
func (p page) Href(file string) string { return p.s.href(p.Theme, p.Locale, file) }

// Mono says whether the page's heading is an identifier, drawn in the
// mono face: an example's page is, named by the example.
func (p page) Mono() bool {
	_, ok := p.s.m.Entry(strings.TrimSuffix(p.File, ".html"))
	return ok
}

// link is one entry of a switcher, or one step of the sequence.
type link struct {
	Href    string
	Label   string
	Current bool
}

// newPage is a page of one theme and locale with everything the
// template reads filled in but its body.
func (s *site) newPage(theme, locale, kind, file, name string) page {
	p := page{s: s, Theme: theme, Locale: locale, Lang: locale, Dir: Dir(locale), File: file, Kind: kind, Name: name}
	p.Home = s.href(theme, locale, "index.html")
	p.Prev, p.Next = s.steps(theme, locale, file)
	p.Routes = s.routes(theme, locale, kind)
	p.Nav = s.galleryNav(p)
	p.Bar = s.controls(p)
	return p
}

// theme renders one theme in one locale: a page per page kind, then a
// page and its frame documents per example, then the documents that
// are neither. It is the one loop that writes to the tree; everything
// else hands its output back through the maps it returns.
func (s *site) theme(theme, locale string) error {
	dir := theme + "/" + locale + "/"
	for _, pk := range s.pageKinds() {
		if reserved(pk.File) {
			return fmt.Errorf("the %s page kind takes %s, which is reserved for an extra document", pk.Kind, pk.File)
		}
		p := s.newPage(theme, locale, pk.Kind, pk.File, s.titleOf(locale, pk))
		p.TitleID = pk.Kind
		if pk.Kind != "overview" {
			p.Up = p.Home + "#nav-" + pk.Kind
		}
		s.phoneIndex(&p)
		body, err := pk.Body(p)
		if err != nil {
			return fmt.Errorf("%s: %w", pk.File, err)
		}
		p.Body = body
		if err := s.write(dir, p); err != nil {
			return err
		}
	}
	for _, e := range s.m.Examples {
		if reserved(e.Name + ".html") {
			return fmt.Errorf("the %s example takes %s.html, which is reserved for an extra document", e.Name, e.Name)
		}
		p := s.newPage(theme, locale, e.Family, e.Name+".html", e.Name)
		p.Up = p.Home + "#nav-" + e.Family
		body, frames, err := s.example(p, e)
		if err != nil {
			return err
		}
		want := s.frameFiles(e)
		if len(frames) != len(want) {
			return fmt.Errorf("%s: example wrote %d frame documents, frameFiles names %d", e.Name, len(frames), len(want))
		}
		for _, f := range want {
			doc, ok := frames[f]
			if !ok {
				return fmt.Errorf("%s: frameFiles names %s, which example did not write", e.Name, f)
			}
			if err := s.put(dir+f, doc); err != nil {
				return err
			}
		}
		p.Body = template.HTML(body)
		if err := s.write(dir, p); err != nil {
			return err
		}
	}
	extra, err := s.extraDocuments(theme, locale)
	if err != nil {
		return err
	}
	names := s.extraDocumentNames()
	if len(extra) != len(names) {
		return fmt.Errorf("extraDocuments wrote %d documents, extraDocumentNames lists %d", len(extra), len(names))
	}
	for _, n := range names {
		doc, ok := extra[n]
		if !ok {
			return fmt.Errorf("extraDocumentNames lists %s, which extraDocuments did not write", n)
		}
		if err := s.put(dir+n, doc); err != nil {
			return err
		}
	}
	return nil
}

// reservedDocuments are the file names, under a theme and locale
// directory, that the documents extraDocuments will write are to take:
// the demo application's four and the modal route's. They are reserved
// here so no page kind or example page can take one first: the modal
// example's own page is modal.html, so the standalone modal route is
// demo-modal.html beside the demo's documents. theme checks every page
// it writes against this list.
var reservedDocuments = []string{"demo.html", "demo-dashboard.html", "demo-requests.html", "demo-request.html", "demo-modal.html"}

// reserved says whether file is one of reservedDocuments.
func reserved(file string) bool {
	for _, r := range reservedDocuments {
		if r == file {
			return true
		}
	}
	return false
}

// extraDocuments is every document of one theme and locale that is
// neither a page kind's, an example's nor a frame's, keyed by path
// under the directory: the demo application's four documents and the
// modal route, under their names from reservedDocuments.
func (s *site) extraDocuments(theme, locale string) (map[string][]byte, error) {
	out, err := s.demo(theme, locale)
	if err != nil {
		return nil, fmt.Errorf("the demo application: %w", err)
	}
	if out["demo-modal.html"], err = s.modal(theme, locale); err != nil {
		return nil, fmt.Errorf("the modal route: %w", err)
	}
	return out, nil
}

// extraDocumentNames lists the paths extraDocuments writes, so the
// tree gate expects them; each is one of reservedDocuments.
func (s *site) extraDocumentNames() []string {
	var out []string
	for _, view := range demoViews {
		out = append(out, demoFile(view))
	}
	return append(out, "demo-modal.html")
}

// write executes the page template around p and puts the result at
// p.File within dir.
func (s *site) write(dir string, p page) error {
	t, err := s.templates(p.Locale)
	if err != nil {
		return err
	}
	var b bytes.Buffer
	if err := t.ExecuteTemplate(&b, "ds-page", p); err != nil {
		return err
	}
	return s.put(dir+p.File, b.Bytes())
}