package inventory

import (
	"errors"
	"strings"
	"testing"

	"github.com/jackc/pgx/v5"
)

// What a release stops shipping is retired at the next start, and never from under a machine
// (novox/hq ADR 0226). `module forget` refuses a provided module, so without this a module the
// control plane no longer carries could be removed by nothing.

func TestAModuleTheControlPlaneNoLongerShipsIsRetired(t *testing.T) {
	inv := fresh(t)
	ctx := t.Context()
	for _, m := range []string{"mesh-wireguard", "networking"} {
		if err := inv.Provide(ctx, manifest(m, nil, nil)); err != nil {
			t.Fatal(err)
		}
	}
	retired, kept, err := inv.RetireUnshipped(ctx, []string{"mesh-wireguard"})
	if err != nil {
		t.Fatal(err)
	}
	if strings.Join(retired, ",") != "networking" || len(kept) != 0 {
		t.Fatalf("retired %v, kept %v", retired, kept)
	}
	if _, err := inv.Provided(ctx, "networking"); !errors.Is(err, pgx.ErrNoRows) {
		t.Fatalf("networking is still in the catalogue: %v", err)
	}
	if provided, err := inv.Provided(ctx, "mesh-wireguard"); err != nil || !provided {
		t.Fatalf("what this release ships went too: %v %v", provided, err)
	}
}

func TestARetiredModuleStillAssignedIsKeptAndSaidSo(t *testing.T) {
	inv := fresh(t)
	ctx := t.Context()
	if _, err := inv.AddNode(ctx, "anchor"); err != nil {
		t.Fatal(err)
	}
	if err := inv.Provide(ctx, manifest("networking", nil, nil)); err != nil {
		t.Fatal(err)
	}
	if _, err := inv.Assign(ctx, "anchor", "networking"); err != nil {
		t.Fatal(err)
	}
	retired, kept, err := inv.RetireUnshipped(ctx, nil)
	if err != nil {
		t.Fatal(err)
	}
	if len(retired) != 0 {
		// Taking it now would drop whatever it pulled in at the next push — for the bundle, the
		// private network.
		t.Fatalf("a module assigned on a machine was retired: %v", retired)
	}
	if !strings.Contains(kept["networking"], "anchor") {
		t.Fatalf("keeping it does not say where it is still assigned: %v", kept)
	}

	// Unassigned, the next start takes it.
	if err := inv.Unassign(ctx, "anchor", "networking"); err != nil {
		t.Fatal(err)
	}
	retired, _, err = inv.RetireUnshipped(ctx, nil)
	if err != nil {
		t.Fatal(err)
	}
	if strings.Join(retired, ",") != "networking" {
		t.Fatalf("unassigned, it was still not retired: %v", retired)
	}
}

func TestAModuleFromARepositoryIsNeverRetiredByThis(t *testing.T) {
	// Only what the control plane recorded as its own. A module somebody registered is theirs to
	// forget.
	inv := fresh(t)
	ctx := t.Context()
	if err := inv.RegisterModule(ctx, manifest("public-acme", nil, nil), Source{}); err != nil {
		t.Fatal(err)
	}
	retired, kept, err := inv.RetireUnshipped(ctx, nil)
	if err != nil {
		t.Fatal(err)
	}
	if len(retired) != 0 || len(kept) != 0 {
		t.Fatalf("a registered module was considered: retired %v, kept %v", retired, kept)
	}
}