package nomino

import (
	"errors"
	"slices"
	"testing"

	"github.com/nalgeon/be"
)

const (
	out1 string = "abc"
	out2 string = "def"
)

var (
	outs           = []string{out1, out2}
	err1           = errors.New("oops")
	gen1 Generator = func(*Config) (string, error) { return out1, nil }
	gen2 Generator = func(*Config) (string, error) { return out2, nil }
	gen3 Generator = func(*Config) (string, error) { return "", err1 }
	gens           = []Generator{gen1, gen2, gen3}
)

func TestWithGenerator(t *testing.T) {
	g := func(*Config) (string, error) { return out1, nil }
	var c Config
	WithGenerator(g)(&c)
	st, err := c.generator(&c)
	be.Err(t, err, nil)
	be.Equal(t, st, out1)
}

func TestMultiGeneratorInOrder(t *testing.T) {
	g := MultiGeneratorInOrder(gens...)
	st, err := g(nil)
	be.Err(t, err, nil)
	be.Equal(t, st, out1)
	st, err = g(nil)
	be.Err(t, err, nil)
	be.Equal(t, st, out2)
	st, err = g(nil)
	be.Equal(t, st, "")
	be.Err(t, err, err1)
	st, err = g(nil)
	be.Err(t, err, nil)
	be.Equal(t, st, out1)
}

func TestMultiGeneratorInOrderOne(t *testing.T) {
	g1 := func(*Config) (string, error) { return out1, nil }
	g := MultiGeneratorInOrder(g1)

	st, err := g(nil)
	be.Err(t, err, nil)
	be.Equal(t, st, out1)
	st, err = g(nil)
	be.Err(t, err, nil)
	be.Equal(t, st, out1)
}

func TestMultiGeneratorInOrderMissing(t *testing.T) {
	g := MultiGeneratorInOrder()
	st, err := g(nil)
	be.Equal(t, st, "")
	be.Err(t, err, ErrMissingGenerators)
	st, err = g(nil)
	be.Equal(t, st, "")
	be.Err(t, err, ErrMissingGenerators)
}

func TestMultiGeneratorRandomOrder(t *testing.T) {
	g := MultiGeneratorRandomOrder(gens...)
	for i := 0; i < 4; i++ {
		st, err := g(nil)
		if err != nil {
			be.Equal(t, st, "")
			be.Err(t, err, err1)
		} else {
			be.True(t, slices.Contains(outs, st))
		}
	}
}

func TestMultiGeneratorRandomOrderOne(t *testing.T) {
	st1 := "abc"
	g1 := func(*Config) (string, error) { return st1, nil }
	g := MultiGeneratorRandomOrder(g1)

	st, err := g(nil)
	be.Err(t, err, nil)
	be.Equal(t, st, st1)
	st, err = g(nil)
	be.Err(t, err, nil)
	be.Equal(t, st, st1)
}

func TestMultiGeneratorRandomOrderMissing(t *testing.T) {
	g := MultiGeneratorRandomOrder()
	st, err := g(nil)
	be.Equal(t, st, "")
	be.Err(t, err, ErrMissingGenerators)
	st, err = g(nil)
	be.Equal(t, st, "")
	be.Err(t, err, ErrMissingGenerators)
}