package registry

import (
	"context"
	"errors"
	"testing"

	"gitea.home.hrajfrisbee.cz/kacerr/egress-proxies-operator/internal/provider"
)

// stubProvider is a minimal provider.Provider satisfying the interface for
// registry tests, which care about wiring, not provider behavior.
type stubProvider struct{ name string }

func (s *stubProvider) Create(ctx context.Context, req provider.CreateRequest) (string, error) {
	return "", nil
}
func (s *stubProvider) Get(ctx context.Context, providerID string) (*provider.Instance, error) {
	return nil, provider.ErrNotFound
}
func (s *stubProvider) Delete(ctx context.Context, providerID string) error { return nil }
func (s *stubProvider) ListByTag(ctx context.Context) ([]provider.Instance, error) {
	return nil, nil
}

func stubConstructor(name string) Constructor {
	return func(ctx context.Context, cfg provider.ProviderConfig) (provider.Provider, error) {
		return &stubProvider{name: name}, nil
	}
}

func TestBuild_dispatchesByType(t *testing.T) {
	t.Parallel()
	cfg := &provider.Config{Providers: []provider.ProviderConfig{
		{Name: "mock", Type: "mock"},
		{Name: "gcp-eu", Type: "gcp"},
	}}
	builtins := map[string]Constructor{
		"mock": stubConstructor("mock"),
		"gcp":  stubConstructor("gcp"),
	}

	providers, err := Build(context.Background(), cfg, builtins)
	if err != nil {
		t.Fatalf("Build() error = %v, want nil", err)
	}
	if len(providers) != 2 {
		t.Fatalf("len(providers) = %d, want 2", len(providers))
	}
	if _, ok := providers["mock"]; !ok {
		t.Error(`providers["mock"] missing`)
	}
	if _, ok := providers["gcp-eu"]; !ok {
		t.Error(`providers["gcp-eu"] missing, keyed by config name not type`)
	}
}

func TestBuild_unknownType(t *testing.T) {
	t.Parallel()
	cfg := &provider.Config{Providers: []provider.ProviderConfig{
		{Name: "p1", Type: "azure"},
	}}
	_, err := Build(context.Background(), cfg, map[string]Constructor{"mock": stubConstructor("mock")})
	if err == nil {
		t.Fatal("Build() error = nil, want error for unknown type")
	}
}

func TestBuild_constructorErrorAbortsWholeBuild(t *testing.T) {
	t.Parallel()
	failing := errors.New("boom")
	cfg := &provider.Config{Providers: []provider.ProviderConfig{
		{Name: "mock", Type: "mock"},
		{Name: "bad", Type: "bad"},
	}}
	builtins := map[string]Constructor{
		"mock": stubConstructor("mock"),
		"bad": func(ctx context.Context, cfg provider.ProviderConfig) (provider.Provider, error) {
			return nil, failing
		},
	}
	providers, err := Build(context.Background(), cfg, builtins)
	if err == nil {
		t.Fatal("Build() error = nil, want error from failing constructor")
	}
	if !errors.Is(err, failing) {
		t.Errorf("Build() error = %v, want it to wrap %v", err, failing)
	}
	if providers != nil {
		t.Errorf("Build() providers = %v, want nil on failure (no partial result)", providers)
	}
}