package catalogue

import (
	"strings"
	"testing"
)

// The mesh's bus is one per mesh, read from the catalogue beside this checkout.
//
// **This is step 2's claim, and it is checked here rather than in a bed** (novox/hq ADR 0116):
// adoption puts the NATS server into the `mesh-broker` seat on a mesh that is already running,
// and the property that matters is that a second one anywhere is refused *when it is assigned*,
// not discovered later as two servers holding different halves of the mesh's traffic. A second
// bus is not a degraded mesh; it is two meshes that both believe they are the one.
func TestASecondMeshBusAnywhereIsRefusedByName(t *testing.T) {
	nats := catalogueManifest(t, "nats")

	if _, err := Resolve(shelf(nats), []string{"nats"}, workstation(), World{}); err != nil {
		t.Fatalf("the bus alone does not resolve: %v", err)
	}

	elsewhere := World{Held: []Held{{Claim: "mesh-broker", Scope: ScopeMesh,
		Node: "anchor", Module: "nats"}}}
	other := workstation()
	other.Name = "laptop"
	_, err := Resolve(shelf(nats), []string{"nats"}, other, elsewhere)
	if err == nil {
		t.Fatal("a second bus was accepted on another machine")
	}
	if !strings.Contains(err.Error(), "mesh-broker") || !strings.Contains(err.Error(), "one per mesh") {
		t.Fatalf("refused without naming the seat: %v", err)
	}
}

// The seat is the server's role, not the product's name (novox/hq ADR 0079). A different
// implementation of the bus claims the same seat, and the mesh refuses it for the same reason —
// which is the property that lets the bus be replaced at all.
func TestTheSeatRefusesADifferentBusToo(t *testing.T) {
	nats := catalogueManifest(t, "nats")
	held := World{Held: []Held{{Claim: "mesh-broker", Scope: ScopeMesh,
		Node: "anchor", Module: "some-other-broker"}}}
	other := workstation()
	other.Name = "laptop"
	if _, err := Resolve(shelf(nats), []string{"nats"}, other, held); err == nil {
		t.Fatal("the seat admitted a second holder because the module's name differed")
	}
}

// The old broker no longer claims the seat: it is an ordinary provider of `amqp`
// (novox/hq ADR 0119), so it can sit on the same mesh as the bus without contending for it.
func TestTheAmqpBrokerDoesNotContendForTheSeat(t *testing.T) {
	lavinmq := catalogueManifest(t, "lavinmq")
	for _, c := range lavinmq.Claims {
		if c.Name == "mesh-broker" {
			t.Fatal("the amqp broker still claims mesh-broker; it is a provider, not foundation")
		}
	}
	busHeld := World{Held: []Held{{Claim: "mesh-broker", Scope: ScopeMesh,
		Node: "anchor", Module: "nats"}}}
	other := workstation()
	other.Name = "laptop"
	if _, err := Resolve(shelf(lavinmq), []string{"lavinmq"}, other, busHeld); err != nil {
		t.Fatalf("the amqp broker was refused beside the mesh bus: %v", err)
	}
}

// **A seat and the interface it delivers are different names, and renaming one must not rename
// the other** (novox/hq ADR 0118). This nearly went wrong: the seats were renamed to the `mesh-*`
// prefix, and a blanket search-and-replace also renamed `npm-package-registry` and `git` where
// they are *provisions* — which a consumer requires and a provider offers. The tests failed with
// "the package registry is served on <nil>", which does not say "you renamed an interface".
func TestRenamingASeatDidNotRenameTheInterfaceItDelivers(t *testing.T) {
	for _, pair := range []struct{ seat, delivers string }{
		{"mesh-git", "git"},
		{"mesh-npm-package-registry", "npm-package-registry"},
		{"mesh-artifact-store", "artifact-store"},
		{"mesh-store", "postgres-database"},
		{"mesh-broker", "mesh-bus"},
	} {
		s, known := SeatNamed(pair.seat)
		if !known {
			t.Fatalf("%q is not a seat", pair.seat)
		}
		if s.Delivers != pair.delivers {
			t.Errorf("the %s seat delivers %q, expected %q — renaming the seat moved the "+
				"interface with it, and every consumer requiring it would stop resolving",
				pair.seat, s.Delivers, pair.delivers)
		}
		if _, isSeat := SeatNamed(pair.delivers); isSeat {
			t.Errorf("%q is both an interface and a seat name; one of the renames was incomplete",
				pair.delivers)
		}
	}
}

// And a manifest written against an old seat name is told what it became, rather than refused as
// unknown — the courtesy the `needs`/`own-secrets` rename already sets.
func TestAnOldSeatNameSaysWhatItBecame(t *testing.T) {
	m := Manifest{Module: "old", Claims: []Claim{{Name: "the-catalogue", Scope: ScopeMesh}}}
	got := strings.Join(claimProblems(m), "; ")
	if !strings.Contains(got, "the-catalogue") || !strings.Contains(got, "mesh-catalog") {
		t.Fatalf("the refusal does not name both the old and the new: %q", got)
	}
}