From d7e4196f615dcc65333f13a94c189b66d72bf9fd Mon Sep 17 00:00:00 2001
From: Bel LaPointe <153096461+breel-render@users.noreply.github.com>
Date: Sun, 15 Dec 2024 09:44:13 -0700
Subject: [PATCH] refactorinnng

---
 cmd/server/games.go | 110 +++++++++++++++++++++++++++++---------------
 1 file changed, 72 insertions(+), 38 deletions(-)

diff --git a/cmd/server/games.go b/cmd/server/games.go
index ab84a67..7b43ef4 100644
--- a/cmd/server/games.go
+++ b/cmd/server/games.go
@@ -356,7 +356,6 @@ func (games Games) CreateEventAssignmentRotation(ctx context.Context, id string,
 	if err != nil {
 		return err
 	}
-	now := time.Now()
 
 	event := EventAssignmentRotation{
 		Type:   AssignmentRotation,
@@ -369,15 +368,23 @@ func (games Games) CreateEventAssignmentRotation(ctx context.Context, id string,
 		AllKillWords: make(AllKillWords),
 	}
 
-	toAssign := []string{}
-	doNotAssign := map[string]string{}
-
+	prevAllKillWords := make(AllKillWords)
 	for k, v := range state.Players {
-		v := v.KillWords
-		toAssign = append(toAssign, k)
-		doNotAssign[k] = v.Assignee
+		prevAllKillWords[k] = v.KillWords
+	}
 
-		event.AllKillWords[k] = KillWords{
+	event.AllKillWords.ShuffleAssignees(prevAllKillWords, killer, victim, word)
+
+	event.AllKillWords.FillKillWords()
+
+	return games.createEvent(ctx, id, event)
+}
+
+func (m AllKillWords) ShuffleAssignees(prev AllKillWords, killer, victim, word string) {
+	now := time.Now()
+
+	for k, v := range prev {
+		m[k] = KillWords{
 			Global:     v.Global,
 			Assigned:   now,
 			Assignee:   "",
@@ -385,72 +392,99 @@ func (games Games) CreateEventAssignmentRotation(ctx context.Context, id string,
 		}
 	}
 
-	if killerState, ok := state.Players[killer]; !ok {
-	} else if victimState, ok := state.Players[victim]; !ok {
+	if killerState, ok := prev[killer]; !ok {
+	} else if victimState, ok := prev[victim]; !ok {
 	} else {
-		event.AllKillWords[killer] = KillWords{
-			Global:     killerState.KillWords.Global,
+		m[killer] = KillWords{
+			Global:     killerState.Global,
 			Assigned:   now,
-			Assignee:   victimState.KillWords.Assignee,
-			Assignment: killerState.KillWords.Assignment,
+			Assignee:   victimState.Assignee,
+			Assignment: killerState.Assignment,
 		}
-		toAssign = slices.DeleteFunc(toAssign, func(s string) bool { return s == event.AllKillWords[killer].Assignee })
 
-		if killerState.KillWords.Global.Word != word {
-			victimState.KillWords.Assignment = Assignment{}
-			state.Players[victim] = victimState
+		if killerState.Global.Word != word {
+			victimState.Assignment = Assignment{}
+			prev[victim] = victimState
 		}
 	}
 
 	for !func() bool {
-		toAssign := slices.Clone(toAssign)
-		doNotAssign := maps.Clone(doNotAssign)
-		allKillWords := maps.Clone(event.AllKillWords)
-
-		for i := range toAssign {
-			j := rand.Intn(i + 1)
-			toAssign[i], toAssign[j] = toAssign[j], toAssign[i]
+		allKillWords := maps.Clone(m)
+		unassigned := allKillWords.unassigned()
+		pop := func() string {
+			result := unassigned[0]
+			unassigned = unassigned[1:]
+			return result
 		}
+
 		for k, v := range allKillWords {
-			if k == toAssign[0] || doNotAssign[k] == toAssign[0] {
+			assignee := pop()
+			if k == assignee || prev[k].Assignee == assignee {
 				return false
 			}
 			allKillWords[k] = KillWords{
 				Global:     v.Global,
 				Assigned:   now,
-				Assignee:   toAssign[0],
+				Assignee:   assignee,
 				Assignment: v.Assignment,
 			}
-			toAssign = toAssign[1:]
 		}
 
-		event.AllKillWords = allKillWords
+		for k, v := range allKillWords {
+			m[k] = v
+		}
 		return true
 	}() {
 	}
+}
 
-	for k, v := range event.AllKillWords {
+func (m AllKillWords) unassigned() []string {
+	var result []string
+	for k := range m {
+		if !slices.Contains(m.assigned(), k) {
+			result = append(result, k)
+		}
+	}
+	for i := range result {
+		j := rand.Intn(i + 1)
+		result[i], result[j] = result[j], result[i]
+	}
+	return result
+}
+
+func (m AllKillWords) assigned() []string {
+	var result []string
+	for k := range m {
+		v := m[k].Assignee
+		if v == "" {
+			continue
+		}
+		result = append(result, v)
+	}
+	return result
+}
+
+func (m AllKillWords) FillKillWords() {
+	for k, v := range m {
 		if v.Global.Word == "" {
-			v.Global = KillWord{Word: event.AllKillWords.unusedGlobal(), Points: -1}
-			event.AllKillWords[k] = v
+			v.Global = KillWord{Word: m.unusedGlobal(), Points: -1}
+			m[k] = v
 		}
 		if len(v.Assignment.Public) == 0 {
 			v.Assignment.Public = []KillWord{}
 			for i := 0; i < 2; i++ {
-				v.Assignment.Public = append(v.Assignment.Public, KillWord{Word: event.AllKillWords.unusedPublic(), Points: 50})
-				event.AllKillWords[k] = v
+				v.Assignment.Public = append(v.Assignment.Public, KillWord{Word: m.unusedPublic(), Points: 50})
+				m[k] = v
 			}
 		}
 		if len(v.Assignment.Private) == 0 {
 			v.Assignment.Private = []KillWord{}
 			for i := 0; i < 2; i++ {
-				v.Assignment.Private = append(v.Assignment.Private, KillWord{Word: event.AllKillWords.unusedPrivate(), Points: 100})
-				event.AllKillWords[k] = v
+				v.Assignment.Private = append(v.Assignment.Private, KillWord{Word: m.unusedPrivate(), Points: 100})
+				m[k] = v
 			}
 		}
 	}
-
-	return games.createEvent(ctx, id, event)
 }
 
 //go:embed holiday.txt