package nomino

import (
	"errors"
	"testing"

	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
)

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

func TestMultiGeneratorInOrder(t *testing.T) {
	st1 := "abc"
	st2 := "def"
	er1 := errors.New("oops")
	g1 := func(*Config) (string, error) { return st1, nil }
	g2 := func(*Config) (string, error) { return st2, nil }
	g3 := func(*Config) (string, error) { return "", er1 }
	g := MultiGeneratorInOrder(g1, g2, g3)
	st, err := g(nil)
	assert.NoError(t, err)
	assert.Equal(t, st1, st)
	st, err = g(nil)
	assert.NoError(t, err)
	assert.Equal(t, st2, st)
	st, err = g(nil)
	assert.Zero(t, st)
	assert.ErrorIs(t, err, er1)
	st, err = g(nil)
	assert.NoError(t, err)
	assert.Equal(t, st1, st)
}

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

	st, err := g(nil)
	assert.NoError(t, err)
	assert.Equal(t, st1, st)
	st, err = g(nil)
	assert.NoError(t, err)
	assert.Equal(t, st1, st)
}

func TestMultiGeneratorInOrderMissing(t *testing.T) {
	g := MultiGeneratorInOrder()
	st, err := g(nil)
	assert.Zero(t, st)
	assert.ErrorIs(t, err, ErrMissingGenerators)
	st, err = g(nil)
	assert.Zero(t, st)
	assert.ErrorIs(t, err, ErrMissingGenerators)
}

func TestUUID(t *testing.T) {
	st, err := UUID()(nil)
	assert.NoError(t, err)
	_, parseErr := uuid.Parse(st)
	assert.NoError(t, parseErr)
}

type badRead struct{}

func (badRead) Read([]byte) (int, error) {
	return 0, errors.New("sorry")
}

func TestUUIDFail(t *testing.T) {
	uuid.SetRand(badRead{})
	defer uuid.SetRand(nil)

	_, err := UUID()(nil)
	assert.Equal(t, errors.New("sorry"), err)
}

func TestSlugMissingFilename(t *testing.T) {
	conf := NewConfig(WithGenerator(Slug()))
	st, err := conf.generator(&conf)
	assert.Zero(t, st)
	assert.ErrorIs(t, err, ErrMissingOriginal)
}

func TestSlugRemovesOriginal(t *testing.T) {
	conf := NewConfig(WithGenerator(Slug()), WithOriginal("Hello, World"))
	st, err := conf.generator(&conf)
	assert.Zero(t, conf.original)
	assert.Equal(t, "hello-world", st)
	assert.NoError(t, err)
}

func TestHashBadHash(t *testing.T) {
	conf := NewConfig(WithOriginal("foobar"), WithGenerator(Hash(0)))
	st, err := conf.generator(&conf)
	assert.Equal(t, "", st)
	assert.ErrorIs(t, err, ErrInvalidHashType)
	assert.ErrorContains(t, err, "invalid hash type: HashType(0)")
}

func TestHashMissingOriginal(t *testing.T) {
	conf := NewConfig(WithGenerator(Hash(MD5)))
	st, err := conf.generator(&conf)
	assert.Equal(t, "", st)
	assert.ErrorIs(t, err, ErrMissingOriginal)
}

func TestHashTypeStringer(t *testing.T) {
	s := MD5.String()
	assert.Equal(t, "MD5", s)
}