// Package menu is the suite's one floating panel ([estilo-menu]), its
// rows ([estilo-menu-item]) and the document menu bar
// ([estilo-menubar]). Docs is its first consumer.
//
// Scripts off, a menu is a <details>: it opens, and its links and form
// buttons work; it closes only when its summary is clicked again. Script
// may add Escape, outside-click close and menubar hover-switching; none
// of it is required.
//
// It carries no strings. Callers supply every label in their locale.
package menu

import (
	"embed"
	"net/http"
	"strings"
)

//go:embed menu.css
var css []byte

//go:embed templates/*.html
var templateFS embed.FS

// CSS returns menu.css. Link it after base.css and before chrome.css.
func CSS() []byte { return append([]byte(nil), css...) }

// Templates holds estilo-menu-item and estilo-icon-check. Parse it into
// the app's page templates with ParseFS(Templates(), "templates/*.html").
func Templates() embed.FS { return templateFS }

// Item is one row rendered by estilo-menu-item. Set exactly one of Href,
// Action and Dialog; each is a different element, and each works with
// scripts off:
//
//   - Href: a link, <a href>, for a row that navigates.
//   - Action: a one-button <form method="post"> to that path, for a row
//     that changes something ("New sheet").
//   - Dialog: a <button> that opens the <dialog> with that id through the
//     platform's invoker command (command="show-modal"), for a row that
//     asks for more before anything happens ("Keyboard shortcuts…").
//     chrome.js opens it where the engine has no invoker commands.
//
// Action and Dialog came with Sheets, the second adopter: Docs' rows were
// all links, and Sheets' Help moved into the account menu as a dialog.
type Item struct {
	Href, Label string
	// Key is an already-formatted shortcut, from Shortcut. Optional.
	Key string
	// Action is the POST target of a form row.
	Action string
	// Dialog is the id of the <dialog> a button row opens.
	Dialog string
	// Danger draws a destructive row in the negative tone
	// (estilo-menu-item="danger"). Calls, the fifth adopter, was the
	// first with one in a menu: "End meeting for everyone". The row still
	// goes to its own confirm page; the tone only says it is the one to
	// read twice.
	Danger bool
}

// Apple reports whether the request comes from an Apple platform, the
// server-side choice behind Shortcut: Sec-CH-UA-Platform "macOS" or
// "iOS", or a User-Agent naming a Macintosh, iPhone or iPad. A response
// whose markup depends on it must be private or no-store, or say
// Vary: User-Agent.
func Apple(r *http.Request) bool {
	switch strings.Trim(r.Header.Get("Sec-CH-UA-Platform"), `"`) {
	case "macOS", "iOS":
		return true
	}
	ua := r.UserAgent()
	return strings.Contains(ua, "Macintosh") || strings.Contains(ua, "iPhone") || strings.Contains(ua, "iPad")
}

// Shortcut formats a key chord for the request's platform, so a label
// is right in the first paint and nothing flips once script runs.
//
// keys is written in one platform-neutral spelling, parts joined by
// "+": Mod (Command on Apple, Ctrl elsewhere), Shift, Alt, Ctrl (the
// literal Control key), then one key. Enter, Delete, Backspace, Tab and
// Esc are named; anything else is printed as given. Apple chords print
// their modifiers in the order ⌃⌥⇧⌘ with no separator (⇧⌘K); other
// platforms join words with "+" in the order Ctrl, Alt, Shift
// (Ctrl+Shift+K).
func Shortcut(r *http.Request, keys string) string {
	return format(Apple(r), keys)
}

var named = map[string][2]string{
	// name: {apple, other}
	"Enter":     {"↩", "Enter"},
	"Delete":    {"⌫", "Delete"},
	"Backspace": {"⌫", "Backspace"},
	"Tab":       {"⇥", "Tab"},
	"Esc":       {"⎋", "Esc"},
}

func format(apple bool, keys string) string {
	var ctrl, alt, shift, cmd bool
	key := ""
	for _, part := range strings.Split(keys, "+") {
		switch part {
		case "Mod":
			if apple {
				cmd = true
			} else {
				ctrl = true
			}
		case "Ctrl":
			ctrl = true
		case "Alt":
			alt = true
		case "Shift":
			shift = true
		default:
			key = part
		}
	}
	if n, ok := named[key]; ok {
		if apple {
			key = n[0]
		} else {
			key = n[1]
		}
	}
	if apple {
		var b strings.Builder
		for _, m := range []struct {
			on    bool
			glyph string
		}{{ctrl, "⌃"}, {alt, "⌥"}, {shift, "⇧"}, {cmd, "⌘"}} {
			if m.on {
				b.WriteString(m.glyph)
			}
		}
		return b.String() + key
	}
	var parts []string
	for _, m := range []struct {
		on   bool
		word string
	}{{ctrl, "Ctrl"}, {alt, "Alt"}, {shift, "Shift"}} {
		if m.on {
			parts = append(parts, m.word)
		}
	}
	if key != "" {
		parts = append(parts, key)
	}
	return strings.Join(parts, "+")
}