package main

import (
	"context"
	"sync"
	"sync/atomic"
	"testing"

	"git.novox.be/novox/mesh-sdk/go/catalogue"
	"github.com/novox/mesh-controller/internal/identity"
	"github.com/novox/mesh-controller/internal/inventory"
	"github.com/novox/mesh-controller/internal/licences"
)

// The serving controller's reads of the rest of the mesh open no pool per call: the licences and identity stores are the
// controller's own, opened once and shared. On 2026-10-25 at 16:08 each take-in opened two pools of its own
// (restOfTheMeshOf), about 120 at once, and novox's store refused every new connection (issues 1945 and 1277).
func TestRestOfTheMeshOfOpensNoPoolPerCall(t *testing.T) {
	wasIdent, wasLic, wasRest := identityOpener, licencesOpener, restOfTheMeshOn
	t.Cleanup(func() { identityOpener, licencesOpener, restOfTheMeshOn = wasIdent, wasLic, wasRest })
	var identities, licencesOpened atomic.Int64
	identityOpener = func(context.Context) (*identity.Identity, error) {
		identities.Add(1)
		return &identity.Identity{}, nil
	}
	licencesOpener = func(context.Context) (*licences.Licences, error) {
		licencesOpened.Add(1)
		return &licences.Licences{}, nil
	}
	// The read of the Input reaches both stores, as readComposeInput does.
	restOfTheMeshOn = func(ctx context.Context, open *stores, _ map[string]catalogue.Manifest, _ string) (catalogue.World, error) {
		if _, err := open.Licences(ctx); err != nil {
			return catalogue.World{}, err
		}
		if _, err := open.Identity(ctx); err != nil {
			return catalogue.World{}, err
		}
		return catalogue.World{}, nil
	}
	inv := &inventory.Inventory{}
	serving := &stores{inventory: inv}
	unshare := shareStores(serving)
	t.Cleanup(unshare)

	var wg sync.WaitGroup
	for range 120 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			if _, err := restOfTheMeshOf(context.Background(), inv, nil, ""); err != nil {
				t.Error(err)
			}
		}()
	}
	wg.Wait()
	if n := licencesOpened.Load(); n != 1 {
		t.Fatalf("opened the licences store %d times for 120 reads, want once", n)
	}
	if n := identities.Load(); n != 1 {
		t.Fatalf("opened the identity store %d times for 120 reads, want once", n)
	}
	if serving.licences == nil || serving.identity == nil {
		t.Fatal("the reads did not use the serving controller's stores")
	}
}

// A process that shares no stores (a verb run as its own short process) still opens them for the call and lets go.
func TestRestOfTheMeshOfOpensItsOwnWhereNoneAreShared(t *testing.T) {
	wasIdent, wasLic, wasRest := identityOpener, licencesOpener, restOfTheMeshOn
	t.Cleanup(func() { identityOpener, licencesOpener, restOfTheMeshOn = wasIdent, wasLic, wasRest })
	var opened atomic.Int64
	licencesOpener = func(context.Context) (*licences.Licences, error) { opened.Add(1); return &licences.Licences{}, nil }
	restOfTheMeshOn = func(ctx context.Context, open *stores, _ map[string]catalogue.Manifest, _ string) (catalogue.World, error) {
		_, err := open.Licences(ctx)
		return catalogue.World{}, err
	}
	inv := &inventory.Inventory{}
	for range 2 {
		if _, err := restOfTheMeshOf(context.Background(), inv, nil, ""); err != nil {
			t.Fatal(err)
		}
	}
	if n := opened.Load(); n != 2 {
		t.Fatalf("opened %d times, want once per call", n)
	}
}