bdgrp_go/utils/helper.go

package utils

import "fmt"

func ComputeMusicClearInfo(musicScore map[string]any) map[string]any {
	difficulties := []string{"easy", "normal", "hard", "expert", "special"}
	type stat struct{ cleared, fullCombo, allPerfect int }
	stats := map[string]*stat{}
	for _, d := range difficulties {
		stats[d] = &stat{}
	}

	for _, v := range musicScore {
		data := v.(map[string]any)
		entries, ok := data["entries"].([]any)
		if !ok {
			continue
		}
		for _, e := range entries {
			entry := e.(map[string]any)
			diff, _ := entry["musicDifficulty"].(string)
			clearStatus, _ := entry["clearStatus"].(string)
			if s, ok := stats[diff]; ok {
				s.cleared++
				if clearStatus == "full_combo" {
					s.fullCombo++
				}
				if clearStatus == "all_perfect" {
					s.allPerfect++
				}
			}
		}
	}

	result := map[string]any{}
	for _, d := range difficulties {
		result[d] = map[string]any{
			"clearedMusicCount":    stats[d].cleared,
			"fullComboMusicCount":  stats[d].fullCombo,
			"allPerfectMusicCount": stats[d].allPerfect,
		}
	}
	return map[string]any{"entries": result}
}

func ComputeMusicClearCountInfo(musicScore map[string]any) map[string]any {
	result := map[string]any{}
	for id, v := range musicScore {
		data := v.(map[string]any)
		entries, ok := data["entries"].([]any)
		if ok && len(entries) > 0 {
			result[id] = len(entries)
		}
	}
	return map[string]any{"entries": result}
}

func BuildUserSituations(userid string, master map[string]any, user map[string]any) []any {
	situationMap := master["masterCharacterSituationMap"].(map[string]any)["entries"].(map[string]any)

	var result []any
	for _, v := range situationMap {
		card := v.(map[string]any)
		releasedAt := fmt.Sprintf("%v", card["releasedAt"])
		if releasedAt == "4128645600000" || releasedAt == "4131237600000" {
			continue
		}

		// maxLevel
		maxLevel := 0
		if paramMap, ok := card["parameterMap"].(map[string]any); ok {
			for k := range paramMap {
				var level int
				fmt.Sscanf(k, "%d", &level)
				if level > maxLevel {
					maxLevel = level
				}
			}
		}

		rarity := 0
		if r, ok := card["rarity"].(float64); ok {
			rarity = int(r)
		}
		hasTraining := rarity >= 3

		var ep0, ep1 map[string]any
		if eps, ok := card["episodes"].(map[string]any); ok {
			if entries, ok := eps["entries"].([]any); ok {
				if len(entries) > 0 {
					ep0, _ = entries[0].(map[string]any)
				}
				if len(entries) > 1 {
					ep1, _ = entries[1].(map[string]any)
				}
			}
		}

		illust := "normal"
		if hasTraining {
			illust = "after_training"
		}
		if user != nil {
			if si, ok := user["situationIllust"].(map[string]any); ok {
				if v, ok := si[fmt.Sprintf("%v", card["situationId"])]; ok {
					illust = fmt.Sprintf("%v", v)
				}
			}
		}

		trainingStatus := "not_doing"
		if hasTraining {
			trainingStatus = "done"
		}

		sit := map[string]any{
			"userId":         userid,
			"situationId":    card["situationId"],
			"level":          maxLevel,
			"exp":            0,
			"createdAt":      card["releasedAt"],
			"addExp":         0,
			"trainingStatus": trainingStatus,
			"duplicateCount": 0,
			"illust":         illust,
			"skillExp":       0,
			"skillLevel":     5,
			"limitBreakRank": 4,
		}

		if hasTraining {
			t, _ := card["training"].(map[string]any)
			perf, tech, vis := 0.0, 0.0, 0.0
			if t != nil {
				perf, _ = t["trainingPerformance"].(float64)
				tech, _ = t["trainingTechnique"].(float64)
				vis, _ = t["trainingVisual"].(float64)
			}
			ep0Perf, ep0Tech, ep0Vis := 0.0, 0.0, 0.0
			ep1Perf, ep1Tech, ep1Vis := 0.0, 0.0, 0.0
			if ep0 != nil {
				ep0Perf, _ = ep0["appendPerformance"].(float64)
				ep0Tech, _ = ep0["appendTechnique"].(float64)
				ep0Vis, _ = ep0["appendVisual"].(float64)
			}
			if ep1 != nil {
				ep1Perf, _ = ep1["appendPerformance"].(float64)
				ep1Tech, _ = ep1["appendTechnique"].(float64)
				ep1Vis, _ = ep1["appendVisual"].(float64)
			}

			sit["userAppendParameter"] = map[string]any{
				"userId":                        userid,
				"situationId":                   card["situationId"],
				"performance":                   perf,
				"technique":                     tech,
				"visual":                        vis,
				"characterPotentialPerformance": 30,
				"characterPotentialTechnique":   30,
				"characterPotentialVisual":      30,
				"characterBonusPerformance":     30 + ep0Perf + ep1Perf,
				"characterBonusTechnique":       30 + ep0Tech + ep1Tech,
				"characterBonusVisual":          30 + ep0Vis + ep1Vis,
			}
		}

		result = append(result, sit)
	}
	return result
}

func BuildUserProfileDegree(userid string, user map[string]any) map[string]any {
	degree := user["degree"].([]any)
	result := map[string]any{
		"first": map[string]any{
			"userId":            userid,
			"profileDegreeType": "first",
			"degreeId":          degree[0],
		},
	}
	if len(degree) > 1 && degree[1] != nil {
		result["second"] = map[string]any{
			"userId":            userid,
			"profileDegreeType": "second",
			"degreeId":          degree[1],
		}
	}
	return result
}

func BuildCharacterRankMap() map[string]any {
	entries := map[string]any{}
	for i := 1; i <= 40; i++ {
		entries[fmt.Sprintf("%d", i)] = map[string]any{
			"rank": 100, "exp": 0, "addExp": 0,
			"nextExp": 0, "totalExp": 0, "releasedPotentialLevel": 50,
		}
	}
	return map[string]any{"entries": entries}
}

func GetScoreRank(score float64, difficultyMaster map[string]any) string {
	if difficultyMaster == nil {
		return "c"
	}
	get := func(key string) float64 {
		v, _ := difficultyMaster[key].(float64)
		return v
	}
	switch {
	case score >= get("scoreSS"):
		return "ss"
	case score >= get("scoreS"):
		return "s"
	case score >= get("scoreA"):
		return "a"
	case score >= get("scoreB"):
		return "b"
	default:
		return "c"
	}
}