feat: impl release hand & next speaker selection

rooms/room.go

@@ -0,0 +1,147 @@
+package rooms
+
+import (
+	"log"
+	"slices"
+)
+
+type Room struct {
+	Name           string // will be unique ID
+	AdminIds       []PersonId
+	PasswordHash   string
+	CurrentSpeaker PersonId // i guess let's set to zero value when it's noone from the room
+	Paricipants    []Person
+	// TODO hands, for each type of hand?
+	// i guess participants order fixed for now?
+	// and i'll still need 'current' for each hand level
+	ParticipantHands map[PersonId]HandGesture
+	Marks            map[HandGesture]PersonId
+}
+
+func (r *Room)InitMaps() {
+	if r.ParticipantHands == nil {
+		r.ParticipantHands = make(map[PersonId]HandGesture)
+	}
+	if r.Marks == nil {
+		r.Marks = make(map[HandGesture]PersonId)
+	}
+}
+
+// and how would i organize?
+// i should have map[HandGesture]ParticipantId as mark. for 'from where to go clockwise if returning a level lover'
+// now i want methods that for some person raise some hand, so i guess it adds what? to map[ParticipantId]HandGesture
+// i suppose methods should be on a room, in a session i'd have ParticipantId to pass in, and would load room
+// and i want all parts of room in same struct, because i'd want to subscribe to changes to all of them
+
+// i suppose raising a hand could be just in place adding PersonId->HandGesture,
+// but releasing hand should have additional logic
+func (r *Room) ReleaseHand(p PersonId) {
+	// releasing a hand of a current speaker should result in selection of a new speaker
+	log.Printf("about to release hand of %d in %s", p, r.Name)
+
+	// first remove hand of the requested person
+	currentSpeakerGesture, currentSpeakerHandFound := r.ParticipantHands[p]
+	if !currentSpeakerHandFound {
+		return
+	}
+
+	delete(r.ParticipantHands, p)
+
+	// if not a current speaker, no complicated logic required to release a hand
+	if r.CurrentSpeaker != p {
+		return
+	}
+
+	// if a current speaker - after removing the hand, we need to find next speaker
+	// from highest hand gesture to lowest, until one is found
+	gestures := [...]HandGesture{Meta, ClarifyingQ, Expand, ProbingQ, ChangeTopic}
+
+	var nextSpeakerId PersonId
+	var nextSpeakerFound bool
+
+gestureIteration:
+	for _, gesture := range gestures {
+		log.Printf("searching for gesture %s", gesture.String())
+		startIndex := r.gestureSearchStartIndex(gesture, currentSpeakerGesture)
+		participantsCount := len(r.Paricipants)
+		for i := 1; i < participantsCount; i++ {
+			checkIndex := startIndex + i%participantsCount
+			checkPerson := r.Paricipants[checkIndex]
+			checkGesture, isFound := r.ParticipantHands[checkPerson.Id]
+			if isFound && checkGesture == gesture {
+				nextSpeakerId, nextSpeakerFound = checkPerson.Id, true
+				break gestureIteration
+			}
+		}
+	}
+	if !nextSpeakerFound {
+		log.Printf("there is not next speaker, that's ok")
+	}
+
+	nextSpeakerGesture := r.ParticipantHands[nextSpeakerId]
+	log.Printf("found next speaker %+v", nextSpeakerId)
+
+	if nextSpeakerGesture > currentSpeakerGesture {
+		// raising the level of the speaker, need to save mark
+		log.Printf("we do have nextSpeaker of priority %s higher than current %s", nextSpeakerGesture.String(), currentSpeakerGesture.String())
+		r.Marks[currentSpeakerGesture] = p
+	}
+
+	// also we need to remove marks from top to current speaker level
+	for _, gesture := range gestures {
+		if gesture < nextSpeakerGesture {
+			break
+		}
+		delete(r.Marks, gesture)
+	}
+
+	r.CurrentSpeaker = nextSpeakerId
+}
+
+// find place to start - separate function
+// current speaker level, searched gesture level, room marks
+// if search level >= current speaker start from speaker
+// if search level < current speaekr look for mark, start from mark of that level,
+//
+//	if no mark - from speaker
+func (r *Room) gestureSearchStartIndex(gesture, curSpeakerGesture HandGesture) int {
+	if r.CurrentSpeaker == PersonId(0) {
+		// nobody is actully a speaker
+		return 0
+	}
+
+	var personFromWhichToStartSearch PersonId
+
+	// if searched guesture is higher or same as current speaker, start from speaker
+	if gesture >= curSpeakerGesture {
+		personFromWhichToStartSearch = r.CurrentSpeaker
+	}
+	// if searched gesture is of lower priority from current speaker, check marks to return to, or use speaker level
+	gestureMark, found := r.Marks[gesture]
+	if found {
+		personFromWhichToStartSearch = gestureMark
+	}
+	// if no mark found - count from the speaker
+	personFromWhichToStartSearch = r.CurrentSpeaker
+
+	indexFromWhichToStart := slices.IndexFunc(r.Paricipants, func(p Person) bool {
+		return p.Id == personFromWhichToStartSearch
+	})
+	return indexFromWhichToStart
+}
+
+// sooooooo. i need hand types. are there enums in go?
+type HandGesture uint8
+
+const (
+	ChangeTopic HandGesture = iota
+	ProbingQ
+	Expand
+	ClarifyingQ
+	Meta
+)
+
+// String() method to print the name of the days
+func (g HandGesture) String() string {
+	return [...]string{"Change Topic", "Probing Quesion", "Expand", "Clarifying Quesion", "Meta"}[g]
+}

rooms/rooms_manager.go

@@ -5,25 +5,28 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"math/rand"
 	"log"
 
 	"github.com/redis/go-redis/v9"
 )
 
-type Person struct {
-	PersonId     int
-	Name         string
-	PasswordHash string
+type PersonId int
+
+// TODO move to rooms i guess
+func RandomPersonId() PersonId {
+	randInt := rand.Int()
+	if randInt == 0 {
+		 randInt = 1
+	}
+	return PersonId(randInt)
 }
 
-type Room struct {
-	Name         string // will be unique ID
-	AdminIds     []int
+
+type Person struct {
+	Id     		 PersonId
+	Name         string
 	PasswordHash string
-	Paricipants  []Person
-	// TODO hands, for each type of hand?
-	// i guess participants order fixed for now?
-	// and i'll still need 'current' for each hand level
 }
 
 // well, it seems that i'd better do marshalling into bytes then