EscapeFromTeacher/pkg/server/leaderboard.go

package server

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"log"
	"time"

	"git.zb-server.de/ZB-Server/EscapeFromTeacher/pkg/game"
	"github.com/redis/go-redis/v9"
)

type Leaderboard struct {
	rdb *redis.Client
	ctx context.Context
}

var GlobalLeaderboard *Leaderboard

const leaderboardKey = "leaderboard:top"

func InitLeaderboard(redisAddr string) error {
	rdb := redis.NewClient(&redis.Options{
		Addr:            redisAddr,
		DB:              0,
		MaxRetries:      5,
		MinRetryBackoff: 1 * time.Second,
		MaxRetryBackoff: 5 * time.Second,
		DialTimeout:     10 * time.Second,
		ReadTimeout:     3 * time.Second,
		WriteTimeout:    3 * time.Second,
	})

	ctx := context.Background()

	// Retry-Logik für initiales Connect
	maxRetries := 10
	retryDelay := 2 * time.Second

	for i := 0; i < maxRetries; i++ {
		if err := rdb.Ping(ctx).Err(); err != nil {
			log.Printf("⚠️ Redis noch nicht erreichbar (Versuch %d/%d): %v", i+1, maxRetries, err)
			if i < maxRetries-1 {
				log.Printf("⏳ Warte %v vor erneutem Versuch...", retryDelay)
				time.Sleep(retryDelay)
				retryDelay = retryDelay * 2 // Exponential backoff
				if retryDelay > 30*time.Second {
					retryDelay = 30 * time.Second
				}
				continue
			}
			return fmt.Errorf("Redis nicht erreichbar nach %d Versuchen: %w", maxRetries, err)
		}
		break // Erfolgreich verbunden
	}

	GlobalLeaderboard = &Leaderboard{
		rdb: rdb,
		ctx: ctx,
	}

	log.Println("✅ Redis-Leaderboard verbunden")
	return nil
}

// GenerateProofCode erstellt einen kryptografisch sicheren Proof-Code
func GenerateProofCode(playerCode string, score int, timestamp int64) string {
	// Secret Salt (sollte eigentlich aus Config kommen, aber für Demo hier hardcoded)
	secret := "EscapeFromTeacher_Secret_2026"
	data := fmt.Sprintf("%s:%d:%d:%s", playerCode, score, timestamp, secret)
	hash := sha256.Sum256([]byte(data))
	// Nehme erste 12 Zeichen des Hex-Hash
	return hex.EncodeToString(hash[:])[:12]
}

func (lb *Leaderboard) AddScore(name, code string, score int) (bool, string) {
	// Erstelle eindeutigen Key für diesen Score: PlayerCode + Timestamp
	timestamp := time.Now().Unix()
	uniqueKey := code + "_" + time.Now().Format("20060102_150405")

	// Generiere Proof-Code
	proofCode := GenerateProofCode(code, score, timestamp)

	// Score speichern
	entry := game.LeaderboardEntry{
		PlayerName: name,
		PlayerCode: code,
		Score:      score,
		Timestamp:  timestamp,
		ProofCode:  proofCode,
	}

	data, _ := json.Marshal(entry)
	lb.rdb.HSet(lb.ctx, "leaderboard:entries", uniqueKey, string(data))

	// In Sorted Set mit Score als Wert (uniqueKey statt code!)
	lb.rdb.ZAdd(lb.ctx, leaderboardKey, redis.Z{
		Score:  float64(score),
		Member: uniqueKey,
	})

	log.Printf("🏆 Leaderboard: %s mit %d Punkten (Entry: %s, Proof: %s)", name, score, uniqueKey, proofCode)
	return true, proofCode
}

// AdminLeaderboardEntry ist ein LeaderboardEntry mit zusätzlichem Key und Validierungsstatus
type AdminLeaderboardEntry struct {
	game.LeaderboardEntry
	Key   string `json:"key"`
	Valid bool   `json:"valid"`
}

// GetAll gibt alle Leaderboard-Einträge zurück (für Admin-Panel)
func (lb *Leaderboard) GetAll() []AdminLeaderboardEntry {
	raw, err := lb.rdb.HGetAll(lb.ctx, "leaderboard:entries").Result()
	if err != nil {
		log.Printf("⚠️ Fehler beim Abrufen aller Einträge: %v", err)
		return nil
	}

	entries := make([]AdminLeaderboardEntry, 0, len(raw))
	for key, dataStr := range raw {
		var e game.LeaderboardEntry
		if err := json.Unmarshal([]byte(dataStr), &e); err != nil {
			continue
		}
		expected := GenerateProofCode(e.PlayerCode, e.Score, e.Timestamp)
		entries = append(entries, AdminLeaderboardEntry{
			LeaderboardEntry: e,
			Key:              key,
			Valid:            e.ProofCode == expected,
		})
	}

	// Absteigend nach Score sortieren
	for i := 0; i < len(entries); i++ {
		for j := i + 1; j < len(entries); j++ {
			if entries[j].Score > entries[i].Score {
				entries[i], entries[j] = entries[j], entries[i]
			}
		}
	}
	return entries
}

// DeleteEntry löscht einen Eintrag aus Leaderboard (Hash + Sorted Set)
func (lb *Leaderboard) DeleteEntry(key string) error {
	lb.rdb.ZRem(lb.ctx, leaderboardKey, key)
	return lb.rdb.HDel(lb.ctx, "leaderboard:entries", key).Err()
}

func (lb *Leaderboard) GetTop10() []game.LeaderboardEntry {
	// Hole Top 10 (höchste Scores zuerst)
	uniqueKeys, err := lb.rdb.ZRevRange(lb.ctx, leaderboardKey, 0, 9).Result()
	if err != nil {
		log.Printf("⚠️ Fehler beim Abrufen des Leaderboards: %v", err)
		return []game.LeaderboardEntry{}
	}

	entries := make([]game.LeaderboardEntry, 0)
	for _, uniqueKey := range uniqueKeys {
		dataStr, err := lb.rdb.HGet(lb.ctx, "leaderboard:entries", uniqueKey).Result()
		if err != nil {
			continue
		}

		var entry game.LeaderboardEntry
		if err := json.Unmarshal([]byte(dataStr), &entry); err != nil {
			continue
		}
		entries = append(entries, entry)
	}

	return entries
}