package gallery

import (
	"encoding/json"
	"errors"
	"fmt"
	"html"
	"html/template"
	"io/fs"
	"regexp"
	"strings"
	"sync"
	"unicode"

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

// ── Sample content in the page's language ────────────────────────────
//
// The samples speak the language of the page they are on. A Japanese
// page with English buttons was showing how English fits a component,
// which is the one language a reader can already picture: German runs
// long, Arabic runs right to left, and the only way to see either inside
// a component is to put it there. The stand-ins stay as written: a
// person is called Grace Hopper in every language, an address is an
// address and a route is a route.
//
// This is Rastrillo's markup walker, under Rastrillo's names. Fiesta's
// samples are all markup (the examples' own documents), so Rastrillo's
// second walker, for a partial's data, has no counterpart here. Every
// sample string is looked up by its English in
// i18n/samples.<locale>.json, which hack/seed/run-translations.sh
// writes as Rastrillo's sampleProse is written, and every lookup is
// traced as samples.<English>, so the parity gate and the leak gate
// read what the frames asked for.
//
// Three things are Fiesta's own. localAttrs also writes the enhanced
// controls' data-rst-<key> attributes from the framework's own frozen
// i18n/<locale>.json, so the select and date fields speak the page's
// language without a script table. An element that carries lang is in
// that language already (the language menu's endonyms) and stays as
// written. And a word's sense, which Rastrillo's typed data carries and
// plain HTML cannot, is named per example in sampleSenses.
//
// What stays as written is decided by rule rather than listed, so a new
// sample is translated by default and the parity gate asks for its
// eleven translations; see keepsAsWritten. The list that exists,
// sampleStandIns, is the names and brands no rule can recognise.

// sampleStandIns are the names, brands and fixed values that stay as
// written inside a string that is otherwise translated. "Actions for
// Grace Hopper" is translated around the name; "Grace Hopper" alone is
// not looked up at all. TestSampleTranslationsKeepTheirStandIns holds
// every translation of a key that carries one to carrying it too.
// Rastrillo's list, then the names Fiesta's seeded examples carry that
// Rastrillo's do not.
var sampleStandIns = []string{
	// People.
	"Grace Hopper", "Ada Lovelace", "Alan Turing", "Fiona Reid", "Otto Neurath",
	"Hedy Lamarr", "Mary Sherman",
	// Brands and products: the gallery's own sample apps, the framework,
	// and the companies whose buttons the sign-in screen draws.
	"Harbour", "rastrillo", "Google", "Apple", "WCAG",
	// Fixed values a translation would only damage: a shortened count,
	// and a postal address that is somewhere.
	"4.1k", "42 Wharf Road, Dublin 2",
	// Fiesta's own: the framework's name, the sample app the shells
	// frame, the sign-in service the screens name, and the two agents
	// the actor and token samples name. Then the fixed values: the
	// currency code the money field shows and posts beside its amount
	// (Rastrillo keeps it as a data key, Currency), a request's
	// reference, and the reference an error page quotes.
	"Fiesta", "Party planner", "Keymail", "Claude", "Codex",
	"EUR", "REQ-4471", "k3f9tq",
}

var (
	// sampleIdent is a machine's word: a field name, an option's value, a
	// slug. A lowercase letter first, then no spaces.
	sampleIdent = regexp.MustCompile(`^\p{Ll}[\p{L}\p{N}_.\-]*$`)
	// sampleCode is a reference with a digit in it (AB3PX, D02, #4471),
	// or a one- or two-letter initial.
	sampleCode = regexp.MustCompile(`#?\b(?:[A-Z]*[0-9][A-Z0-9]*|[A-Z]{1,2})\b`)
	sampleMail = regexp.MustCompile(`\S+@\S*`)
)

// keepsAsWritten says whether a sample string stays as it is in every
// language: a URL, an address, a machine's identifier, a number with no
// words around it, or nothing but stand-ins.
func keepsAsWritten(s string) bool {
	s = strings.TrimSpace(html.UnescapeString(s))
	if s == "" || strings.HasPrefix(s, "/") || strings.HasPrefix(s, "?") ||
		strings.HasPrefix(s, "#") && !strings.Contains(s, " ") || strings.Contains(s, "://") {
		return true
	}
	if sampleIdent.MatchString(s) {
		return true
	}
	return !hasWords(s)
}

// hasWords says whether anything a reader would call a word is left in s
// once the stand-ins, the email addresses and the codes are taken out.
func hasWords(s string) bool {
	for _, k := range sampleStandIns {
		s = strings.ReplaceAll(s, k, "")
	}
	s = sampleMail.ReplaceAllString(s, "")
	s = sampleCode.ReplaceAllString(s, "")
	return strings.IndexFunc(s, unicode.IsLetter) >= 0
}

// verbSense is Rastrillo's suffix for a sample word that is an action
// where the same English is a noun elsewhere in the samples: Archive in
// a row's menu against the Archive a topbar links to. English spells
// the two alike and most of the eleven do not (Archivar and Archivo),
// so the action is looked up under its own key, the word plus
// verbSense. English still reads the bare word.
const verbSense = " (verb)"

// nounSense is the other way round: a sample word that names a thing
// where the catalog's bare word is the action. The seg-tabs group
// "View" names the view a reader picks; the bare View is a row menu's
// link, a verb in most of the eleven (Russian Открыть, open), which
// would label the group as a command.
const nounSense = " (noun)"

// withoutSense is a sample key's English: the key with its sense, if
// it has one, taken off.
func withoutSense(key string) string {
	return strings.TrimSuffix(strings.TrimSuffix(key, verbSense), nounSense)
}

// sampleSenses names, per example, the sample text whose key is not its
// English. Rastrillo marks the sense in its typed sample data
// (verb("Archive")); an example here is plain HTML, which cannot, so
// the example is named instead. localMarkup and EnglishStrings both
// apply it, so the walker and the exporter cannot disagree. Rastrillo's
// sampleProse has two verb keys, and Fiesta's examples use both words
// in that sense: the row menu's Archive button and the bulk bar's
// Export action.
var sampleSenses = map[string]map[string]string{
	"row-menu": {"Archive": "Archive" + verbSense},
	"bulk-bar": {"Export": "Export" + verbSense},
	"seg-tabs": {"View": "View" + nounSense},
}

// sampleID is the id a sample string is traced under: its key, which is
// its English or, for a word in a sense, its English and the sense.
func sampleID(key string) string { return "samples." + key }

// sampleCatalogs is every non-English locale's sample translations,
// read once from i18n/samples.<locale>.json: an English key to its
// translation, as Rastrillo's sampleProse rows are.
var sampleCatalogs = sync.OnceValues(func() (map[string]catalog, error) {
	out := map[string]catalog{}
	for _, locale := range Locales {
		if locale == "en" {
			continue
		}
		name := "i18n/samples." + locale + ".json"
		b, err := fs.ReadFile(catalogFiles, name)
		if err != nil {
			return nil, fmt.Errorf("the %s sample catalog: %w", locale, err)
		}
		var c catalog
		if err := json.Unmarshal(b, &c); err != nil {
			return nil, fmt.Errorf("%s: %w", name, err)
		}
		out[locale] = c
	}
	return out, nil
})

// samplesIn is one locale's sample translations; nil for English.
func samplesIn(locale string) catalog {
	cs, err := sampleCatalogs()
	if err != nil {
		return nil
	}
	return cs[locale]
}

// sampleText is one sample string in locale, by its key: the catalog's
// translation, or the English (the key without its sense) for English
// and for a key the catalog does not answer, which the parity gate
// fails. Every lookup is traced.
func sampleText(locale, key string) string {
	trace(sampleID(key))
	en := withoutSense(key)
	if locale == "en" {
		return en
	}
	if t := samplesIn(locale)[key]; t != "" {
		return t
	}
	return en
}

// controlStrings is the framework's own catalog for each locale, as the
// enhanced controls read it from a data-rst-<key> attribute: every
// string as it is, and the date-words vocabulary as its JSON, compact
// with its keys sorted, as the seeded documents write it.
var controlStrings = sync.OnceValues(func() (map[string]map[string]string, error) {
	out := map[string]map[string]string{}
	for _, locale := range Locales {
		b, ok := fiesta.Strings(locale)
		if !ok {
			return nil, fmt.Errorf("the framework has no i18n/%s.json", locale)
		}
		var raw map[string]json.RawMessage
		if err := json.Unmarshal(b, &raw); err != nil {
			return nil, fmt.Errorf("i18n/%s.json: %w", locale, err)
		}
		table := map[string]string{}
		for k, v := range raw {
			var s string
			if json.Unmarshal(v, &s) == nil {
				table[k] = s
				continue
			}
			var words map[string]string
			if err := json.Unmarshal(v, &words); err != nil {
				return nil, fmt.Errorf("i18n/%s.json: %s is neither a string nor a table of words", locale, k)
			}
			j, err := json.Marshal(words)
			if err != nil {
				return nil, err
			}
			table[k] = string(j)
		}
		out[locale] = table
	}
	return out, nil
})

// ── Markup ───────────────────────────────────────────────────────────

// spokenAttrs are the attributes a person reads or hears. Every other
// attribute is the machine's, including value on anything but a text
// input: an <option>'s value is what the form posts. Rastrillo's five,
// and alt, which the media grid's pictures carry and Rastrillo's
// samples do not.
var spokenAttrs = map[string]bool{
	"aria-label": true, "data-tip": true, "placeholder": true, "title": true, "label": true,
	"alt": true,
}

// keptElements hold content that is never translated: code, a drawing,
// a name (the convention throughout is that a person's name, an email
// address or a record's own words go in <bdi>), and the slots of a
// shell that carry the app's brand and its user.
var keptElements = map[string]bool{"svg": true, "code": true, "bdi": true, "style": true, "script": true}

// keptAttrs mark an element whose content stays as written: Rastrillo's
// shell slots, and lang, which says the content is in a language of its
// own already (the language menu names each language in itself).
var keptAttrs = []string{"rst-shell-brand", "rst-person-name", "rst-person-email", "rst-person-av", "lang"}

// phraseElements are the elements that sit inside a sentence. An
// element whose content is words and these, and nothing else, is
// translated as one sentence, markup included, so "Displaying
// <strong>1–20</strong> of <strong>412</strong>" can become a sentence
// with the two numbers the other way round. Translated word by word it
// could not: "of" has no translation that works in every order.
var phraseElements = map[string]bool{
	"a": true, "abbr": true, "b": true, "bdi": true, "code": true, "data": true,
	"em": true, "i": true, "output": true, "small": true, "strong": true, "time": true,
}

var voidElements = map[string]bool{
	"area": true, "br": true, "col": true, "embed": true, "hr": true, "img": true,
	"input": true, "link": true, "meta": true, "source": true, "track": true, "wbr": true,
}

// mtoken is one piece of a sample's markup: text, or a tag.
type mtoken struct {
	raw   string
	tag   string // the element's name; empty for text
	close bool   // </tag>
	void  bool   // a void element, a self-closing SVG child, or a comment
}

// tokenise splits markup into text and tags. It is not a general HTML
// parser and does not need to be: the samples are this repository's
// own, with every attribute quoted. A comment (the layouts' slot marks)
// is a tag that opens nothing.
func tokenise(src string) []mtoken {
	var out []mtoken
	for len(src) > 0 {
		i := strings.IndexByte(src, '<')
		if i != 0 {
			if i < 0 {
				i = len(src)
			}
			out = append(out, mtoken{raw: src[:i]})
			src = src[i:]
			continue
		}
		j := markupTagEnd(src)
		raw := src[:j]
		src = src[j:]
		t := mtoken{raw: raw}
		name := strings.TrimPrefix(raw[1:], "/")
		t.close = strings.HasPrefix(raw, "</")
		if k := strings.IndexAny(name, " \t\n/>"); k >= 0 {
			name = name[:k]
		}
		t.tag = strings.ToLower(name)
		t.void = voidElements[t.tag] || strings.HasSuffix(raw, "/>") || strings.HasPrefix(raw, "<!")
		out = append(out, t)
	}
	return out
}

// markupTagEnd is the length of the tag at the start of src, quoted
// attribute values included: a > inside one does not end the tag.
// Rastrillo's tagEnd, renamed: frame.go has a tagEnd of its own.
func markupTagEnd(src string) int {
	var quote byte
	for i := 1; i < len(src); i++ {
		switch c := src[i]; {
		case quote != 0:
			if c == quote {
				quote = 0
			}
		case c == '"' || c == '\'':
			quote = c
		case c == '>':
			return i + 1
		}
	}
	return len(src)
}

// closing is the index of the token that closes the element opened at
// toks[i], or len(toks) when nothing does.
func closing(toks []mtoken, i int) int {
	depth := 0
	for j := i + 1; j < len(toks); j++ {
		t := toks[j]
		if t.tag != toks[i].tag || t.void {
			continue
		}
		if !t.close {
			depth++
			continue
		}
		if depth == 0 {
			return j
		}
		depth--
	}
	return len(toks)
}

// localiser is one walk over a sample's markup: the locale the data-rst
// attributes are written in, the example's senses, and look, which
// turns a key into the text that replaces it. The renderer looks each
// key up in the locale; EnglishStrings collects them. Both walk with
// the same code, so they cannot ask for different strings.
type localiser struct {
	locale string
	senses map[string]string
	look   func(key string) string
}

// key is the key a run of sample text is looked up by: its sense where
// the example names one, its English otherwise.
func (l localiser) key(s string) string {
	if k, ok := l.senses[s]; ok {
		return k
	}
	return s
}

// localMarkup is one hand-written sample of the named example in one
// locale. In English it returns src byte for byte; anywhere else the
// only bytes that change are the text, the spoken attribute values and
// the enhanced controls' attributes it translates.
func localMarkup(locale, name, src string) string {
	return walkMarkup(localiser{locale: locale, senses: sampleSenses[name], look: func(key string) string {
		return sampleText(locale, key)
	}}, src)
}

// sampleKeys is every key localMarkup looks up in one sample, in order.
func sampleKeys(name, src string) []string {
	var out []string
	walkMarkup(localiser{locale: "en", senses: sampleSenses[name], look: func(key string) string {
		out = append(out, key)
		return withoutSense(key)
	}}, src)
	return out
}

// walkMarkup is Rastrillo's localMarkup over a localiser.
func walkMarkup(l localiser, src string) string {
	toks := tokenise(src)
	var b strings.Builder
	for i := 0; i < len(toks); i++ {
		t := toks[i]
		switch {
		case t.tag == "":
			b.WriteString(localText(l, t.raw))
		case t.close || t.void:
			b.WriteString(localAttrs(l, t))
		default:
			end := closing(toks, i)
			b.WriteString(localAttrs(l, t))
			if keptElement(t) {
				for _, k := range toks[i+1 : min(end+1, len(toks))] {
					b.WriteString(k.raw)
				}
				i = end
				continue
			}
			if isPhrase(toks[i+1 : end]) {
				var inner strings.Builder
				for _, k := range toks[i+1 : end] {
					inner.WriteString(k.raw)
				}
				b.WriteString(localText(l, inner.String()))
				if end < len(toks) {
					b.WriteString(toks[end].raw)
				}
				i = end
			}
		}
	}
	return b.String()
}

// keptElement says whether an element's content stays as written.
func keptElement(t mtoken) bool {
	if keptElements[t.tag] {
		return true
	}
	for _, a := range keptAttrs {
		if strings.Contains(t.raw, " "+a+" ") || strings.Contains(t.raw, " "+a+">") || strings.Contains(t.raw, " "+a+"=") {
			return true
		}
	}
	return false
}

// isPhrase says whether an element's content is one sentence: words of
// its own beside at least one element, and every element inside it one
// that sits in running text.
func isPhrase(inner []mtoken) bool {
	words, elements := false, false
	depth := 0
	for _, t := range inner {
		switch {
		case t.tag == "":
			if depth == 0 && hasWords(html.UnescapeString(t.raw)) {
				words = true
			}
		case !phraseElements[t.tag]:
			return false
		case t.close:
			depth--
		default:
			if depth == 0 {
				elements = true
			}
			if !t.void {
				depth++
			}
		}
	}
	return words && elements
}

// localText translates one run, keeping the whitespace around it where
// it was: the samples are indented, and the indent is not the sentence.
func localText(l localiser, raw string) string {
	core := strings.TrimSpace(raw)
	if core == "" || keepsAsWritten(stripTags(core)) {
		return raw
	}
	lead := raw[:strings.Index(raw, core)]
	return lead + l.look(l.key(core)) + raw[len(lead)+len(core):]
}

// stripTags is a phrase's text with its markup taken out, for deciding
// whether there is anything in it to translate.
func stripTags(s string) string {
	var b strings.Builder
	for _, t := range tokenise(s) {
		if t.tag == "" {
			b.WriteString(t.raw)
		}
	}
	return b.String()
}

// spokenAttr matches one double-quoted attribute and its value.
var spokenAttr = regexp.MustCompile(`([a-z-]+)="([^"]*)"`)

// controlAttr matches one of the enhanced controls' attributes and its
// value: data-rst- and the key the framework's catalog files it under.
var controlAttr = regexp.MustCompile(`(\sdata-rst-)([a-z0-9-]+)="([^"]*)"`)

// localAttrs translates the spoken attributes of one tag. A text input's
// value is spoken too: it is what the field shows. Every data-rst-<key>
// whose key the framework's catalog has takes that catalog's value in
// the walk's locale, which is what the enhanced controls would have
// read from a script table.
func localAttrs(l localiser, t mtoken) string {
	if t.close || !strings.Contains(t.raw, `="`) {
		return t.raw
	}
	textInput := t.tag == "input" && (strings.Contains(t.raw, ` type="text"`) || !strings.Contains(t.raw, ` type="`))
	raw := spokenAttr.ReplaceAllStringFunc(t.raw, func(m string) string {
		sub := spokenAttr.FindStringSubmatch(m)
		if !(spokenAttrs[sub[1]] || textInput && sub[1] == "value") || keepsAsWritten(sub[2]) {
			return m
		}
		return sub[1] + `="` + l.look(l.key(sub[2])) + `"`
	})
	if !strings.Contains(raw, " data-rst-") {
		return raw
	}
	tables, err := controlStrings()
	if err != nil {
		return raw
	}
	table := tables[l.locale]
	return controlAttr.ReplaceAllStringFunc(raw, func(m string) string {
		sub := controlAttr.FindStringSubmatch(m)
		v, ok := table[sub[2]]
		if !ok {
			return m
		}
		return sub[1] + sub[2] + `="` + template.HTMLEscapeString(v) + `"`
	})
}

// ── Documents ────────────────────────────────────────────────────────

var titleText = regexp.MustCompile(`<title>[^<]*</title>`)

// localBody is a document with its body's markup through localMarkup;
// the head is left as it is. English is the document unchanged.
func localBody(locale, name, doc string) (string, error) {
	if locale == "en" {
		return doc, nil
	}
	body := bodyTag.FindStringIndex(doc)
	end := strings.LastIndex(doc, "</body>")
	if body == nil || end < body[1] {
		return "", fmt.Errorf("no <body> to localise")
	}
	return doc[:body[1]] + localMarkup(locale, name, doc[body[1]:end]) + doc[end:], nil
}

// localDocument is one state's document in locale: its body localised
// and its title the frame's (localTitle). English is the document as
// written.
func (s *site) localDocument(locale string, e example.Entry, st example.State, doc string) (string, error) {
	doc, err := localBody(locale, e.Name, doc)
	if err != nil {
		return "", err
	}
	return s.localTitle(locale, e, st, doc)
}

// localTitle is a state's document with its <title> the frame's title
// in the page's language, the example's name and the state's label, in
// place of the English the example wrote there. English is the
// document as written.
func (s *site) localTitle(locale string, e example.Entry, st example.State, doc string) (string, error) {
	if locale == "en" {
		return doc, nil
	}
	if n := len(titleText.FindAllStringIndex(doc, -1)); n != 1 {
		return "", fmt.Errorf("the document has %d <title> elements, want one", n)
	}
	title := "<title>" + template.HTMLEscapeString(s.frameTitle(locale, e, st)) + "</title>"
	return titleText.ReplaceAllLiteralString(doc, title), nil
}

// localHTML is a document's <html> in the page's language and its
// direction. A document that does not open as English left to right
// is an error, so a seed written otherwise is not silently left as
// English.
func localHTML(doc, locale string) (string, error) {
	if locale == "en" {
		return doc, nil
	}
	if !strings.Contains(doc, ltrHTML) {
		return "", fmt.Errorf("no %s to localise", ltrHTML)
	}
	return strings.Replace(doc, ltrHTML, `<html lang="`+locale+`" dir="`+Dir(locale)+`"`, 1), nil
}

// localSample is one state's frame document and the code its HTML tab
// shows, in locale. The example's document is put in the page's
// language (localDocument) and then framed, so the walker reads the
// sample's own links and the frame's rewrites come after it; the code
// is the component's body as the frame shows it, or for a layout the
// whole document in the page's language. The money sample in its
// default state is the money table's markup for the locale, frame and
// code alike, bypassing the walker as Rastrillo's formatMarkup does:
// its amounts are already written for the locale, and its currency
// codes read as words.
func (s *site) localSample(theme, locale string, e example.Entry, st example.State) (frame, code string, err error) {
	doc, err := example.Document(s.src, e.Name, st.ID)
	if err != nil {
		return "", "", err
	}
	// A layout's code is its whole document, so its body is not read
	// again on its own.
	var en string
	if !e.Document {
		if en, err = example.Markup(s.src, e.Name, st.ID); err != nil {
			return "", "", err
		}
	}
	if e.Name == moneyExample && st.ID == e.Default && !e.Document {
		money, ok := s.moneyBody(locale)
		if !ok {
			return "", "", fmt.Errorf("i18n/money.json has no %s sample", locale)
		}
		if strings.Count(doc, en) != 1 {
			return "", "", errors.New("the body is not where the money table can replace it")
		}
		if doc, err = s.localTitle(locale, e, st, strings.Replace(doc, en, money, 1)); err != nil {
			return "", "", err
		}
		code = money
	} else {
		if doc, err = s.localDocument(locale, e, st, doc); err != nil {
			return "", "", err
		}
		if !e.Document {
			code = localMarkup(locale, e.Name, en)
		}
	}
	if frame, err = s.frame(doc, theme, locale, e, st.ID); err != nil {
		return "", "", err
	}
	if e.Document {
		code, err = localHTML(doc, locale)
	}
	return frame, code, err
}

// sampleSources is every sample the renderer puts through localMarkup,
// by the example (or document) whose senses apply: each example state's
// body, the money sample's default excepted; the demo application's
// content, with the gallery's own sentences it carries held out; and
// the demo's two rail labels. EnglishStrings collects the sample keys
// from these, with the walker the renderer uses.
func sampleSources(src fs.FS, m *example.Manifest) ([][2]string, error) {
	var out [][2]string
	for _, e := range m.Examples {
		for _, st := range e.States {
			if e.Name == moneyExample && st.ID == e.Default {
				continue
			}
			markup, err := example.Markup(src, e.Name, st.ID)
			if err != nil {
				return nil, err
			}
			out = append(out, [2]string{e.Name, markup})
		}
	}
	for _, view := range demoViews[1:] {
		content, err := demoContent(view, demoData{Back: demoBackHeld, Callout: demoCalloutHeld})
		if err != nil {
			return nil, err
		}
		out = append(out, [2]string{"demo", content})
	}
	for _, label := range demoRail {
		out = append(out, [2]string{"demo", label.label})
	}
	return out, nil
}