From 1dcf4216d473a6ce7063297b3cae1c4cff2a070d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?William=20Herg=C3=A8s?= <william@herges.fr>
Date: Sat, 17 Jan 2026 22:14:37 +0100
Subject: fix(state): bad sum for XPs

---
 user/state.go | 26 ++++++++++++++++++++------
 user/xp.go    | 16 +++++++---------
 2 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/user/state.go b/user/state.go
index 676728b..2c27fef 100644
--- a/user/state.go
+++ b/user/state.go
@@ -3,6 +3,7 @@ package user
 import (
 	"context"
 	"errors"
+	"math"
 	"sync"
 	"time"
 
@@ -162,6 +163,19 @@ func SetState(ctx context.Context, state *State) context.Context {
 	return context.WithValue(ctx, ContextKeyState, state)
 }
 
+func deepCopy(src CopaingCached) CopaingCached {
+	res := CopaingCached{
+		ID:        src.ID,
+		DiscordID: src.DiscordID,
+		GuildID:   src.GuildID,
+		XP:        src.XP,
+		XPToAdd:   src.XPToAdd,
+		XPs:       make([]XPCached, len(src.XPs)),
+	}
+	copy(res.XPs, src.XPs)
+	return res
+}
+
 func (s *State) Copaing(guildID, copaingID string) (*CopaingCached, error) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
@@ -181,7 +195,7 @@ func (s *State) Copaings(guild string) []CopaingCached {
 	var ccs []CopaingCached
 	for _, cc := range s.storage {
 		if cc.GuildID == guild {
-			ccs = append(ccs, cc)
+			ccs = append(ccs, deepCopy(cc))
 		}
 	}
 	return ccs
@@ -197,15 +211,16 @@ func calcXP(c *Copaing) uint {
 
 func generateXPs(c *Copaing) []XPCached {
 	data := map[time.Duration]XPCached{}
-	sixH := 6 * time.Hour
+	var sumEach time.Duration = 6
 	for _, xp := range c.CopaingXPs {
-		// we add sixH at the end because we want it to be rounded to ceil
-		since := time.Since(xp.CreatedAt)/sixH + sixH
+		// we add sumEach at the end because we want it to be rounded to ceil
+		tmp := time.Since(xp.CreatedAt)/(sumEach*time.Hour) + sumEach
+		since := time.Duration(math.Floor(float64(tmp)))
 		if v, ok := data[since]; ok {
 			v.XP += xp.XP
 		} else {
 			data[since] = XPCached{
-				Time: since,
+				Time: since * time.Hour,
 				XP:   xp.XP,
 			}
 		}
@@ -214,7 +229,6 @@ func generateXPs(c *Copaing) []XPCached {
 	i := 0
 	for _, v := range data {
 		ccs[i] = v
-		println(v.Time.String(), v.XP)
 		i++
 	}
 	return ccs
diff --git a/user/xp.go b/user/xp.go
index 35c11f3..161a450 100644
--- a/user/xp.go
+++ b/user/xp.go
@@ -40,30 +40,28 @@ func (cc *CopaingCached) AddXP(ctx context.Context, s bot.Session, m *user.Membe
 	}
 }
 
-func (cc *CopaingCached) GetXPForDays(n uint) uint {
+func (cc *CopaingCached) GetXPForDays(d int) uint {
 	xp := uint(0)
 	for _, v := range cc.XPs {
-		if v.Time <= time.Duration(n*24)*time.Hour {
+		if v.Time <= time.Duration(d*24)*time.Hour {
 			xp += v.XP
 		}
 	}
 	return xp + cc.XPToAdd
 }
 
-// GetBestXP returns n Copaing with the best XP within d days (d <= cfg.DaysXPRemain; d < 0 <=> d = cfg.DaysXPRemain)
+// GetBestXP returns n Copaings with the best XP within d days (d <= cfg.DaysXPRemain; d < 0 <=> d = cfg.DaysXPRemain)
 func GetBestXP(ctx context.Context, guildId string, n uint, d int) []CopaingCached {
 	ccs := GetState(ctx).Copaings(guildId)
 	if d > 0 {
-		for _, v := range ccs {
-			v.XP = v.GetXPForDays(n)
+		for i, cc := range ccs {
+			cc.XP = cc.GetXPForDays(d)
+			ccs[i] = cc
 		}
 	}
 	slices.SortFunc(ccs, func(a, b CopaingCached) int {
 		// desc order
 		return int(b.XP) - int(a.XP)
 	})
-	m := min(len(ccs), int(n))
-	res := make([]CopaingCached, m)
-	copy(ccs[:m], res)
-	return res
+	return ccs[:min(len(ccs), int(n))]
 }
-- 
cgit v1.2.3