package auth

import (
	"errors"
	"strings"
	"testing"
	"unicode"
)

func TestGenerateToken(t *testing.T) {
	const n = 1000

	tokens := make([]string, 0, n)
	for i := 0; i < n; i++ {
		tok, err := GenerateToken()
		if err != nil {
			t.Fatalf("GenerateToken returned error on call %d: %v", i, err)
		}
		tokens = append(tokens, tok)
	}

	t.Run("all tokens are non-empty", func(t *testing.T) {
		for i, tok := range tokens {
			if tok == "" {
				t.Fatalf("token %d is empty", i)
			}
		}
	})

	t.Run("all tokens are distinct", func(t *testing.T) {
		seen := make(map[string]struct{}, len(tokens))
		for i, tok := range tokens {
			if _, dup := seen[tok]; dup {
				t.Fatalf("token %d is a duplicate: %q", i, tok)
			}
			seen[tok] = struct{}{}
		}
	})

	t.Run("no token contains whitespace", func(t *testing.T) {
		for i, tok := range tokens {
			if strings.IndexFunc(tok, unicode.IsSpace) >= 0 {
				t.Fatalf("token %d contains whitespace: %q", i, tok)
			}
		}
	})

	t.Run("every token is at least 32 characters", func(t *testing.T) {
		for i, tok := range tokens {
			if len(tok) < 32 {
				t.Fatalf("token %d has length %d, want >= 32", i, len(tok))
			}
		}
	})
}

type failingReader struct{}

func (failingReader) Read([]byte) (int, error) { return 0, errors.New("read failed") }

func TestGenerateTokenReadError(t *testing.T) {
	tok, err := generateToken(failingReader{})
	if err == nil {
		t.Fatal("expected an error when the random source fails")
	}
	if tok != "" {
		t.Fatalf("expected empty token on error, got %q", tok)
	}
}