package ownmanifest

import (
	"os"
	"path/filepath"
	"strings"
	"testing"

	. "git.novox.be/novox/mesh-sdk/go/catalogue"
)

func TestTheControllersOwnManifestClaimsItsSeat(t *testing.T) {
	// The seat test above fabricates manifests, so deleting the claim from the real module.json
	// would fail nothing (novox/hq issue 059's review). This binds the one manifest this
	// repository owns: the controller claims the mesh-scoped seat named after its server
	// (ADR 0079), or the one-controller property is convention again.
	raw, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
	if err != nil {
		t.Fatalf("the controller's own manifest is unreadable: %v", err)
	}
	m, err := ParseManifest(raw)
	if err != nil {
		t.Fatalf("the controller's own manifest does not parse: %v", err)
	}
	for _, c := range m.Claims {
		if c.Name == "mesh-controller" && c.At() == ScopeMesh {
			return
		}
	}
	t.Fatalf("module.json no longer claims the mesh-scoped mesh-controller seat: %+v", m.Claims)
}

// **The control plane's own manifest, composed through the whole path.**
//
// The store was given 6852 and the broker's plain port 5679 (the control-node's migration, novox/hq
// 04-ISSUES/102). The control plane's own connections are sealed at genesis with the ports genesis
// wrote; what its container is told beside them is where this machine put the store and the
// broker now, read from the node's settings exactly as every consumer's binding is.
func TestTheControlPlanesOwnAddressesFollowTheNodesPorts(t *testing.T) {
	raw, err := os.ReadFile("../../module.json")
	if err != nil {
		t.Fatal(err)
	}
	m, err := ParseManifest(raw)
	if err != nil {
		t.Fatalf("the control plane's own manifest does not parse:\n%v", err)
	}
	// The manifest itself names them now; withSeatPorts is a no-op on it, and this holds it so.
	for _, r := range m.Resources {
		if r["type"] != "process" {
			continue
		}
		env, _ := r["env"].(map[string]any)
		for key, want := range seatPorts {
			if env[key] != want {
				t.Errorf("module.json says %s=%v, not %q", key, env[key], want)
			}
		}
	}
	control, err := m.Resolve([]Built{{
		Name: "controller", Kind: ArtifactBundle,
		Reference: ArtifactStoreScheme + "mesh-controller/controller@sha256:" + strings.Repeat("c", 64),
		Digest:    "sha256:" + strings.Repeat("c", 64),
	}})
	if err != nil {
		t.Fatal(err)
	}
	r := Resolution{Node: "anchor", Modules: []Manifest{control}}
	needed := map[string]map[string]string{"mesh-controller": {}}
	for name := range m.OwnSecrets {
		needed["mesh-controller"][name] = "sealed-" + name
	}
	out, err := r.Declaration(Rendering{
		Needed:        needed,
		ArtifactStore: "anchor.internal:5100",
		Seats: map[string]map[int]int{
			"mesh-store":  {5432: 6852},
			"mesh-broker": {5671: 5671, 5672: 5679, 15672: 15673},
		},
	})
	if err != nil {
		t.Fatalf("the control plane does not compose: %v", err)
	}
	server := fileNamed(out, "mesh-controller.controller")
	if server == nil {
		t.Fatalf("the control plane's process is not in the declaration: %v", out)
	}
	env, _ := server["env"].(map[string]any)
	for key, want := range map[string]string{
		"MESH_STORE_INVENTORY_PORT":   "6852",
		"MESH_STORE_IDENTITY_PORT":    "6852",
		"MESH_STORE_LICENCES_PORT":    "6852",
		"MESH_BROKER_MANAGEMENT_PORT": "15673",
		"MESH_BROKER_ADDRESS_PORT":    "5671",
	} {
		if env[key] != want {
			t.Errorf("the control plane is told %s=%v; the node put it on %s", key, env[key], want)
		}
	}
	if got := server["source"]; got != "anchor.internal:5100/mesh-controller/controller@sha256:"+strings.Repeat("c", 64) {
		t.Errorf("the control plane's own bundle is fetched from %v, not routed through the store", got)
	}

	// And on a mesh where the foundation is where genesis raised it, nothing is added.
	out, err = r.Declaration(Rendering{Needed: needed, ArtifactStore: "anchor.internal:5100"})
	if err != nil {
		t.Fatal(err)
	}
	env, _ = fileNamed(out, "mesh-controller.controller")["env"].(map[string]any)
	if env["MESH_STORE_INVENTORY_PORT"] != "" {
		t.Errorf("with no settings, the control plane is told %v", env)
	}
}

// seatPorts is what the control plane's manifest says beside each sealed connection: the port
// this machine put the seat's holder at (novox/hq 04-ISSUES/102).
var seatPorts = map[string]string{
	"MESH_STORE_INVENTORY_PORT":   "${seat:mesh-store:5432}",
	"MESH_STORE_IDENTITY_PORT":    "${seat:mesh-store:5432}",
	"MESH_STORE_LICENCES_PORT":    "${seat:mesh-store:5432}",
	"MESH_BROKER_MANAGEMENT_PORT": "${seat:mesh-broker:15672}",
	"MESH_BROKER_ADDRESS_PORT":    "${seat:mesh-broker:5671}",
}