package gallery

import (
	"errors"
	"fmt"
	"regexp"
	"strings"

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

// The frame document: one example document made a page the gallery
// can frame, with the gallery's own assets, the page's theme and
// locale, kept out of search, padded unless it is a whole page, the
// sign-in card on its stage, a layout's links live where the interface
// says and dead everywhere else, and the scheme store on <html> so a
// document opened in a tab of its own remembers the reader's choice.

var (
	headTag      = regexp.MustCompile(`<head\b[^>]*>`)
	firstLink    = regexp.MustCompile(`<(link|script)\b`)
	bodyTag      = regexp.MustCompile(`<body\b[^>]*>`)
	viewportMeta = regexp.MustCompile(`<meta name="viewport"[^>]*>`)
	assetLink    = regexp.MustCompile(`(href|src)="\.\./\.\./(css|js)/([^"]+)"`)
	picture      = regexp.MustCompile(`src="\.\./assets/([^"]+)"`)
	sampleRef    = regexp.MustCompile(`\b(href|action)="([^"]*)"`)
	anyTag       = regexp.MustCompile(`<[a-zA-Z][^>]*>`)
	anchorTag    = regexp.MustCompile(`<a\b[^>]*>`)
	tagEnd       = regexp.MustCompile(`\s*/?>$`)
	ltrHTML      = `<html lang="en" dir="ltr"`
	schemeLocal  = ` data-rst-scheme-store="local"`

	// The stage's scene, lifted from the layout-stage example as
	// schemeMenu lifts the header's menu from scheme-menu.
	stageSceneTag = regexp.MustCompile(`(?s)<div rst-stage-scene aria-hidden="true">.*?</div>`)
	// A body whose first element is the sign-in card.
	signinFirst = regexp.MustCompile(`^\s*<[a-zA-Z][^>]*\srst-signin[\s>=]`)

	// A layout's own regions, matched on the shipped shells' markup.
	shellBack  = regexp.MustCompile(`(?s)<div rst-shell-back>\s*<a\b[^>]*>`)
	shellNav   = regexp.MustCompile(`(?s)<nav rst-shell-nav>.*?</nav>`)
	shellBrand = regexp.MustCompile(`<a rst-shell-brand\b[^>]*>`)
	localeMenu = regexp.MustCompile(`(?s)<details rst-dropdown rst-locale\b.*?</details>`)
	firstNavID = regexp.MustCompile(`<nav rst-shell-nav>\s*<a\b[^>]*\sid="([^"]+)"`)
	langAttr   = regexp.MustCompile(`\slang="([^"]+)"`)
	currentOn  = regexp.MustCompile(`\saria-current="[^"]*"`)
)

// footWords are the words of a layout's foot link, the way back to the
// design system, as the examples write them.
const footWords = "Back to the design system"

// footLink matches a layout's foot link in locale: the layout document
// is in the page's language by the time its links are made live, so
// the link is matched by its words as the walker translated them.
func footLink(locale string) *regexp.Regexp {
	return regexp.MustCompile(`<a\b[^>]*>` + regexp.QuoteMeta(localMarkup(locale, "", footWords)) + `</a>`)
}

// frameStyle is the one style every frame document ends its head with.
// A component sample gets breathing room; a whole-page sample fills the
// frame, because insetting a page inside a page is not what any of them
// look like, and the shells' rail and the stage are 100dvh tall, so
// padding under one is also a scrollbar that can never be got rid of.
// The layout-stage example's body is itself the stage, so :is() names
// the body; a wrapped sign-in's stage is the body's child, so :has()
// names the children. A layout document is a whole page by the
// manifest's word, whatever its markup offers a selector: the column
// shell has no wrapper to name, and Rastrillo's standalone shells are
// rendered with no padding rule at all, so frame marks a layout's body
// data-gallery-document (Fiesta's own mark) and the third rule fills it.
const frameStyle = `<style>body { padding: 1rem; }
body:is([rst-stage], [rst-shell-topbar], [rst-shell-sidebar], [rst-shell-console]), body:has(> [rst-shell-topbar], > [rst-shell-sidebar], > [rst-shell-console], > [rst-backdrop], > [rst-stage]) { padding: 0; }
body[data-gallery-document] { padding: 0; }</style>`

// documentMark is what a layout document's <body> carries.
const documentMark = ` data-gallery-document`

// frame turns one example document into a frame document: the
// gallery's hashed assets in place of the relative links, the page's
// theme in place of the example's, frame.js first in the head, a robots
// meta after the viewport's, the frame style last in the head, the
// scheme store on <html>, the page's language and direction on <html>
// when it is not English, the sign-in card on its stage, a layout's
// body marked a whole page and its links live where the interface
// says, and every other href and action in the body pointed at "#".
// The example's title and everything else in it are kept. e is the
// example the document belongs to: whether it is a layout decides
// whether its body is a page and its links come alive.
func (s *site) frame(doc, theme, locale string, e example.Entry, state string) (string, error) {
	return s.framed(doc, theme, locale, e, func(inner string) (string, error) {
		return s.layoutLinks(inner, e, state, theme, locale)
	})
}

// framed is frame with the layout's links left to the caller: links
// rewrites a layout document's body before the deadening pass, and a
// nil links leaves the body as written, for a document that marks its
// own live links data-gallery-nav (the demo application's).
func (s *site) framed(doc, theme, locale string, e example.Entry, links func(string) (string, error)) (string, error) {
	head := headTag.FindStringIndex(doc)
	body := bodyTag.FindStringIndex(doc)
	if head == nil || body == nil || body[0] < head[1] {
		return "", errors.New("no <head> and <body> to rewrite")
	}
	// frame.js goes before the first stylesheet or script of the head,
	// after the charset and viewport metas, which stay first.
	at := firstLink.FindStringIndex(doc[head[1]:body[0]])
	if at == nil {
		return "", errors.New("no stylesheet in the head to put frame.js before")
	}
	at[0] += head[1]
	top := doc[:at[0]] + `<script src="` + s.asset("frame.js") + `"></script>` + "\n" + doc[at[0]:body[0]]
	top = assetLink.ReplaceAllStringFunc(top, func(m string) string {
		sub := assetLink.FindStringSubmatch(m)
		file := sub[2] + "/" + sub[3]
		if strings.HasPrefix(file, "css/themes/") {
			file = "css/themes/" + theme + ".css"
		}
		return sub[1] + `="` + s.asset(file) + `"`
	})
	top = s.pictures(top)
	if locale != "en" {
		if !strings.Contains(top, ltrHTML) {
			return "", fmt.Errorf("no %s to localise", ltrHTML)
		}
		top = strings.Replace(top, ltrHTML, `<html lang="`+locale+`" dir="`+Dir(locale)+`"`, 1)
	}
	// A frame is a fragment, not a page: thousands of them sit under
	// the gallery's directories, and a search engine listing them would
	// send a reader to a lone field with nothing around it.
	vp := viewportMeta.FindStringIndex(top)
	if vp == nil {
		return "", errors.New("no viewport meta in the head to put the robots meta after")
	}
	top = top[:vp[1]] + "\n" + `<meta name="robots" content="noindex">` + top[vp[1]:]
	// The scheme store, so fiesta.js in a document opened in a tab of
	// its own remembers the choice where the gallery's pages do. The
	// scheme-menu example's documents already say so.
	tag := htmlTag.FindStringIndex(top)
	if tag == nil {
		return "", errors.New("no <html> to put the scheme store on")
	}
	if !schemeStore.MatchString(top[tag[0]:tag[1]]) {
		top = top[:tag[1]-1] + schemeLocal + top[tag[1]-1:]
	}
	shut := strings.LastIndex(top, "</head>")
	if shut < 0 {
		return "", errors.New("no </head> to end with the frame style")
	}
	top = top[:shut] + frameStyle + "\n" + top[shut:]
	open := doc[body[0]:body[1]]
	if e.Document {
		open = open[:len(open)-1] + documentMark + ">"
	}

	rest := doc[body[1]:]
	end := strings.LastIndex(rest, "</body>")
	if end < 0 {
		return "", errors.New("no </body>")
	}
	inner, tail := rest[:end], rest[end:]
	if e.Document {
		if links != nil {
			var err error
			if inner, err = links(inner); err != nil {
				return "", err
			}
		}
	} else if signinFirst.MatchString(inner) {
		inner = "\n" + stage(s.scene, inner) + "\n"
	}
	inner = s.pictures(inner)
	// Every href and action that is not the gallery's own goes to "#":
	// a sample's link goes nowhere and a sample's form requests nothing.
	inner = anyTag.ReplaceAllStringFunc(inner, func(tag string) string {
		if strings.Contains(tag, " data-gallery-nav") {
			return tag
		}
		return sampleRef.ReplaceAllStringFunc(tag, func(m string) string {
			sub := sampleRef.FindStringSubmatch(m)
			if strings.HasPrefix(sub[2], "#") {
				return m
			}
			return sub[1] + `="#"`
		})
	})
	return top + open + inner + tail, nil
}

// pictures points every sample picture at its hashed copy under
// assets/images/.
func (s *site) pictures(html string) string {
	return picture.ReplaceAllStringFunc(html, func(m string) string {
		name := picture.FindStringSubmatch(m)[1]
		return `src="` + s.asset("images/"+name) + `"`
	})
}

// stageScene is the stage's scene, the <div rst-stage-scene> with its
// art, lifted from the layout-stage example's default state, so the
// staged sign-in screens show the stage the layout documents. newSite
// calls it once and keeps the scene on the site.
func (s *site) stageScene() (string, error) {
	const name = "layout-stage"
	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
	}
	scene := stageSceneTag.FindString(doc)
	if scene == "" {
		return "", fmt.Errorf("%s/%s carries no scene to lift", name, state)
	}
	return scene, nil
}

// stage puts a body whose first element is the sign-in card on the
// stage: the scene, then the card in the page column, as the stage
// shell lays a screen out. Ten of the twelve sign-in states; the two
// rst-box screens stay bare, as Rastrillo keeps them. The HTML tab
// still shows the bare card, which is what a reader copies.
func stage(scene, body string) string {
	return `<div rst-stage>` + scene + `<div rst-page>` + strings.TrimSpace(body) + `</div></div>`
}

// layoutLinks makes a layout document's own links live, so a shell demo
// opened full width works as the app it stands for: the back strip's
// way up goes to the shell's index document at its first nav id; the
// nav goes to the shell's page document where the manifest has one;
// the brand and the foot's "Back to the design system" go to the
// Overview; and the language menu's links go to the same layout
// document in each locale, the page's own marked current, lang and dir
// kept. Every link rewritten carries data-gallery-nav, which is what
// marks it the gallery's: the deadening pass leaves it alone and the
// URL gates resolve it. The rest of the body's links are a sample's
// and go to "#" afterwards.
//
// The shell of a layout is its name without layout- and -page: the
// index is layout-<shell>, the page layout-<shell>-page. The document
// in another locale is the same state's, the one being framed.
func (s *site) layoutLinks(doc string, e example.Entry, state, theme, locale string) (string, error) {
	shell := strings.TrimSuffix(strings.TrimPrefix(e.Name, "layout-"), "-page")
	index := "layout-" + shell
	indexState, ok := s.m.Default(index)
	if !ok {
		return "", fmt.Errorf("%s: the manifest has no %s, the shell's index document", e.Name, index)
	}
	own := func(l string) string { return s.href(theme, l, "frames/"+e.Name+"/"+state+".html") }
	overview := s.href(theme, locale, s.fileOf("overview"))
	var err error

	if shellBack.MatchString(doc) {
		indexDoc, derr := example.Document(s.src, index, indexState)
		if derr != nil {
			return "", derr
		}
		id := firstNavID.FindStringSubmatch(indexDoc)
		if id == nil {
			return "", fmt.Errorf("%s: %s has no nav id for the way up to land on", e.Name, index)
		}
		up := s.href(theme, locale, "frames/"+index+"/"+indexState+".html") + "#" + id[1]
		doc = shellBack.ReplaceAllStringFunc(doc, func(m string) string {
			return anchorTag.ReplaceAllStringFunc(m, func(a string) string { return liveLink(a, up) })
		})
	}
	if pageState, ok := s.m.Default(index + "-page"); ok {
		page := s.href(theme, locale, "frames/"+index+"-page/"+pageState+".html")
		doc = shellNav.ReplaceAllStringFunc(doc, func(m string) string {
			return anchorTag.ReplaceAllStringFunc(m, func(a string) string { return liveLink(a, page) })
		})
	}
	doc = shellBrand.ReplaceAllStringFunc(doc, func(a string) string { return liveLink(a, overview) })
	if doc, err = s.localeLinks(doc, locale, own); err != nil {
		return "", fmt.Errorf("%s: %w", e.Name, err)
	}
	doc = footLink(locale).ReplaceAllStringFunc(doc, func(m string) string {
		return anchorTag.ReplaceAllString(m, liveLink(anchorTag.FindString(m), overview))
	})
	return doc, nil
}

// localeLinks points every link of a document's language menu at href
// of the link's own locale, marked the gallery's, with the seeded
// current mark removed and the page's own locale marked instead; lang
// and dir are kept. A link with no lang, or a lang the gallery renders
// no locale for, is an error. The layouts' frame documents and the demo
// application both write their menus through it.
func (s *site) localeLinks(doc, locale string, href func(locale string) string) (string, error) {
	var err error
	doc = localeMenu.ReplaceAllStringFunc(doc, func(m string) string {
		return anchorTag.ReplaceAllStringFunc(m, func(a string) string {
			lang := langAttr.FindStringSubmatch(a)
			if lang == nil {
				err = errors.New("a language link carries no lang")
				return a
			}
			if !known(lang[1]) {
				err = fmt.Errorf("the language menu names %s, which the gallery has no locale for", lang[1])
				return a
			}
			a = currentOn.ReplaceAllString(a, "")
			a = liveLink(a, href(lang[1]))
			if lang[1] == locale {
				a = tagEnd.ReplaceAllString(a, ` aria-current="true">`)
			}
			return a
		})
	})
	return doc, err
}

// liveLink points one <a> tag at href and marks it the gallery's own.
func liveLink(tag, href string) string {
	tag = sampleRef.ReplaceAllStringFunc(tag, func(m string) string {
		if sampleRef.FindStringSubmatch(m)[1] != "href" {
			return m
		}
		return `href="` + href + `"`
	})
	return tagEnd.ReplaceAllString(tag, ` data-gallery-nav>`)
}

// known says whether the gallery renders the locale.
func known(locale string) bool {
	for _, l := range Locales {
		if l == locale {
			return true
		}
	}
	return false
}

// exampleDocument builds a document shaped like a seeded example, with
// the relative asset links the seeds carry, so frame treats it like
// any example: a title, the two stylesheets, the scripts by file name,
// one <style> where style is not empty, and the body.
func exampleDocument(title string, scripts []string, style, body string) string {
	var b strings.Builder
	b.WriteString("<!doctype html>\n<html lang=\"en\" dir=\"ltr\">\n<head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width\">\n")
	b.WriteString("<title>" + title + "</title>\n")
	b.WriteString("<link rel=\"stylesheet\" href=\"../../css/tokens.css\">\n<link rel=\"stylesheet\" href=\"../../css/themes/day.css\">\n")
	for _, sc := range scripts {
		b.WriteString(`<script defer src="../../js/` + sc + `"></script>` + "\n")
	}
	if style != "" {
		b.WriteString("<style>" + style + "</style>\n")
	}
	b.WriteString("</head>\n<body>\n" + body + "\n</body>\n</html>\n")
	return b.String()
}