package console

import (
	"fmt"
	"strings"
	"testing"

	"github.com/carlosframework/platform/internal/infraview"
)

// The same fleet must draw the same picture every time. A diagram that
// reshuffles between refreshes cannot be read for change, which is most of
// what an operator opens it for.
func TestLayoutIsDeterministic(t *testing.T) {
	a := renderBoth(BuildArch(archFixture()))
	b := renderBoth(BuildArch(archFixture()))
	if a != b {
		t.Fatal("two builds of the same input produced different SVG")
	}
}

// renderBoth is the whole page's drawing: every band of the CARLOS estate
// and every band of the account's other one, in page order. Determinism is a
// property of the PAGE, so every test about it renders all of it — a split
// that made one picture stable by letting another reshuffle would be no
// improvement on one that reshuffled. It also covers the band ORDER, which
// is part of what a reader would see move.
func renderBoth(v ArchView) string {
	return renderEstate(v.CARLOS) + "\n" + renderEstate(v.Rest)
}

// renderEstate is one estate's drawing: every band of it, in page order.
func renderEstate(e ArchEstate) string {
	var out []string
	for _, b := range e.Bands {
		out = append(out, b.Label+"\n"+string(RenderArchSVG(b)))
	}
	return strings.Join(out, "\n")
}

// eachBand names every picture on the page — one per estate per region — so
// a test that must hold of all of them says which one failed. It is the
// unit those tests want: a band is what gets laid out, sized and drawn, and
// the properties they assert (nothing overlaps, nothing sits on an edge,
// the viewBox is positive) are properties of one picture.
func eachBand(v ArchView) map[string]ArchBand {
	out := map[string]ArchBand{}
	for name, e := range map[string]ArchEstate{"CARLOS": v.CARLOS, "rest of the account": v.Rest} {
		for _, b := range e.Bands {
			out[name+" / "+b.Label] = b
		}
	}
	return out
}

// Layer order is the story one band tells: a DNS name enters at the left,
// resolves to an address, and reaches the box that answers for it. Four
// columns, because four is what fits the page (archLayer). A record
// pointing outside the estate must sit to the RIGHT of the record that
// names it — the diagram's headline unjoined case reads left-to-right like
// everything else.
func TestLayoutOrdersLayers(t *testing.T) {
	in := archFixture()
	in.Inv.Resources = append(in.Inv.Resources, infraview.Resource{
		Kind: infraview.KindDNSRecord, ID: "r2", Name: "mail.carloku.com",
		Attrs: map[string]string{"zone": "carloku.com", "type": "A", "value": "203.0.113.9"},
	})
	v := BuildArch(in)
	x := map[string]int{}
	for _, n := range archNodes(v) {
		x[n.ID] = n.X
	}
	if !(x["record:r1"] < x["ip:eipalloc-1"] && x["ip:eipalloc-1"] < x["box:carlos-eu-west-1"]) {
		t.Fatalf("layers out of order: %+v", x)
	}
	// And the whole band fits the console's 64rem main column, which is the
	// entire reason the columns were folded down to four. A picture wider
	// than this is one the operator has to drag.
	for name, b := range eachBand(v) {
		if b.Width > 1024 {
			t.Errorf("%s: band is %d units wide — it must fit the 1024px main column without scrolling sideways", name, b.Width)
		}
	}
	if !(x["record:r2"] < x["external:203.0.113.9"]) {
		t.Fatalf("external must sit right of the record that points at it: %+v", x)
	}
}

// No node may overlap another: the layout is the only thing standing
// between a growing fleet and an unreadable page.
func TestLayoutDoesNotOverlap(t *testing.T) {
	v := BuildArch(archFixture())
	// Per picture: two nodes in DIFFERENT diagrams sharing a coordinate is
	// not an overlap, it is two diagrams.
	for name, est := range eachBand(v) {
		for i := range est.Nodes {
			for j := i + 1; j < len(est.Nodes); j++ {
				a, b := est.Nodes[i], est.Nodes[j]
				if a.X < b.X+b.W && b.X < a.X+a.W && a.Y < b.Y+b.H && b.Y < a.Y+a.H {
					t.Fatalf("%s: %s overlaps %s", name, a.ID, b.ID)
				}
			}
		}
	}
}

// The SVG must scale without script and must not carry raw user strings
// unescaped.
func TestSVGIsSelfContainedAndEscaped(t *testing.T) {
	in := archFixture()
	in.Fleet.Boxes[0].Label = `evil"><script>alert(1)</script>`
	in.Hosts[0].Label = in.Fleet.Boxes[0].Label
	out := renderBoth(BuildArch(in))
	if !strings.Contains(out, "viewBox=") {
		t.Error("SVG must carry a viewBox so it scales with no JS")
	}
	if strings.Contains(out, "<script") {
		t.Error("a box label must never reach the SVG unescaped")
	}
}

// A deployment with no boxes and no inventory yet — an ungranted console on
// day one — must still draw a valid, positive viewBox. This is the FIRST
// page an operator sees after this ships, not a contrived corner case.
func TestLayoutEmptyGraphHasValidViewBox(t *testing.T) {
	v := BuildArch(ArchInput{})
	for name, est := range eachBand(v) {
		if len(est.Nodes) != 0 {
			t.Fatalf("%s: expected to draw no nodes at all, got %d", name, len(est.Nodes))
		}
		if est.Width <= 0 || est.Height <= 0 {
			t.Fatalf("%s: Width/Height must be positive even with zero nodes: %dx%d", name, est.Width, est.Height)
		}
	}
	out := renderBoth(v)
	if strings.Count(out, "viewBox=") != 2 {
		t.Error("both SVGs must carry a viewBox even when the graph is empty")
	}
	if strings.Contains(out, `viewBox="0 0 -`) {
		t.Error("viewBox must never carry a negative dimension")
	}
}

// The SVG carries an intrinsic size, not a viewBox alone. Without width and
// height a browser has nothing to size the element by, so it fills its
// container and scales the drawing down to fit: a full estate is ~1918 units
// wide against a ~1024px column, which renders 13px node titles at ~7px and
// never overflows, so the wrapper's scrollbar never appears either. The
// labels ARE the content of this diagram, so the size attributes are what
// make it a diagram rather than a texture.
func TestSVGCarriesIntrinsicSize(t *testing.T) {
	v := BuildArch(archFixture())
	out := renderBoth(v)
	for name, est := range eachBand(v) {
		if want := fmt.Sprintf(`width="%d" height="%d"`, est.Width, est.Height); !strings.Contains(out, want) {
			t.Errorf("%s: SVG must carry %s so it renders 1:1 and .archwrap scrolls; got:\n%s", name, want, out)
		}
		if !strings.Contains(out, fmt.Sprintf(`viewBox="0 0 %d %d"`, est.Width, est.Height)) {
			t.Errorf("%s: the viewBox must still match the intrinsic size", name)
		}
	}
	// Deterministic with the attributes as it was without them.
	if out != renderBoth(BuildArch(archFixture())) {
		t.Error("two renders of the same input differ")
	}
}

// archAlarmFixture is the flagship's real shape for this: one auto-recover
// alarm per box, plus one alarm naming a machine the estate read did not
// return.
func archAlarmFixture() ArchInput {
	in := archFixture()
	in.Inv.Resources = append(in.Inv.Resources,
		infraview.Resource{Kind: infraview.KindAlarm, ID: "a-1", Name: "auto-recover-eu-west-1",
			Attrs: map[string]string{"target": "i-123", "state": "OK", "metric": "StatusCheckFailed"}},
		infraview.Resource{Kind: infraview.KindAlarm, ID: "a-2", Name: "auto-recover-mystery",
			Attrs: map[string]string{"target": "i-999", "state": "ALARM", "metric": "StatusCheckFailed"}},
	)
	return in
}

// An alarm-bearing estate stays clean: the alarms ride the nodes they
// watch instead of standing in the flow (which is what put them under the
// IP-to-box edges), and adding them changes neither the overlap-free
// property nor determinism.
func TestLayoutAlarmBearingEstateStaysClean(t *testing.T) {
	v := BuildArch(archAlarmFixture())

	nodes := archNodes(v)
	for _, n := range nodes {
		if n.Kind == "alarm" {
			t.Fatalf("an alarm must not be a node in the flow: %+v", n)
		}
	}
	worn := map[string]int{}
	for _, n := range nodes {
		worn[n.ID] = len(n.Alarms)
	}
	// One in each picture: the box's alarm is CARLOS, the alarm on a machine
	// no box reports belongs with the rest of the account.
	for _, id := range []string{"box:carlos-eu-west-1", "machine:i-999"} {
		if worn[id] == 0 {
			t.Errorf("%s should wear the alarm that watches it: %+v", id, nodes)
		}
	}

	for name, est := range eachBand(v) {
		for i := range est.Nodes {
			for j := i + 1; j < len(est.Nodes); j++ {
				a, b := est.Nodes[i], est.Nodes[j]
				if a.X < b.X+b.W && b.X < a.X+a.W && a.Y < b.Y+b.H && b.Y < a.Y+a.H {
					t.Fatalf("%s: %s overlaps %s", name, a.ID, b.ID)
				}
			}
		}
	}
	if renderBoth(v) != renderBoth(BuildArch(archAlarmFixture())) {
		t.Error("two builds of an alarm-bearing estate produced different SVG")
	}
}

// The ordering contract inside bandsFrom: satellites are dropped, THEN the
// bands are decided, THEN each is laid out, and only then are its dangling
// edges pruned. Get it wrong and the page carries edges to nodes nobody
// draws, leaving the invariant to rest entirely on RenderArchSVG's skip.
// Two halves: the steps compose in that order, and a built view is already
// clean when it ships.
func TestPruneRunsAfterLayoutDropsSatellites(t *testing.T) {
	g := archGraph{
		Nodes: []Node{
			{ID: "box:a", Kind: "box", Title: "a"},
			{ID: "identity:role", Kind: "identity", Title: "carlos-box-role"},
		},
		Edges: []Edge{{From: "box:a", To: "identity:role", Kind: "runs"}},
	}
	bands := bandsFrom(g, map[string]string{"box:a": "eu-west-1"})
	if len(bands) != 1 || bands[0].Region != "eu-west-1" {
		t.Fatalf("bands = %+v, want one eu-west-1 band", bands)
	}
	for _, n := range bands[0].Nodes {
		if n.ID == "identity:role" {
			t.Fatal("an identity is table-only; it must be dropped before it is drawn")
		}
	}
	if len(bands[0].Edges) != 0 {
		t.Errorf("edges = %+v, want none — the only edge pointed at a dropped node", bands[0].Edges)
	}

	// And on a real build carrying both drawn alarms and a partial estate:
	// pruning the shipped view again must change nothing, because BuildArch
	// already pruned AFTER laying out.
	in := archAlarmFixture()
	in.Inv.Resources = append(in.Inv.Resources, infraview.Resource{
		Kind: infraview.KindAlarm, ID: "a-gone",
		Attrs: map[string]string{"target": "i-terminated", "state": "OK"},
	})
	built := BuildArch(in)
	for name, est := range eachBand(built) {
		before := len(est.Edges)
		pruneDanglingEdges(&est)
		if len(est.Edges) != before {
			t.Errorf("%s: a shipped view still had %d dangling edges in it", name, before-len(est.Edges))
		}
	}
}