package gateway

import (
	"strings"
	"testing"
)

// The plugin UI injection is JavaScript inside the embedded index.html, and it
// is the ONLY thing that turns a plugin's `ui` block into a visible page or
// element. These tests pin the wiring on the JS side; the server side (what the
// payload contains) is covered by TestUIInjectServesPluginUI and the lua
// package's TestBillingPluginDeclaresUI.
//
// What makes this worth pinning: a missing hook here fails SILENTLY. The page
// simply never appears, there is no error anywhere, and it looks like "the
// plugin didn't declare a page" rather than "the UI forgot to inject it".

// uiSource returns the embedded WebUI document.
func uiSourceX(t *testing.T) string {
	t.Helper()
	return uiSource(t)
}

// TestUIFetchesPluginInjection: the boot sequence must ask the kernel what to
// inject. Without this fetch the whole feature is inert.
func TestUIFetchesPluginInjection(t *testing.T) {
	src := uiSourceX(t)
	if !strings.Contains(src, "/api/ui-inject") {
		t.Error("the WebUI never calls /api/ui-inject; plugin pages and elements can never appear")
	}
}

// TestUIInjectsBeforeFirstRender: injection must be awaited before the first
// refresh, otherwise the sidebar is built without the plugin entry and the
// first paint races the fetch. This is an ordering contract, so it is asserted
// on the source order rather than trusted.
func TestUIInjectsBeforeFirstRender(t *testing.T) {
	src := uiSourceX(t)
	iInject := strings.Index(src, "injectPluginUI()")
	iRefresh := strings.LastIndex(src, `refresh("status")`)
	if iInject < 0 {
		t.Fatal("injectPluginUI() is never called")
	}
	if iRefresh < 0 {
		t.Fatal("the boot sequence no longer calls refresh(\"status\")")
	}
	if iInject > iRefresh {
		t.Error("injectPluginUI() is called after the first refresh; the sidebar " +
			"and #main would be built before the plugin page exists")
	}
	// And it must be awaited, not fire-and-forget.
	window := src[iInject:]
	if !strings.Contains(window[:200], ".finally") && !strings.Contains(window[:200], "await") {
		t.Error("injectPluginUI() is not awaited before refresh; a slow response " +
			"would race the first paint")
	}
}

// TestUIPluginScriptsRunAfterMarkup is the subtle one. Setting innerHTML with a
// <script> tag does NOT execute it; appending via a template neither does. The
// mount therefore has to be inserted first and its scripts re-created
// afterwards, or a plugin's script runs before its own DOM exists — which is
// exactly the "document.getElementById returns null" failure mode.
func TestUIPluginScriptsRunAfterMarkup(t *testing.T) {
	src := uiSourceX(t)
	// A <template> is used to parse the mount without executing scripts...
	if !strings.Contains(src, "createElement(\"template\")") {
		t.Error("the mount is not parsed via <template>; scripts could execute before their DOM")
	}
	// ...and scripts are then re-created as fresh elements so they DO run.
	if !strings.Contains(src, "document.createElement(\"script\")") {
		t.Error("plugin <script> blocks are never re-created, so they never execute")
	}
	if !strings.Contains(src, "replaceWith(s)") {
		t.Error("the original inert <script> is not replaced by an executable one")
	}
}

// TestUIPluginAPISurface: the documented browser API must exist with the exact
// names docs/plugins.md promises, since plugin authors code against it.
func TestUIPluginAPISurface(t *testing.T) {
	src := uiSourceX(t)
	for _, member := range []string{"fetchState", "postState", "onTabShown"} {
		if !strings.Contains(src, member+":") && !strings.Contains(src, member+"(") {
			t.Errorf("window.pluginAPI.%s is missing; docs/plugins.md documents it", member)
		}
	}
}

// TestUIPluginPageBecomesRealTab: a plugin page must get a pane in #main AND a
// sidebar button wired to goTab, otherwise the page is unreachable.
func TestUIPluginPageBecomesRealTab(t *testing.T) {
	src := uiSourceX(t)
	// pane in #main
	if !strings.Contains(src, `pane.id = "tab-" + id`) {
		t.Error("no pane is created for a plugin page")
	}
	if !strings.Contains(src, "main.appendChild(pane)") {
		t.Error("the plugin pane is not appended to #main")
	}
	// sidebar button wired to the tab router
	if !strings.Contains(src, "btn.dataset.tab = id") {
		t.Error("the sidebar button is not given a data-tab, so goTab() will not route to it")
	}
	if !strings.Contains(src, "btn.onclick = () => goTab(id)") {
		t.Error("the sidebar button is not wired to goTab()")
	}
	// and the router must know about it
	if !strings.Contains(src, "PLUGIN_PAGES.has(tab)") {
		t.Error("refresh() does not route plugin pages, so opening one renders nothing")
	}
}

// TestUIPluginElementsHonorAnchor: elements declare top / bottom / before:sel /
// after:sel. Silently ignoring the anchor would put a "top" tile at the bottom
// of the status page, which looks like a layout bug rather than a plugin bug.
func TestUIPluginElementsHonorAnchor(t *testing.T) {
	src := uiSourceX(t)
	for _, anchor := range []string{`anchor === "top"`, `anchor.startsWith("before:")`, `"after:"`} {
		if !strings.Contains(src, anchor) {
			t.Errorf("the anchor form %s is not handled; elements would all land at the bottom", anchor)
		}
	}
}

// TestUIPluginInjectionFailureIsNonFatal: plugins are optional, so a failed
// /api/ui-inject must still leave a working UI (the dashboard has to render).
// Two places have to cooperate: the function swallows the fetch error, and the
// caller catches anything that still escapes so refresh() always runs.
func TestUIPluginInjectionFailureIsNonFatal(t *testing.T) {
	src := uiSourceX(t)
	// inside the function: the fetch is wrapped in try/catch
	fnStart := strings.Index(src, "async function injectPluginUI()")
	if fnStart < 0 {
		t.Fatal("injectPluginUI() is not defined")
	}
	fn := src[fnStart:]
	if !strings.Contains(fn, "plugins are optional; the UI must work without them") {
		t.Error("injectPluginUI does not guard its own fetch failure")
	}
	// at the call site: the rejection cannot escape before the first render
	// LastIndex, not Index: the DEFINITION of injectPluginUI also matches, and
	// the definition has no .catch on it.
	iCall := strings.LastIndex(src, "injectPluginUI()")
	if iCall < 0 {
		t.Fatal("injectPluginUI() is never called")
	}
	// Bound the window at len(src): the call site sits near EOF and a fixed
	// slice overruns it (a panic in a test is worse than a skipped assertion).
	end := iCall + 220
	if end > len(src) {
		end = len(src)
	}
	if !strings.Contains(src[iCall:end], ".catch") {
		t.Error("a failed /api/ui-inject would reject before refresh(\"status\"), " +
			"leaving the dashboard blank")
	}
}