package common

import (
	"crypto/rand"
	"encoding/json"
	"fmt"
	"math/big"
	"sync"
	"time"

	pb "gac-hkrpg-go/protocol/proto"
)

type GachaType string

const (
	GachaTypeUnknown               GachaType = "Unknown"
	GachaTypeNewbie                GachaType = "Newbie"
	GachaTypeNormal                GachaType = "Normal"
	GachaTypeAvatarUp              GachaType = "AvatarUp"
	GachaTypeWeaponUp              GachaType = "WeaponUp"
	GachaTypeCollaborationAvatarUp GachaType = "CollaborationAvatarUp"
	GachaTypeCollaborationWeaponUp GachaType = "CollaborationWeaponUp"
)

type GachaPityFamily int

const (
	GachaPityFamilyUnknown             GachaPityFamily = 0
	GachaPityFamilyNewbie              GachaPityFamily = 1
	GachaPityFamilyNormal              GachaPityFamily = 2
	GachaPityFamilyAvatarCollaboration GachaPityFamily = 5
	GachaPityFamilyWeaponCollaboration GachaPityFamily = 6
	GachaPityFamilyAvatarUp            GachaPityFamily = 11
	GachaPityFamilyWeaponUp            GachaPityFamily = 12
)

type GachaBanner struct {
	ID           uint32    `json:"id"`
	GachaType    GachaType `json:"gachaType"`
	BeginTime    int64     `json:"beginTime"`
	EndTime      int64     `json:"endTime"`
	RateUpItems5 []uint32  `json:"rateUpItems5"`
	RateUpItems4 []uint32  `json:"rateUpItems4"`
}

type GachaPityState struct {
	PullsSinceFiveStar         uint32 `json:"since_five_star"`
	PullsSinceFourStarOrHigher uint32 `json:"since_four_star"`
	GuaranteedFiveStar         bool   `json:"guaranteed_five_star"`
	GuaranteedFourStar         bool   `json:"guaranteed_four_star"`
	TotalPulls                 uint32 `json:"total_pulls"`
	NewbieFiveStarClaimed      bool   `json:"newbie_five_star_claimed,omitempty"`
}

func (s *GachaPityState) RecordFiveStar() {
	s.PullsSinceFiveStar = 0
	s.PullsSinceFourStarOrHigher = 0
	s.TotalPulls++
}

func (s *GachaPityState) RecordFourStar() {
	s.PullsSinceFiveStar++
	s.PullsSinceFourStarOrHigher = 0
	s.TotalPulls++
}

func (s *GachaPityState) RecordThreeStar() {
	s.PullsSinceFiveStar++
	s.PullsSinceFourStarOrHigher++
	s.TotalPulls++
}

func (b *GachaBanner) IsActiveAt(unixSeconds int64) bool {
	if b.BeginTime > 0 && unixSeconds < b.BeginTime {
		return false
	}
	if b.EndTime > 0 && unixSeconds > b.EndTime {
		return false
	}
	return true
}

func (b *GachaBanner) CostItemID() uint32 {
	switch b.GachaType {
	case GachaTypeNewbie, GachaTypeNormal:
		return 101 // Star Rail Pass
	case GachaTypeAvatarUp, GachaTypeWeaponUp, GachaTypeCollaborationAvatarUp, GachaTypeCollaborationWeaponUp:
		return 102 // Star Rail Special Pass
	default:
		return 0
	}
}

func (b *GachaBanner) IsLightConeBanner() *bool {
	switch b.GachaType {
	case GachaTypeAvatarUp, GachaTypeCollaborationAvatarUp:
		val := false
		return &val
	case GachaTypeWeaponUp, GachaTypeCollaborationWeaponUp:
		val := true
		return &val
	default:
		return nil
	}
}

func (b *GachaBanner) PityFamily() GachaPityFamily {
	switch b.GachaType {
	case GachaTypeNewbie:
		return GachaPityFamilyNewbie
	case GachaTypeNormal:
		return GachaPityFamilyNormal
	case GachaTypeWeaponUp:
		return GachaPityFamilyWeaponUp
	case GachaTypeAvatarUp:
		return GachaPityFamilyAvatarUp
	case GachaTypeCollaborationAvatarUp:
		return GachaPityFamilyAvatarCollaboration
	case GachaTypeCollaborationWeaponUp:
		return GachaPityFamilyWeaponCollaboration
	default:
		return GachaPityFamilyNormal
	}
}

func (b *GachaBanner) ToProtoInfo() *pb.GachaInfo {
	info := &pb.GachaInfo{
		GachaId:    b.ID,
		DetailUrl:  "",
		HistoryUrl: "",
		BeginTime:  b.BeginTime,
		EndTime:    b.EndTime,
	}
	if info.EndTime == 0 {
		info.EndTime = 4102416000
	}

	// 4.6 client wire mapping:
	// Wire #13 (ONIHOMCELJK) = rateUpItems5 (featured 5-star character/lightcone)
	// Wire #10 (PrizeItemList) = rateUpItems4 + rateUpItems5 distinct (detail / capsules)
	info.ONIHOMCELJK = append([]uint32(nil), b.RateUpItems5...)

	seen := make(map[uint32]bool)
	for _, id := range append(b.RateUpItems4, b.RateUpItems5...) {
		if !seen[id] && id > 0 {
			seen[id] = true
			info.PrizeItemList = append(info.PrizeItemList, id)
		}
	}

	if b.ID == 1001 {
		goldAvatars := []uint32{1003, 1004, 1101, 1107, 1104, 1209, 1211}
		ceilingAvatars := make([]*pb.GachaCeilingAvatar, 0, len(goldAvatars))
		for _, aid := range goldAvatars {
			ceilingAvatars = append(ceilingAvatars, &pb.GachaCeilingAvatar{AvatarId: aid})
		}
		info.GachaCeiling = &pb.GachaCeiling{
			IsClaimed:  true,
			AvatarList: ceilingAvatars,
		}
	} else if b.GachaType == GachaTypeAvatarUp || b.GachaType == GachaTypeCollaborationAvatarUp {
		info.ItemDetailList = []uint32{11}
	}

	return info
}

var (
	bannersMu              sync.RWMutex
	loadedBanners          []GachaBanner
	loadedUnlockAllBanners []GachaBanner
	bannersInitialized     bool
)

func parseBannersRaw(raw []byte) ([]GachaBanner, error) {
	var list []GachaBanner
	if err := json.Unmarshal(raw, &list); err == nil && len(list) > 0 {
		return list, nil
	}
	var wrapper struct {
		Banners      []GachaBanner `json:"Banners"`
		BannersLower []GachaBanner `json:"banners"`
	}
	if err := json.Unmarshal(raw, &wrapper); err == nil {
		if len(wrapper.Banners) > 0 {
			return wrapper.Banners, nil
		}
		if len(wrapper.BannersLower) > 0 {
			return wrapper.BannersLower, nil
		}
	}
	var rawList []json.RawMessage
	if err := json.Unmarshal(raw, &rawList); err == nil {
		var banners []GachaBanner
		for _, item := range rawList {
			var b GachaBanner
			if err := json.Unmarshal(item, &b); err == nil && b.ID > 0 {
				banners = append(banners, b)
			}
		}
		if len(banners) > 0 {
			return banners, nil
		}
	}
	return nil, fmt.Errorf("no valid banners parsed")
}

func LoadBannersConfig() error {
	bannersMu.Lock()
	defer bannersMu.Unlock()

	rawBase, err := ReadResourceFile("resources/Banners.json")
	if err != nil {
		return fmt.Errorf("failed to read resources/Banners.json: %w", err)
	}
	baseList, err := parseBannersRaw(rawBase)
	if err != nil {
		return fmt.Errorf("failed to parse resources/Banners.json: %w", err)
	}

	var unlockList []GachaBanner
	rawUnlock, err := ReadResourceFile("resources/BannersUnlockAll.json")
	if err == nil {
		if list, err := parseBannersRaw(rawUnlock); err == nil {
			unlockList = list
		}
	}

	loadedBanners = baseList
	loadedUnlockAllBanners = unlockList
	bannersInitialized = true
	return nil
}

func ReloadBanners() error {
	return LoadBannersConfig()
}

func ensureBannersLoaded() {
	bannersMu.RLock()
	init := bannersInitialized
	bannersMu.RUnlock()
	if !init {
		_ = LoadBannersConfig()
	}
}

// GetVisibleBanners returns active banners according to the player's WarpUnlockMode:
// 0 = only active banners from Banners.json
// 1 = all banners (Banners.json + BannersUnlockAll.json)
// 2 = character banners (Banners.json + character banners from BannersUnlockAll.json)
// 3 = lightcone banners (Banners.json + lightcone banners from BannersUnlockAll.json)
func GetVisibleBanners(mode int) []GachaBanner {
	ensureBannersLoaded()

	bannersMu.RLock()
	defer bannersMu.RUnlock()

	now := time.Now().Unix()
	if mode == 0 {
		out := make([]GachaBanner, 0, len(loadedBanners))
		for _, b := range loadedBanners {
			if b.IsActiveAt(now) {
				out = append(out, b)
			}
		}
		return out
	}

	out := make([]GachaBanner, 0, len(loadedBanners)+len(loadedUnlockAllBanners))
	ids := make(map[uint32]bool)
	featured := make(map[[2]uint32]bool)

	for _, b := range loadedBanners {
		if b.IsActiveAt(now) {
			lc := b.IsLightConeBanner()
			if mode == 2 && lc != nil && *lc {
				continue // character only
			}
			if mode == 3 && lc != nil && !*lc {
				continue // lightcone only
			}
			out = append(out, b)
			ids[b.ID] = true
			if lc != nil {
				var lcFlag uint32
				if *lc {
					lcFlag = 1
				}
				for _, item := range b.RateUpItems5 {
					featured[[2]uint32{lcFlag, item}] = true
				}
			}
		}
	}

	for _, b := range loadedUnlockAllBanners {
		lc := b.IsLightConeBanner()
		if lc == nil {
			continue
		}
		if mode == 2 && *lc {
			continue // character only
		}
		if mode == 3 && !*lc {
			continue // lightcone only
		}
		if len(b.RateUpItems5) == 0 {
			continue
		}
		var lcFlag uint32
		if *lc {
			lcFlag = 1
		}
		if featured[[2]uint32{lcFlag, b.RateUpItems5[0]}] {
			continue // already featured by active banner
		}
		if ids[b.ID] {
			continue
		}
		if !b.IsActiveAt(now) {
			continue
		}
		ids[b.ID] = true
		out = append(out, b)
	}

	return out
}

func FindGachaBanner(gachaID uint32, mode int) *GachaBanner {
	visible := GetVisibleBanners(mode)
	for i := range visible {
		if visible[i].ID == gachaID {
			return &visible[i]
		}
	}
	// Fallback to any loaded banner so an in-flight pull is never rejected
	bannersMu.RLock()
	defer bannersMu.RUnlock()
	for i := range loadedBanners {
		if loadedBanners[i].ID == gachaID {
			return &loadedBanners[i]
		}
	}
	for i := range loadedUnlockAllBanners {
		if loadedUnlockAllBanners[i].ID == gachaID {
			return &loadedUnlockAllBanners[i]
		}
	}
	return nil
}

// ---------------------------------------------------------------------------
// Gacha Pools & Probabilities
// ---------------------------------------------------------------------------

var (
	StandardGoldAvatars = []uint32{1003, 1004, 1101, 1107, 1104, 1209, 1211}
	StandardGoldWeapons = []uint32{23000, 23002, 23003, 23004, 23005, 23012, 23013}
)

func FiveStarChance90(pullNumber uint32) float64 {
	if pullNumber >= 90 {
		return 1.0
	}
	if pullNumber >= 76 {
		return 0.324
	}
	return 0.006
}

func FiveStarChance80(pullNumber uint32) float64 {
	if pullNumber >= 80 {
		return 1.0
	}
	if pullNumber >= 66 {
		return 0.219633
	}
	return 0.008
}

func FiveStarChanceNewbie(pullNumber uint32) float64 {
	if pullNumber >= 50 {
		return 1.0
	}
	return 0.006
}

func cryptoRandFloat() float64 {
	n, err := rand.Int(rand.Reader, big.NewInt(1000000))
	if err != nil {
		return 0.5
	}
	return float64(n.Int64()) / 1000000.0
}

func cryptoPickOne(list []uint32) uint32 {
	if len(list) == 0 {
		return 0
	}
	n, err := rand.Int(rand.Reader, big.NewInt(int64(len(list))))
	if err != nil {
		return list[0]
	}
	return list[n.Int64()]
}

func withoutItems(source, excluded []uint32) []uint32 {
	exMap := make(map[uint32]bool, len(excluded))
	for _, id := range excluded {
		exMap[id] = true
	}
	out := make([]uint32, 0, len(source))
	for _, id := range source {
		if !exMap[id] {
			out = append(out, id)
		}
	}
	return out
}

func pickByCategory(avatars, weapons []uint32) uint32 {
	if len(avatars) == 0 {
		return cryptoPickOne(weapons)
	}
	if len(weapons) == 0 {
		return cryptoPickOne(avatars)
	}
	if cryptoRandFloat() < 0.5 {
		return cryptoPickOne(avatars)
	}
	return cryptoPickOne(weapons)
}

func loadGachaItemCatalogs() (purpleAvatars, purpleWeapons, blueWeapons []uint32, err error) {
	// 4-star avatars from AvatarConfig.json
	rawAv, err := ReadResourceFile("resources/AvatarConfig.json")
	if err == nil {
		var doc struct {
			Avatars []struct {
				AvatarID uint32 `json:"AvatarID"`
				Rarity   string `json:"Rarity"`
				MaxRank  uint32 `json:"MaxRank"`
			} `json:"avatar_config"`
		}
		if json.Unmarshal(rawAv, &doc) == nil {
			for _, a := range doc.Avatars {
				if a.Rarity == "CombatPowerAvatarRarityType4" && a.MaxRank > 0 && a.AvatarID < 8000 {
					purpleAvatars = append(purpleAvatars, a.AvatarID)
				}
			}
		}
	}
	if len(purpleAvatars) == 0 {
		purpleAvatars = []uint32{
			1001, 1002, 1008, 1009, 1013, 1103, 1105, 1106, 1108, 1109,
			1110, 1111, 1201, 1202, 1206, 1207, 1210, 1214, 1215, 1223,
			1224, 1301, 1312,
		}
	}

	// Lightcones from GachaLootCatalog.json
	rawLoot, err := ReadResourceFile("resources/GachaLootCatalog.json")
	if err == nil {
		var doc struct {
			Lightcones []struct {
				ID     uint32 `json:"id"`
				Rarity uint32 `json:"rarity"`
			} `json:"lightcones"`
		}
		bpCones := map[uint32]bool{
			21028: true, 21029: true, 21030: true, 21031: true, 21032: true, 21033: true, 21034: true,
			21052: true, 21053: true, 21055: true, 21056: true, 21057: true, 21058: true, 21060: true,
			21061: true, 21062: true, 21065: true,
		}
		if json.Unmarshal(rawLoot, &doc) == nil {
			for _, c := range doc.Lightcones {
				if c.Rarity == 3 {
					blueWeapons = append(blueWeapons, c.ID)
				} else if c.Rarity == 4 && !bpCones[c.ID] && !(c.ID >= 22000 && c.ID < 23000) {
					purpleWeapons = append(purpleWeapons, c.ID)
				}
			}
		}
	}
	if len(blueWeapons) == 0 {
		blueWeapons = []uint32{20000, 20001, 20002, 20003, 20004, 20005, 20006, 20007, 20008, 20009}
	}
	if len(purpleWeapons) == 0 {
		purpleWeapons = []uint32{21000, 21001, 21002, 21003, 21004, 21005, 21006, 21007, 21008, 21009}
	}
	return purpleAvatars, purpleWeapons, blueWeapons, nil
}

func (b *GachaBanner) ResolveFiveStarItem(state *GachaPityState, standardAvatars, standardWeapons []uint32) uint32 {
	featured := b.RateUpItems5
	switch b.GachaType {
	case GachaTypeNewbie:
		return cryptoPickOne(standardAvatars)
	case GachaTypeWeaponUp, GachaTypeCollaborationWeaponUp:
		return resolveFeaturedOrStandard(state, featured, standardWeapons, 0.75)
	case GachaTypeAvatarUp, GachaTypeCollaborationAvatarUp:
		return resolveFeaturedOrStandard(state, featured, standardAvatars, 0.50)
	default:
		return pickByCategory(standardAvatars, standardWeapons)
	}
}

func resolveFeaturedOrStandard(state *GachaPityState, featured, standard []uint32, featuredChance float64) uint32 {
	if len(featured) == 0 {
		return cryptoPickOne(standard)
	}
	if state.GuaranteedFiveStar || cryptoRandFloat() < featuredChance || len(standard) == 0 {
		state.GuaranteedFiveStar = false
		return cryptoPickOne(featured)
	}
	state.GuaranteedFiveStar = true
	pool := withoutItems(standard, featured)
	if len(pool) == 0 {
		pool = standard
	}
	return cryptoPickOne(pool)
}

func (b *GachaBanner) ResolveFourStarItem(state *GachaPityState, purpleAvatars, purpleWeapons []uint32) uint32 {
	isWeaponPool := b.GachaType == GachaTypeWeaponUp || b.GachaType == GachaTypeCollaborationWeaponUp
	featuredChance := 0.50
	if isWeaponPool {
		featuredChance = 0.75
	}

	avMap := make(map[uint32]bool, len(purpleAvatars))
	for _, id := range purpleAvatars {
		avMap[id] = true
	}
	wpMap := make(map[uint32]bool, len(purpleWeapons))
	for _, id := range purpleWeapons {
		wpMap[id] = true
	}

	var featured []uint32
	for _, id := range b.RateUpItems4 {
		if isWeaponPool {
			if wpMap[id] {
				featured = append(featured, id)
			}
		} else {
			if avMap[id] || wpMap[id] {
				featured = append(featured, id)
			}
		}
	}

	allStandard := append(append([]uint32(nil), purpleAvatars...), purpleWeapons...)
	if len(featured) == 0 {
		if isWeaponPool {
			return cryptoPickOne(purpleWeapons)
		}
		return pickByCategory(purpleAvatars, purpleWeapons)
	}

	standard := withoutItems(allStandard, featured)
	if state.GuaranteedFourStar || cryptoRandFloat() < featuredChance || len(standard) == 0 {
		state.GuaranteedFourStar = false
		return cryptoPickOne(featured)
	}
	state.GuaranteedFourStar = true
	return cryptoPickOne(standard)
}

// ---------------------------------------------------------------------------
// Gacha Pull Execution & Duplicate Granting
// ---------------------------------------------------------------------------

type GachaDrawItemResult struct {
	ItemID           uint32
	Rarity           uint32 // 3, 4, 5
	IsAvatar         bool
	IsNew            bool
	Lightcone        *Lightcone
	TransferItemList []*pb.Item
	TokenItemList    []*pb.Item
}

type GachaDrawBatchResult struct {
	Items     []GachaDrawItemResult
	PityState GachaPityState
}

func (b *GachaBanner) RollSingle(state *GachaPityState, purpleAvatars, purpleWeapons, blueWeapons []uint32) (uint32, uint32) {
	pullNumber5 := state.PullsSinceFiveStar + 1
	pullNumber4 := state.PullsSinceFourStarOrHigher + 1

	var fiveStarProb float64
	var fourStarProb float64 = 0.051

	switch b.GachaType {
	case GachaTypeNewbie:
		fiveStarProb = FiveStarChanceNewbie(pullNumber5)
	case GachaTypeWeaponUp, GachaTypeCollaborationWeaponUp:
		fiveStarProb = FiveStarChance80(pullNumber5)
		fourStarProb = 0.066
	default:
		fiveStarProb = FiveStarChance90(pullNumber5)
	}

	if cryptoRandFloat() < fiveStarProb {
		item := b.ResolveFiveStarItem(state, StandardGoldAvatars, StandardGoldWeapons)
		state.RecordFiveStar()
		if b.GachaType == GachaTypeNewbie {
			state.NewbieFiveStarClaimed = true
		}
		return item, 5
	}

	if pullNumber4 >= 10 || cryptoRandFloat() < fourStarProb {
		item := b.ResolveFourStarItem(state, purpleAvatars, purpleWeapons)
		state.RecordFourStar()
		return item, 4
	}

	item := cryptoPickOne(blueWeapons)
	state.RecordThreeStar()
	return item, 3
}

// PerformGachaRolls executes `times` pulls and atomically updates freesr-data.json
func PerformGachaRolls(banner *GachaBanner, times uint32, player *FreesrData) (*GachaDrawBatchResult, error) {
	if times != 1 && times != 10 {
		return nil, fmt.Errorf("invalid gacha times %d", times)
	}

	purpleAvatars, purpleWeapons, blueWeapons, err := loadGachaItemCatalogs()
	if err != nil {
		return nil, err
	}

	family := banner.PityFamily()
	familyKey := fmt.Sprintf("%d", family)

	persistentWriteMu.Lock()
	defer persistentWriteMu.Unlock()
	unlock, err := lockPersistentFile()
	if err != nil {
		return nil, err
	}
	defer unlock()

	root, err := readLimitedRoot()
	if err != nil {
		return nil, err
	}

	// Load pity states
	pityMap := make(map[string]GachaPityState)
	if raw, ok := root["gacha_pity"]; ok && len(raw) > 0 {
		_ = json.Unmarshal(raw, &pityMap)
	}
	pityState := pityMap[familyKey]

	// Migrate from legacy gacha_limited if empty and AvatarUp
	if family == GachaPityFamilyAvatarUp && pityState.TotalPulls == 0 {
		if leg, err := decodeLimitedPity(root); err == nil && leg.TotalDraws > 0 {
			pityState.PullsSinceFiveStar = leg.SinceFiveStar
			pityState.PullsSinceFourStarOrHigher = leg.SinceFourStar
			pityState.TotalPulls = uint32(leg.TotalDraws)
		}
	}

	// Load materials
	materials := make(map[uint32]uint32)
	if raw, ok := root["materials"]; ok {
		_ = json.Unmarshal(raw, &materials)
	}
	if player.Materials == nil {
		player.Materials = make(map[uint32]uint32)
	}
	for k, v := range materials {
		player.Materials[k] = v
	}

	// Load avatars
	var avatarDoc map[uint32]json.RawMessage
	if raw, ok := root["avatars"]; ok {
		_ = json.Unmarshal(raw, &avatarDoc)
	}
	if avatarDoc == nil {
		avatarDoc = make(map[uint32]json.RawMessage)
	}

	// Load lightcones
	var coneDoc []json.RawMessage
	if raw, ok := root["lightcones"]; ok {
		_ = json.Unmarshal(raw, &coneDoc)
	}
	var maxUID uint32
	for _, raw := range coneDoc {
		var lc Lightcone
		if json.Unmarshal(raw, &lc) == nil && lc.InternalUID > maxUID {
			maxUID = lc.InternalUID
		}
	}
	for _, lc := range player.Lightcones {
		if lc.InternalUID > maxUID {
			maxUID = lc.InternalUID
		}
	}

	results := make([]GachaDrawItemResult, 0, times)

	for i := uint32(0); i < times; i++ {
		itemID, rarity := banner.RollSingle(&pityState, purpleAvatars, purpleWeapons, blueWeapons)
		if itemID == 0 {
			itemID = cryptoPickOne(blueWeapons)
			rarity = 3
		}

		res := GachaDrawItemResult{
			ItemID: itemID,
			Rarity: rarity,
		}

		isAvatar := itemID < 20000

		if isAvatar {
			res.IsAvatar = true
			existingAvatar, owned := player.Avatars[itemID]
			if !owned || existingAvatar == nil {
				// First acquisition
				res.IsNew = true
				newAv := &AvatarJson{
					AvatarID:   itemID,
					Level:      1,
					Promotion:  0,
					Techniques: []uint32{},
					Data: AvatarData{
						Rank:               0,
						Skills:             make(map[uint32]uint32),
						SkillsByAnchorType: make(map[uint32]uint32),
					},
				}
				player.Avatars[itemID] = newAv
				raw, _ := json.Marshal(newAv)
				avatarDoc[itemID] = raw
			} else {
				// Duplicate conversion: Eidolon item + Starlight (252)
				res.IsNew = false
				rankUpItemID := itemID + 10000
				curRank := existingAvatar.Data.Rank + materials[rankUpItemID]
				var starlight uint32
				if curRank < 6 {
					materials[rankUpItemID]++
					player.Materials[rankUpItemID] = materials[rankUpItemID]
					res.TransferItemList = append(res.TransferItemList, &pb.Item{
						ItemId: rankUpItemID,
						Num:    1,
					})
					if rarity == 5 {
						starlight = 40
					} else {
						starlight = 8
					}
				} else {
					if rarity == 5 {
						starlight = 100
					} else {
						starlight = 20
					}
				}
				if starlight > 0 {
					materials[252] += starlight
					player.Materials[252] = materials[252]
					res.TokenItemList = append(res.TokenItemList, &pb.Item{
						ItemId: 252,
						Num:    starlight,
					})
				}
			}
		} else {
			// Lightcone
			res.IsAvatar = false
			maxUID++
			lc := Lightcone{
				ItemID:      itemID,
				InternalUID: maxUID,
				Level:       1,
				Rank:        1,
				Promotion:   0,
			}
			player.Lightcones = append(player.Lightcones, lc)
			raw, _ := json.Marshal(lc)
			coneDoc = append(coneDoc, raw)
			res.Lightcone = &lc

			var embers, starlight uint32
			if rarity == 5 {
				starlight = 40
			} else if rarity == 4 {
				starlight = 8
			} else {
				embers = 20
			}

			if embers > 0 {
				materials[251] += embers
				player.Materials[251] = materials[251]
				res.TokenItemList = append(res.TokenItemList, &pb.Item{
					ItemId: 251,
					Num:    embers,
				})
			}
			if starlight > 0 {
				materials[252] += starlight
				player.Materials[252] = materials[252]
				res.TokenItemList = append(res.TokenItemList, &pb.Item{
					ItemId: 252,
					Num:    starlight,
				})
			}
		}

		results = append(results, res)
	}

	// Commit state
	pityMap[familyKey] = pityState
	root["gacha_pity"], err = json.Marshal(pityMap)
	if err != nil {
		return nil, err
	}

	// Mirror legacy pity for AvatarUp
	if family == GachaPityFamilyAvatarUp {
		legacyPity := LimitedGachaPity{
			SinceFiveStar: pityState.PullsSinceFiveStar,
			SinceFourStar: pityState.PullsSinceFourStarOrHigher,
			TotalDraws:    uint64(pityState.TotalPulls),
		}
		root["gacha_limited"], _ = json.Marshal(legacyPity)
	}

	root["materials"], err = json.Marshal(materials)
	if err != nil {
		return nil, err
	}
	root["avatars"], err = json.Marshal(avatarDoc)
	if err != nil {
		return nil, err
	}
	root["lightcones"], err = json.Marshal(coneDoc)
	if err != nil {
		return nil, err
	}

	if err := writeJSONAtomic("freesr-data.json", root); err != nil {
		return nil, err
	}

	return &GachaDrawBatchResult{
		Items:     results,
		PityState: pityState,
	}, nil
}