rewrite to make more pluggable

Author: DistroByte

.gitignore

@@ -1,2 +1,2 @@
 coverage.*
-elo.*
+output/

bench_test.go

@@ -0,0 +1,178 @@
+package multielo
+
+import (
+	"testing"
+)
+
+func setupLeagueForBenchmark(playerCount int) (*League, []*MatchResult) {
+	cfg := DefaultConfig()
+	cfg.MaxMatches = 1 << 30 // effectively unbounded for benchmark runs
+	l := NewLeagueWithConfig(cfg)
+
+	players := make([]*Player, playerCount)
+	for i := 0; i < playerCount; i++ {
+		name := string(rune('A'+i%26)) + string(rune('a'+(i/26)))
+		_ = l.AddPlayer(name)
+		p, _ := l.GetPlayer(name)
+		players[i] = p
+	}
+
+	results := make([]*MatchResult, playerCount)
+	for i := 0; i < playerCount; i++ {
+		results[i] = &MatchResult{Position: i + 1, Player: players[i]}
+	}
+	return l, results
+}
+
+// Benchmark: Small match (8 players)
+func BenchmarkAddMatchSmall(b *testing.B) {
+	l, results := setupLeagueForBenchmark(8)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if err := l.AddMatch(results); err != nil {
+			b.Fatalf("add match failed: %v", err)
+		}
+		if i%1000 == 0 {
+			l.ResetMatches()
+		}
+	}
+}
+
+// Benchmark: Medium match (20 players)
+func BenchmarkAddMatchMedium(b *testing.B) {
+	l, results := setupLeagueForBenchmark(20)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if err := l.AddMatch(results); err != nil {
+			b.Fatalf("add match failed: %v", err)
+		}
+		if i%1000 == 0 {
+			l.ResetMatches()
+		}
+	}
+}
+
+// Benchmark: Large match (50 players)
+func BenchmarkAddMatchLarge(b *testing.B) {
+	l, results := setupLeagueForBenchmark(50)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if err := l.AddMatch(results); err != nil {
+			b.Fatalf("add match failed: %v", err)
+		}
+		if i%100 == 0 {
+			l.ResetMatches()
+		}
+	}
+}
+
+// Benchmark: GetPlayer lookups (should be O(1))
+func BenchmarkGetPlayer(b *testing.B) {
+	l, _ := setupLeagueForBenchmark(100)
+	testName := "Aa" // Known player from setup
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := l.GetPlayer(testName)
+		if err != nil {
+			b.Fatalf("get player failed: %v", err)
+		}
+	}
+}
+
+// Benchmark: GetLeaderboard with leaderboard caching
+func BenchmarkGetLeaderboard(b *testing.B) {
+	l, results := setupLeagueForBenchmark(30)
+
+	// Add some matches to populate the league
+	for i := 0; i < 10; i++ {
+		_ = l.AddMatch(results)
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = l.GetLeaderboard()
+	}
+}
+
+// Benchmark: GetPlayerStats
+func BenchmarkGetPlayerStats(b *testing.B) {
+	l, results := setupLeagueForBenchmark(20)
+
+	// Add some matches to build up stats
+	for i := 0; i < 50; i++ {
+		_ = l.AddMatch(results)
+	}
+
+	player, _ := l.GetPlayer("Aa")
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = player.GetStats()
+	}
+}
+
+// Benchmark: League initialization with many players
+func BenchmarkLeagueInitialization(b *testing.B) {
+	const playerCount = 100
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		cfg := DefaultConfig()
+		cfg.MaxMatches = 1 << 30
+		l := NewLeagueWithConfig(cfg)
+
+		for j := 0; j < playerCount; j++ {
+			name := string(rune('A'+(j%26))) + string(rune('a'+(j/26)))
+			_ = l.AddPlayer(name)
+		}
+	}
+}
+
+// Benchmark: Service layer AddPlayer
+func BenchmarkServiceAddPlayer(b *testing.B) {
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		cfg := DefaultConfig()
+		cfg.MaxMatches = 1 << 30
+		cfg.MaxPlayers = 10 // Just need a few players per iteration
+		l := NewLeagueWithConfig(cfg)
+		service := NewLeagueService(l)
+
+		for j := 0; j < 10; j++ {
+			name := "Player" + string(rune('A'+(j%26)))
+			if err := service.AddPlayer(name); err != nil {
+				b.Fatalf("add player failed: %v", err)
+			}
+		}
+	}
+}
+
+// Benchmark: Match filtering
+func BenchmarkMatchFiltering(b *testing.B) {
+	l, results := setupLeagueForBenchmark(10)
+
+	// Add many matches
+	for i := 0; i < 100; i++ {
+		_ = l.AddMatch(results)
+	}
+
+	filter := MatchFilter{
+		Limit:  10,
+		Offset: 0,
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = l.GetMatchesFiltered(filter)
+	}
+}

domain/elo.go

@@ -0,0 +1,64 @@
+package domain
+
+import "math"
+
+type ELOCalculator interface {
+	Calculate(results []*MatchResult, cfg LeagueConfig) ([]MatchDiff, error)
+}
+
+type DefaultELOCalculator struct{}
+
+func (DefaultELOCalculator) Calculate(results []*MatchResult, cfg LeagueConfig) ([]MatchDiff, error) {
+	n := len(results)
+	if n < 2 {
+		return nil, ErrInvalidMatch
+	}
+
+	kValue := roundK(cfg.KFactor, n)
+	changes := make([]MatchDiff, n)
+
+	for i, result := range results {
+		changes[i] = MatchDiff{Player: result.Player, Diff: 0}
+	}
+
+	for i, result := range results {
+		currentELO := result.Player.ELO()
+		currentPosition := result.Position
+
+		for j, opponentResult := range results {
+			if i == j {
+				continue
+			}
+
+			opponentELO := opponentResult.Player.ELO()
+			opponentPosition := opponentResult.Position
+
+			var score float64
+			if currentPosition < opponentPosition {
+				score = 1.0
+			} else if currentPosition == opponentPosition {
+				score = 0.5
+			} else {
+				score = 0.0
+			}
+
+			expectedScore := expectedScore(currentELO, opponentELO)
+			eloChange := kValue * (score - expectedScore)
+			changes[i].Diff += int(eloChange)
+		}
+	}
+
+	return changes, nil
+}
+
+func CalculateELOChanges(results []*MatchResult, cfg LeagueConfig) ([]MatchDiff, error) {
+	return DefaultELOCalculator{}.Calculate(results, cfg)
+}
+
+func roundK(k int, n int) float64 {
+	return math.Round(float64(k) / float64(n-1))
+}
+
+func expectedScore(aELO, bELO int) float64 {
+	return 1.0 / (1.0 + math.Pow(10, float64(bELO-aELO)/400))
+}

domain/errors.go

@@ -0,0 +1,55 @@
+package domain
+
+import (
+	"errors"
+	"fmt"
+)
+
+type ErrorType string
+
+const (
+	ErrorTypeValidation     ErrorType = "VALIDATION"
+	ErrorTypeNotFound       ErrorType = "NOT_FOUND"
+	ErrorTypePlayerNotFound ErrorType = "PLAYER_NOT_FOUND"
+	ErrorTypePlayerExists   ErrorType = "PLAYER_EXISTS"
+	ErrorTypeConflict       ErrorType = "CONFLICT"
+	ErrorTypeInternal       ErrorType = "INTERNAL"
+)
+
+type ELOError struct {
+	Type    ErrorType
+	Message string
+	Player  string
+	Cause   error
+	Context map[string]interface{}
+}
+
+func (e ELOError) Error() string {
+	if e.Player != "" {
+		return fmt.Sprintf("[%s] %s (player: %s)", e.Type, e.Message, e.Player)
+	}
+	return fmt.Sprintf("[%s] %s", e.Type, e.Message)
+}
+
+func (e ELOError) Unwrap() error {
+	return e.Cause
+}
+
+var (
+	ErrInvalidPlayerName   = ELOError{Type: ErrorTypeValidation, Message: "player name cannot be empty or whitespace only"}
+	ErrPlayerAlreadyExists = ELOError{Type: ErrorTypePlayerExists, Message: "player already exists"}
+	ErrPlayerNotFound      = ELOError{Type: ErrorTypePlayerNotFound, Message: "player not found"}
+	ErrELOOutOfBounds      = ELOError{Type: ErrorTypeValidation, Message: "ELO value out of allowed range"}
+	ErrInvalidPosition     = ELOError{Type: ErrorTypeValidation, Message: "match position must be positive"}
+	ErrInvalidMatch        = ELOError{Type: ErrorTypeValidation, Message: "invalid match data"}
+	ErrLeagueFull          = ELOError{Type: ErrorTypeConflict, Message: "league has reached maximum player capacity"}
+	ErrNoPlayers           = ELOError{Type: ErrorTypeValidation, Message: "no players in league"}
+)
+
+var (
+	ErrMatchNotFound      = errors.New("match not found")
+	ErrInvalidELOChange   = errors.New("invalid elo change")
+	ErrInvalidPlayer      = errors.New("invalid player")
+	ErrInvalidPlayerStats = errors.New("invalid player stats")
+	ErrInvalidLeague      = errors.New("invalid league")
+)

domain/graph.go

@@ -0,0 +1,76 @@
+package domain
+
+type GraphRenderer interface {
+	Render(data GraphData, filenamePrefix string) (string, error)
+}
+
+type GraphData struct {
+	Config  LeagueConfig
+	Players []GraphPlayer
+	Matches []GraphMatch
+}
+
+type GraphPlayer struct {
+	Name       string
+	ELO        int
+	ELOHistory []int
+}
+
+type GraphMatch struct {
+	Results []GraphMatchResult
+}
+
+type GraphMatchResult struct {
+	Position int
+	Name     string
+}
+
+var graphRenderer GraphRenderer
+
+func SetGraphRenderer(r GraphRenderer) {
+	graphRenderer = r
+}
+
+func (l *League) GenerateGraph() (string, error) {
+	return l.GenerateGraphWithFilename("elo")
+}
+
+func (l *League) GenerateGraphWithFilename(filenamePrefix string) (string, error) {
+	l.mu.RLock()
+	if l.playersRepo.Count() == 0 {
+		l.mu.RUnlock()
+		return "", ErrNoPlayers
+	}
+	if l.matchesRepo.Count() == 0 {
+		l.mu.RUnlock()
+		return "", ELOError{Type: ErrorTypeValidation, Message: "no matches to plot"}
+	}
+
+	data := GraphData{Config: l.config}
+
+	players := l.playersRepo.List()
+	data.Players = make([]GraphPlayer, 0, len(players))
+	for _, p := range players {
+		data.Players = append(data.Players, GraphPlayer{
+			Name:       p.Name(),
+			ELO:        p.ELO(),
+			ELOHistory: l.playerELOHistory[p.Name()],
+		})
+	}
+
+	matches := l.matchesRepo.List()
+	data.Matches = make([]GraphMatch, 0, len(matches))
+	for _, m := range matches {
+		gm := GraphMatch{Results: make([]GraphMatchResult, 0, len(m.Results))}
+		for _, r := range m.Results {
+			gm.Results = append(gm.Results, GraphMatchResult{Position: r.Position, Name: r.Player.Name()})
+		}
+		data.Matches = append(data.Matches, gm)
+	}
+	l.mu.RUnlock()
+
+	if graphRenderer == nil {
+		return "", ELOError{Type: ErrorTypeInternal, Message: "graph renderer not configured"}
+	}
+	return graphRenderer.Render(data, filenamePrefix)
+}