OOKNET                             [ /  search the index  ]  
──────────────────────────────────────────────────────────────────────────────────────
[ KB ]    [ GIT ]    [ PROJECTS ]    [ ABOUT ]                                      EN
══════════════════════════════════════════════════════════════════════════════════════
OOKNET   [ /  search  ]  
────────────────────────────────────────────────
[ KB ] [ GIT ] [ PROJECTS ] [ ABOUT ]
════════════════════════════════════════════════
 
HASH      bc500fc46fe6
DATE      2025-11-14
SUBJECT   ookstats: handle new connected realms
FILES     2 CHANGED
HASH      bc500fc46fe6
DATE      2025-11-14
SUBJECT   ookstats: handle new connected realms
FILES     2 CHANGED
 

diff --git a/nix/pkgs/ookstats/src/internal/generator/player_leaderboards.go b/nix
/pkgs/ookstats/src/internal/generator/player_leaderboards.go
index bcd6b1c..7b0b576 100644
--- a/nix/pkgs/ookstats/src/internal/generator/player_leaderboards.go
+++ b/nix/pkgs/ookstats/src/internal/generator/player_leaderboards.go
@@ -3,6 +3,7 @@ package generator
 import (
 	"database/sql"
 	"fmt"
+	"ookstats/internal/utils"
 	"ookstats/internal/wow"
 	"ookstats/internal/writer"
 	"os"
@@ -187,39 +188,52 @@ func generateRealmPlayerLeaderboards(db *sql.DB, out, region
 string, pageSize in
 		slugs = append(slugs, s)
 	}
 
-	for _, rslug := range slugs {
-		dir := filepath.Join(out, "players", "realm", region, rslug)
+	groups := groupRealmSlugs(region, slugs)
+	if len(groups) == 0 {
+		return nil
+	}
+
+	for _, group := range groups {
+		if len(group.Slugs) == 0 {
+			continue
+		}
+		dir := filepath.Join(out, "players", "realm", region, group.Parent)
 		if err := os.MkdirAll(dir, 0o755); err != nil {
 			return err
 		}
 
+		placeholder := makeSQLPlaceholders(len(group.Slugs))
+		baseArgs := append([]interface{}{seasonID, region}, stringSliceToInterface(grou
p.Slugs)...)
+
 		var total int
-		if err := db.QueryRow(`
+		countQuery := fmt.Sprintf(`
 			SELECT COUNT(*)
 			FROM players p
 			JOIN realms r ON p.realm_id = r.id
 			JOIN player_profiles pp ON p.id = pp.player_id
-			WHERE pp.season_id = ? AND r.region = ? AND r.slug = ? AND pp.has_complete_cov
erage = 1 AND pp.combined_best_time IS NOT NULL
-		`, seasonID, region, rslug).Scan(&total); err != nil {
+			WHERE pp.season_id = ? AND r.region = ? AND r.slug IN (%s) AND pp.has_complete
_coverage = 1 AND pp.combined_best_time IS NOT NULL
+		`, placeholder)
+		if err := db.QueryRow(countQuery, baseArgs...).Scan(&total); err != nil {
 			return fmt.Errorf("players total (realm, season %d): %w", seasonID, err)
 		}
 
 		pages := (total + pageSize - 1) / pageSize
 		for p := 1; p <= pages; p++ {
 			offset := (p - 1) * pageSize
-			rows, err := db.Query(`
+			dataArgs := append(append([]interface{}{}, baseArgs...), pageSize, offset)
+			rows, err := db.Query(fmt.Sprintf(`
 				SELECT p.id, p.name, r.slug, r.name, r.region,
-					   COALESCE(pd.class_name,''), COALESCE(pd.active_spec_name,''), pp.main_spe
c_id,
-					   pp.combined_best_time, pp.dungeons_completed, pp.total_runs,
-					   COALESCE(pp.realm_ranking_bracket, '')
+				       COALESCE(pd.class_name,''), COALESCE(pd.active_spec_name,''), pp.main_
spec_id,
+				       pp.combined_best_time, pp.dungeons_completed, pp.total_runs,
+				       COALESCE(pp.realm_ranking_bracket, '')
 				FROM players p
 				JOIN realms r ON p.realm_id = r.id
 				JOIN player_profiles pp ON p.id = pp.player_id
 				LEFT JOIN player_details pd ON p.id = pd.player_id
-				WHERE pp.season_id = ? AND r.region = ? AND r.slug = ? AND pp.has_complete_co
verage = 1 AND pp.combined_best_time IS NOT NULL
+				WHERE pp.season_id = ? AND r.region = ? AND r.slug IN (%s) AND pp.has_complet
e_coverage = 1 AND pp.combined_best_time IS NOT NULL
 				ORDER BY pp.combined_best_time ASC, p.name ASC
 				LIMIT ? OFFSET ?
-			`, seasonID, region, rslug, pageSize, offset)
+			`, placeholder), dataArgs...)
 			if err != nil {
 				return err
 			}
@@ -229,7 +243,9 @@ func generateRealmPlayerLeaderboards(db *sql.DB, out, region s
tring, pageSize in
 				return err
 			}
 
-			title := strings.ToUpper(region) + "/" + rslug + " Player Rankings"
+			applyPercentileBrackets(list, offset, total)
+
+			title := strings.ToUpper(region) + "/" + group.Parent + " Player Rankings"
 			page := buildPlayerLeaderboardPage(list, title, total, pages, p, pageSize)
 			if err := writer.WriteJSONFile(filepath.Join(dir, fmt.Sprintf("%d.json", p)), 
page); err != nil {
 				return err
@@ -269,8 +285,18 @@ func generateClassPlayerLeaderboards(db *sql.DB, out, classKe
y string, pageSize
 		}
 		rrows.Close()
 
+		seenParents := make(map[string]struct{})
 		for _, rslug := range slugs {
-			if err := generateClassScope(db, out, "realm", reg, rslug, classKey, pageSize,
 seasonID); err != nil {
+			parentSlug := effectiveRealmSlug(reg, rslug)
+			if parentSlug == "" {
+				parentSlug = rslug
+			}
+			if _, exists := seenParents[parentSlug]; exists {
+				continue
+			}
+			seenParents[parentSlug] = struct{}{}
+
+			if err := generateClassScope(db, out, "realm", reg, parentSlug, classKey, page
Size, seasonID); err != nil {
 				return err
 			}
 		}
@@ -286,7 +312,12 @@ func generateClassScope(db *sql.DB, out, scope, region, realm
Slug, classKey stri
 	} else if scope == "regional" {
 		dir = filepath.Join(out, "players", "class", classKey, "regional", region)
 	} else {
-		dir = filepath.Join(out, "players", "class", classKey, "realm", region, realmSl
ug)
+		effectiveSlug := effectiveRealmSlug(region, realmSlug)
+		if effectiveSlug == "" {
+			effectiveSlug = realmSlug
+		}
+		realmSlug = effectiveSlug
+		dir = filepath.Join(out, "players", "class", classKey, "realm", region, effecti
veSlug)
 	}
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return err
@@ -326,19 +357,26 @@ func generateClassScope(db *sql.DB, out, scope, region, real
mSlug, classKey stri
 		`, seasonID, region)
 	} else {
 		bracketColumn = "pp.realm_ranking_bracket"
-		rows, err = db.Query(`
+		realmSlugs := realmGroupSlugs(region, realmSlug)
+		if len(realmSlugs) == 0 {
+			realmSlugs = []string{realmSlug}
+		}
+		placeholder := makeSQLPlaceholders(len(realmSlugs))
+		args := append([]interface{}{seasonID, region}, stringSliceToInterface(realmSlu
gs)...)
+		rows, err = db.Query(fmt.Sprintf(`
 			SELECT p.id, p.name, r.slug, r.name, r.region,
-				   COALESCE(pd.class_name,''), COALESCE(pd.active_spec_name,''), pp.main_spec
_id,
-				   pp.combined_best_time, pp.dungeons_completed, pp.total_runs,
-				   COALESCE(pp.realm_ranking_bracket, '')
+			       COALESCE(pd.class_name,''), COALESCE(pd.active_spec_name,''), pp.main_s
pec_id,
+			       pp.combined_best_time, pp.dungeons_completed, pp.total_runs,
+			       COALESCE(pp.realm_ranking_bracket, '')
 			FROM players p
 			JOIN realms r ON p.realm_id = r.id
 			JOIN player_profiles pp ON p.id = pp.player_id
 			LEFT JOIN player_details pd ON p.id = pd.player_id
-			WHERE pp.season_id = ? AND r.region = ? AND r.slug = ? AND pp.has_complete_cov
erage = 1 AND pp.combined_best_time IS NOT NULL
+			WHERE pp.season_id = ? AND r.region = ? AND r.slug IN (%s) AND pp.has_complete
_coverage = 1 AND pp.combined_best_time IS NOT NULL
 			ORDER BY pp.combined_best_time ASC, p.name ASC
-		`, seasonID, region, realmSlug)
+		`, placeholder), args...)
 	}
+
 	_ = bracketColumn // unused for now, but documents intent
 	if err != nil {
 		return err
@@ -421,6 +459,10 @@ func generateClassScope(db *sql.DB, out, scope, region, realm
Slug, classKey stri
 			list = append(list, obj)
 		}
 
+		if scope == "realm" {
+			applyPercentileBrackets(list, offset, total)
+		}
+
 		title := "Global Player Rankings"
 		if scope == "regional" {
 			title = strings.ToUpper(region) + " Player Rankings"
@@ -510,3 +552,21 @@ func buildPlayerLeaderboardPage(leaderboard []map[string]any,
 title string, tota
 		},
 	}
 }
+
+func applyPercentileBrackets(entries []map[string]any, offset int, total int) {
+	if total <= 0 {
+		return
+	}
+	for i, entry := range entries {
+		rank := offset + i + 1
+		if rank <= 0 {
+			continue
+		}
+		bracket := utils.CalculatePercentileBracket(rank, total)
+		if bracket == "" {
+			delete(entry, "ranking_percentile")
+		} else {
+			entry["ranking_percentile"] = bracket
+		}
+	}
+}


diff --git a/nix/pkgs/ookstats/src/internal/
generator/player_leaderboards.go b/nix/pkgs/
ookstats/src/internal/generator/player_leade
rboards.go
index bcd6b1c..7b0b576 100644
--- a/nix/pkgs/ookstats/src/internal/generat
or/player_leaderboards.go
+++ b/nix/pkgs/ookstats/src/internal/generat
or/player_leaderboards.go
@@ -3,6 +3,7 @@ package generator
 import (
 	"database/sql"
 	"fmt"
+	"ookstats/internal/utils"
 	"ookstats/internal/wow"
 	"ookstats/internal/writer"
 	"os"
@@ -187,39 +188,52 @@ func generateRealmPlay
erLeaderboards(db *sql.DB, out, region strin
g, pageSize in
 		slugs = append(slugs, s)
 	}
 
-	for _, rslug := range slugs {
-		dir := filepath.Join(out, "players", "rea
lm", region, rslug)
+	groups := groupRealmSlugs(region, slugs)
+	if len(groups) == 0 {
+		return nil
+	}
+
+	for _, group := range groups {
+		if len(group.Slugs) == 0 {
+			continue
+		}
+		dir := filepath.Join(out, "players", "rea
lm", region, group.Parent)
 		if err := os.MkdirAll(dir, 0o755); err !=
 nil {
 			return err
 		}
 
+		placeholder := makeSQLPlaceholders(len(gr
oup.Slugs))
+		baseArgs := append([]interface{}{seasonID
, region}, stringSliceToInterface(group.Slug
s)...)
+
 		var total int
-		if err := db.QueryRow(`
+		countQuery := fmt.Sprintf(`
 			SELECT COUNT(*)
 			FROM players p
 			JOIN realms r ON p.realm_id = r.id
 			JOIN player_profiles pp ON p.id = pp.pla
yer_id
-			WHERE pp.season_id = ? AND r.region = ? 
AND r.slug = ? AND pp.has_complete_coverage 
= 1 AND pp.combined_best_time IS NOT NULL
-		`, seasonID, region, rslug).Scan(&total);
 err != nil {
+			WHERE pp.season_id = ? AND r.region = ? 
AND r.slug IN (%s) AND pp.has_complete_cover
age = 1 AND pp.combined_best_time IS NOT NUL
L
+		`, placeholder)
+		if err := db.QueryRow(countQuery, baseArg
s...).Scan(&total); err != nil {
 			return fmt.Errorf("players total (realm,
 season %d): %w", seasonID, err)
 		}
 
 		pages := (total + pageSize - 1) / pageSiz
e
 		for p := 1; p <= pages; p++ {
 			offset := (p - 1) * pageSize
-			rows, err := db.Query(`
+			dataArgs := append(append([]interface{}{
}, baseArgs...), pageSize, offset)
+			rows, err := db.Query(fmt.Sprintf(`
 				SELECT p.id, p.name, r.slug, r.name, r.
region,
-					   COALESCE(pd.class_name,''), COALESC
E(pd.active_spec_name,''), pp.main_spec_id,
-					   pp.combined_best_time, pp.dungeons_
completed, pp.total_runs,
-					   COALESCE(pp.realm_ranking_bracket, 
'')
+				       COALESCE(pd.class_name,''), COAL
ESCE(pd.active_spec_name,''), pp.main_spec_i
d,
+				       pp.combined_best_time, pp.dungeo
ns_completed, pp.total_runs,
+				       COALESCE(pp.realm_ranking_bracke
t, '')
 				FROM players p
 				JOIN realms r ON p.realm_id = r.id
 				JOIN player_profiles pp ON p.id = pp.pl
ayer_id
 				LEFT JOIN player_details pd ON p.id = p
d.player_id
-				WHERE pp.season_id = ? AND r.region = ?
 AND r.slug = ? AND pp.has_complete_coverage
 = 1 AND pp.combined_best_time IS NOT NULL
+				WHERE pp.season_id = ? AND r.region = ?
 AND r.slug IN (%s) AND pp.has_complete_cove
rage = 1 AND pp.combined_best_time IS NOT NU
LL
 				ORDER BY pp.combined_best_time ASC, p.n
ame ASC
 				LIMIT ? OFFSET ?
-			`, seasonID, region, rslug, pageSize, of
fset)
+			`, placeholder), dataArgs...)
 			if err != nil {
 				return err
 			}
@@ -229,7 +243,9 @@ func generateRealmPlayer
Leaderboards(db *sql.DB, out, region string,
 pageSize in
 				return err
 			}
 
-			title := strings.ToUpper(region) + "/" +
 rslug + " Player Rankings"
+			applyPercentileBrackets(list, offset, to
tal)
+
+			title := strings.ToUpper(region) + "/" +
 group.Parent + " Player Rankings"
 			page := buildPlayerLeaderboardPage(list,
 title, total, pages, p, pageSize)
 			if err := writer.WriteJSONFile(filepath.
Join(dir, fmt.Sprintf("%d.json", p)), page);
 err != nil {
 				return err
@@ -269,8 +285,18 @@ func generateClassPlaye
rLeaderboards(db *sql.DB, out, classKey stri
ng, pageSize
 		}
 		rrows.Close()
 
+		seenParents := make(map[string]struct{})
 		for _, rslug := range slugs {
-			if err := generateClassScope(db, out, "r
ealm", reg, rslug, classKey, pageSize, seaso
nID); err != nil {
+			parentSlug := effectiveRealmSlug(reg, rs
lug)
+			if parentSlug == "" {
+				parentSlug = rslug
+			}
+			if _, exists := seenParents[parentSlug];
 exists {
+				continue
+			}
+			seenParents[parentSlug] = struct{}{}
+
+			if err := generateClassScope(db, out, "r
ealm", reg, parentSlug, classKey, pageSize, 
seasonID); err != nil {
 				return err
 			}
 		}
@@ -286,7 +312,12 @@ func generateClassScope
(db *sql.DB, out, scope, region, realmSlug, 
classKey stri
 	} else if scope == "regional" {
 		dir = filepath.Join(out, "players", "clas
s", classKey, "regional", region)
 	} else {
-		dir = filepath.Join(out, "players", "clas
s", classKey, "realm", region, realmSlug)
+		effectiveSlug := effectiveRealmSlug(regio
n, realmSlug)
+		if effectiveSlug == "" {
+			effectiveSlug = realmSlug
+		}
+		realmSlug = effectiveSlug
+		dir = filepath.Join(out, "players", "clas
s", classKey, "realm", region, effectiveSlug
)
 	}
 	if err := os.MkdirAll(dir, 0o755); err != 
nil {
 		return err
@@ -326,19 +357,26 @@ func generateClassScop
e(db *sql.DB, out, scope, region, realmSlug,
 classKey stri
 		`, seasonID, region)
 	} else {
 		bracketColumn = "pp.realm_ranking_bracket
"
-		rows, err = db.Query(`
+		realmSlugs := realmGroupSlugs(region, rea
lmSlug)
+		if len(realmSlugs) == 0 {
+			realmSlugs = []string{realmSlug}
+		}
+		placeholder := makeSQLPlaceholders(len(re
almSlugs))
+		args := append([]interface{}{seasonID, re
gion}, stringSliceToInterface(realmSlugs)...
)
+		rows, err = db.Query(fmt.Sprintf(`
 			SELECT p.id, p.name, r.slug, r.name, r.r
egion,
-				   COALESCE(pd.class_name,''), COALESCE
(pd.active_spec_name,''), pp.main_spec_id,
-				   pp.combined_best_time, pp.dungeons_c
ompleted, pp.total_runs,
-				   COALESCE(pp.realm_ranking_bracket, '
')
+			       COALESCE(pd.class_name,''), COALE
SCE(pd.active_spec_name,''), pp.main_spec_id
,
+			       pp.combined_best_time, pp.dungeon
s_completed, pp.total_runs,
+			       COALESCE(pp.realm_ranking_bracket
, '')
 			FROM players p
 			JOIN realms r ON p.realm_id = r.id
 			JOIN player_profiles pp ON p.id = pp.pla
yer_id
 			LEFT JOIN player_details pd ON p.id = pd
.player_id
-			WHERE pp.season_id = ? AND r.region = ? 
AND r.slug = ? AND pp.has_complete_coverage 
= 1 AND pp.combined_best_time IS NOT NULL
+			WHERE pp.season_id = ? AND r.region = ? 
AND r.slug IN (%s) AND pp.has_complete_cover
age = 1 AND pp.combined_best_time IS NOT NUL
L
 			ORDER BY pp.combined_best_time ASC, p.na
me ASC
-		`, seasonID, region, realmSlug)
+		`, placeholder), args...)
 	}
+
 	_ = bracketColumn // unused for now, but d
ocuments intent
 	if err != nil {
 		return err
@@ -421,6 +459,10 @@ func generateClassScope
(db *sql.DB, out, scope, region, realmSlug, 
classKey stri
 			list = append(list, obj)
 		}
 
+		if scope == "realm" {
+			applyPercentileBrackets(list, offset, to
tal)
+		}
+
 		title := "Global Player Rankings"
 		if scope == "regional" {
 			title = strings.ToUpper(region) + " Play
er Rankings"
@@ -510,3 +552,21 @@ func buildPlayerLeaderb
oardPage(leaderboard []map[string]any, title
 string, tota
 		},
 	}
 }
+
+func applyPercentileBrackets(entries []map[
string]any, offset int, total int) {
+	if total <= 0 {
+		return
+	}
+	for i, entry := range entries {
+		rank := offset + i + 1
+		if rank <= 0 {
+			continue
+		}
+		bracket := utils.CalculatePercentileBrack
et(rank, total)
+		if bracket == "" {
+			delete(entry, "ranking_percentile")
+		} else {
+			entry["ranking_percentile"] = bracket
+		}
+	}
+}

 

diff --git a/nix/pkgs/ookstats/src/internal/generator/realm_aliases.go b/nix/pkgs/
ookstats/src/internal/generator/realm_aliases.go
new file mode 100644
index 0000000..1bd4ac8
--- /dev/null
+++ b/nix/pkgs/ookstats/src/internal/generator/realm_aliases.go
@@ -0,0 +1,151 @@
+package generator
+
+import "strings"
+
+// mergedRealmParents maps child realm slugs to their parent leaderboard realm pe
r region.
+var mergedRealmParents = map[string]map[string]string{
+	"us": {
+		"nazgrim":   "pagle",
+		"galakras":  "pagle",
+		"raden":     "pagle",
+		"ra-den":    "pagle",
+		"lei-shen":  "pagle",
+		"leishen":   "pagle",
+		"immerseus": "pagle",
+	},
+	"eu": {
+		"shekzeer":  "mirage-raceway",
+		"garalon":   "mirage-raceway",
+		"norushen":  "mirage-raceway",
+		"hoptallus": "mirage-raceway",
+		"hotallus":  "mirage-raceway",
+		"ook-ook":   "everlook",
+		"ookook":    "everlook",
+	},
+}
+
+type realmGroup struct {
+	Parent string
+	Slugs  []string
+}
+
+func normalizeSlug(slug string) string {
+	return strings.ToLower(strings.TrimSpace(slug))
+}
+
+func normalizeRegion(region string) string {
+	return strings.ToLower(strings.TrimSpace(region))
+}
+
+// effectiveRealmSlug returns the parent leaderboard slug for a given region/real
m slug.
+func effectiveRealmSlug(region, slug string) string {
+	normalizedRegion := normalizeRegion(region)
+	normalizedSlug := normalizeSlug(slug)
+	if normalizedSlug == "" {
+		return ""
+	}
+
+	if parents, ok := mergedRealmParents[normalizedRegion]; ok {
+		if parent, ok := parents[normalizedSlug]; ok {
+			return parent
+		}
+	}
+	return normalizedSlug
+}
+
+// realmGroupSlugs returns all realm slugs (parent + children) that belong to the
 same leaderboard group.
+func realmGroupSlugs(region, slug string) []string {
+	normalizedRegion := normalizeRegion(region)
+	parent := effectiveRealmSlug(region, slug)
+	if parent == "" {
+		if s := normalizeSlug(slug); s != "" {
+			return []string{s}
+		}
+		return nil
+	}
+
+	unique := make(map[string]struct{})
+	ordered := make([]string, 0, 4)
+	add := func(value string) {
+		if value == "" {
+			return
+		}
+		if _, exists := unique[value]; exists {
+			return
+		}
+		unique[value] = struct{}{}
+		ordered = append(ordered, value)
+	}
+
+	add(parent)
+	if parents, ok := mergedRealmParents[normalizedRegion]; ok {
+		for child, p := range parents {
+			if p == parent {
+				add(child)
+			}
+		}
+	}
+	add(normalizeSlug(slug))
+
+	return ordered
+}
+
+// groupRealmSlugs groups a list of realm slugs by their effective leaderboard pa
rent.
+func groupRealmSlugs(region string, slugs []string) []realmGroup {
+	normalizedRegion := normalizeRegion(region)
+	index := make(map[string]int)
+	var groups []realmGroup
+
+	for _, slug := range slugs {
+		parent := effectiveRealmSlug(normalizedRegion, slug)
+		if parent == "" {
+			continue
+		}
+		if idx, ok := index[parent]; ok {
+			groups[idx].Slugs = appendUnique(groups[idx].Slugs, normalizeSlug(slug))
+		} else {
+			groups = append(groups, realmGroup{
+				Parent: parent,
+				Slugs:  []string{normalizeSlug(slug)},
+			})
+			index[parent] = len(groups) - 1
+		}
+	}
+
+	for i := range groups {
+		groups[i].Slugs = appendUnique(groups[i].Slugs, groups[i].Parent)
+	}
+
+	return groups
+}
+
+func appendUnique(list []string, value string) []string {
+	if value == "" {
+		return list
+	}
+	for _, existing := range list {
+		if existing == value {
+			return list
+		}
+	}
+	return append(list, value)
+}
+
+func makeSQLPlaceholders(n int) string {
+	if n <= 0 {
+		return ""
+	}
+	parts := make([]string, n)
+	for i := range parts {
+		parts[i] = "?"
+	}
+	return strings.Join(parts, ",")
+}
+
+func stringSliceToInterface(values []string) []interface{} {
+	out := make([]interface{}, len(values))
+	for i, v := range values {
+		out[i] = v
+	}
+	return out
+}


diff --git a/nix/pkgs/ookstats/src/internal/
generator/realm_aliases.go b/nix/pkgs/ooksta
ts/src/internal/generator/realm_aliases.go
new file mode 100644
index 0000000..1bd4ac8
--- /dev/null
+++ b/nix/pkgs/ookstats/src/internal/generat
or/realm_aliases.go
@@ -0,0 +1,151 @@
+package generator
+
+import "strings"
+
+// mergedRealmParents maps child realm slug
s to their parent leaderboard realm per regi
on.
+var mergedRealmParents = map[string]map[str
ing]string{
+	"us": {
+		"nazgrim":   "pagle",
+		"galakras":  "pagle",
+		"raden":     "pagle",
+		"ra-den":    "pagle",
+		"lei-shen":  "pagle",
+		"leishen":   "pagle",
+		"immerseus": "pagle",
+	},
+	"eu": {
+		"shekzeer":  "mirage-raceway",
+		"garalon":   "mirage-raceway",
+		"norushen":  "mirage-raceway",
+		"hoptallus": "mirage-raceway",
+		"hotallus":  "mirage-raceway",
+		"ook-ook":   "everlook",
+		"ookook":    "everlook",
+	},
+}
+
+type realmGroup struct {
+	Parent string
+	Slugs  []string
+}
+
+func normalizeSlug(slug string) string {
+	return strings.ToLower(strings.TrimSpace(s
lug))
+}
+
+func normalizeRegion(region string) string 
{
+	return strings.ToLower(strings.TrimSpace(r
egion))
+}
+
+// effectiveRealmSlug returns the parent le
aderboard slug for a given region/realm slug
.
+func effectiveRealmSlug(region, slug string
) string {
+	normalizedRegion := normalizeRegion(region
)
+	normalizedSlug := normalizeSlug(slug)
+	if normalizedSlug == "" {
+		return ""
+	}
+
+	if parents, ok := mergedRealmParents[norma
lizedRegion]; ok {
+		if parent, ok := parents[normalizedSlug];
 ok {
+			return parent
+		}
+	}
+	return normalizedSlug
+}
+
+// realmGroupSlugs returns all realm slugs 
(parent + children) that belong to the same 
leaderboard group.
+func realmGroupSlugs(region, slug string) [
]string {
+	normalizedRegion := normalizeRegion(region
)
+	parent := effectiveRealmSlug(region, slug)
+	if parent == "" {
+		if s := normalizeSlug(slug); s != "" {
+			return []string{s}
+		}
+		return nil
+	}
+
+	unique := make(map[string]struct{})
+	ordered := make([]string, 0, 4)
+	add := func(value string) {
+		if value == "" {
+			return
+		}
+		if _, exists := unique[value]; exists {
+			return
+		}
+		unique[value] = struct{}{}
+		ordered = append(ordered, value)
+	}
+
+	add(parent)
+	if parents, ok := mergedRealmParents[norma
lizedRegion]; ok {
+		for child, p := range parents {
+			if p == parent {
+				add(child)
+			}
+		}
+	}
+	add(normalizeSlug(slug))
+
+	return ordered
+}
+
+// groupRealmSlugs groups a list of realm s
lugs by their effective leaderboard parent.
+func groupRealmSlugs(region string, slugs [
]string) []realmGroup {
+	normalizedRegion := normalizeRegion(region
)
+	index := make(map[string]int)
+	var groups []realmGroup
+
+	for _, slug := range slugs {
+		parent := effectiveRealmSlug(normalizedRe
gion, slug)
+		if parent == "" {
+			continue
+		}
+		if idx, ok := index[parent]; ok {
+			groups[idx].Slugs = appendUnique(groups[
idx].Slugs, normalizeSlug(slug))
+		} else {
+			groups = append(groups, realmGroup{
+				Parent: parent,
+				Slugs:  []string{normalizeSlug(slug)},
+			})
+			index[parent] = len(groups) - 1
+		}
+	}
+
+	for i := range groups {
+		groups[i].Slugs = appendUnique(groups[i].
Slugs, groups[i].Parent)
+	}
+
+	return groups
+}
+
+func appendUnique(list []string, value stri
ng) []string {
+	if value == "" {
+		return list
+	}
+	for _, existing := range list {
+		if existing == value {
+			return list
+		}
+	}
+	return append(list, value)
+}
+
+func makeSQLPlaceholders(n int) string {
+	if n <= 0 {
+		return ""
+	}
+	parts := make([]string, n)
+	for i := range parts {
+		parts[i] = "?"
+	}
+	return strings.Join(parts, ",")
+}
+
+func stringSliceToInterface(values []string
) []interface{} {
+	out := make([]interface{}, len(values))
+	for i, v := range values {
+		out[i] = v
+	}
+	return out
+}

 
[ BACK TO LOG ]
──────────────────────────────────────────────────────────────────────────────────────
OOKNET
────────────────────────────────────────────────
OOKNET