package inventory

import (
	"testing"

	"github.com/novox/mesh-controller/internal/catalogue"
	"github.com/novox/mesh-controller/internal/secrets"
)

// With an operator key, a module's own secret is sealed to the operator as well — and the operator
// opens exactly the value the node was given.
func TestAnOwnSecretIsSealedToTheOperatorToo(t *testing.T) {
	inv, ctx := twoNodesWithKeys(t)
	if err := inv.RegisterModule(ctx, catalogue.Manifest{Module: "postgres", Version: "1"}, Source{}); err != nil {
		t.Fatal(err)
	}

	// Before there is a key: minted, and honestly unrecoverable.
	if _, err := inv.SecretForModule(ctx, "consumer", "postgres", "superuser"); err != nil {
		t.Fatal(err)
	}
	if _, err := inv.KeptSecret(ctx, "consumer", "postgres", "superuser"); err == nil {
		t.Fatal("a secret made before the operator key was reported recoverable")
	}
	kept, unrecoverable, err := inv.KeptForOperator(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if len(kept) != 0 || len(unrecoverable) != 1 {
		t.Fatalf("before a key: %d kept, %d unrecoverable", len(kept), len(unrecoverable))
	}

	pub, priv, err := secrets.Keypair()
	if err != nil {
		t.Fatal(err)
	}
	if orphaned, err := inv.SetOperatorKey(ctx, pub); err != nil || orphaned != 0 {
		t.Fatalf("set: orphaned %d, %v", orphaned, err)
	}

	// A new secret is sealed to both; an accepted one too.
	if _, err := inv.SecretForModule(ctx, "provider", "postgres", "superuser"); err != nil {
		t.Fatal(err)
	}
	if err := inv.AcceptSecretForModule(ctx, "provider", "postgres", "replication", "given-by-a-person"); err != nil {
		t.Fatal(err)
	}
	kept, unrecoverable, err = inv.KeptForOperator(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if len(kept) != 2 || len(unrecoverable) != 1 {
		t.Fatalf("after a key: %d kept, %d unrecoverable", len(kept), len(unrecoverable))
	}
	got, err := inv.KeptSecret(ctx, "provider", "postgres", "replication")
	if err != nil {
		t.Fatal(err)
	}
	value, err := secrets.Open(priv, got.Sealed)
	if err != nil {
		t.Fatal(err)
	}
	if string(value) != "given-by-a-person" {
		t.Fatalf("recovered %q", value)
	}
	if got.Origin != "accepted" || got.Key != pub {
		t.Fatalf("kept as %+v", got)
	}
	minted, err := inv.KeptSecret(ctx, "provider", "postgres", "superuser")
	if err != nil {
		t.Fatal(err)
	}
	if v, err := secrets.Open(priv, minted.Sealed); err != nil || len(v) != 40 {
		t.Fatalf("the minted secret did not open to a 40-character value: %v", err)
	}

	// The old secret, remade for a rejoined node, becomes recoverable — it was issued again.
	if _, err := inv.SecretForModule(ctx, "consumer", "postgres", "superuser"); err != nil {
		t.Fatal(err)
	}
	if _, err := inv.KeptSecret(ctx, "consumer", "postgres", "superuser"); err == nil {
		t.Fatal("asking again did not remake, yet it became recoverable")
	}

	// Replacing the key says how many secrets stay sealed to the old one.
	pub2, _, _ := secrets.Keypair()
	orphaned, err := inv.SetOperatorKey(ctx, pub2)
	if err != nil {
		t.Fatal(err)
	}
	if orphaned != 2 {
		t.Fatalf("replacing the key orphaned %d, and two were sealed to it", orphaned)
	}
	if now, _ := inv.OperatorKey(ctx); now != pub2 {
		t.Fatal("the new key is not the mesh's key")
	}
}