notarius/internal/modules/dnd/register/merge.go

package register

import (
	"slices"

	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
)

func appendSpellLists(values []dnd.SpellList) (dnd.SpellList, error) {
	count := 0
	present := false
	for _, value := range values {
		if value.SpellCasts != nil {
			present = true
		}
		count += len(value.SpellCasts)
	}
	if !present {
		return dnd.SpellList{}, nil
	}
	combined := dnd.SpellList{SpellCasts: make([]dnd.SpellCast, 0, count)}
	for _, value := range values {
		for _, spellCast := range value.SpellCasts {
			combined.SpellCasts = append(combined.SpellCasts, cloneSpellCast(spellCast))
		}
	}
	return combined, nil
}

func appendNPCLists(values []dnd.NPCList) (dnd.NPCList, error) {
	count := 0
	present := false
	for _, value := range values {
		if value.NPCs != nil {
			present = true
		}
		count += len(value.NPCs)
	}
	if !present {
		return dnd.NPCList{}, nil
	}
	combined := dnd.NPCList{NPCs: make([]dnd.NPC, 0, count)}
	for _, value := range values {
		for _, npc := range value.NPCs {
			combined.NPCs = append(combined.NPCs, cloneNPC(npc))
		}
	}
	return combined, nil
}

func appendCombatTurnLists(values []dnd.CombatTurnList) (dnd.CombatTurnList, error) {
	count := 0
	present := false
	for _, value := range values {
		if value.CombatTurns != nil {
			present = true
		}
		count += len(value.CombatTurns)
	}
	if !present {
		return dnd.CombatTurnList{}, nil
	}
	combined := dnd.CombatTurnList{CombatTurns: make([]dnd.CombatTurn, 0, count)}
	for _, value := range values {
		for _, turn := range value.CombatTurns {
			combined.CombatTurns = append(combined.CombatTurns, cloneCombatTurn(turn))
		}
	}
	return combined, nil
}

func appendEnemyEventLists(values []dnd.EnemyEventList) (dnd.EnemyEventList, error) {
	count := 0
	present := false
	for _, value := range values {
		if value.Events != nil {
			present = true
		}
		count += len(value.Events)
	}
	if !present {
		return dnd.EnemyEventList{}, nil
	}
	combined := dnd.EnemyEventList{Events: make([]dnd.EnemyEvent, 0, count)}
	for _, value := range values {
		for _, event := range value.Events {
			combined.Events = append(combined.Events, cloneEnemyEvent(event))
		}
	}
	return combined, nil
}

func appendItemEventLists(values []dnd.ItemEventList) (dnd.ItemEventList, error) {
	count := 0
	present := false
	for _, value := range values {
		if value.Events != nil {
			present = true
		}
		count += len(value.Events)
	}
	if !present {
		return dnd.ItemEventList{}, nil
	}
	combined := dnd.ItemEventList{Events: make([]dnd.ItemEvent, 0, count)}
	for _, value := range values {
		for _, event := range value.Events {
			combined.Events = append(combined.Events, cloneItemEvent(event))
		}
	}
	return combined, nil
}

func appendNPCInteractionLists(values []dnd.NPCInteractionList) (dnd.NPCInteractionList, error) {
	count := 0
	present := false
	for _, value := range values {
		if value.Interactions != nil {
			present = true
		}
		count += len(value.Interactions)
	}
	if !present {
		return dnd.NPCInteractionList{}, nil
	}
	combined := dnd.NPCInteractionList{Interactions: make([]dnd.NPCInteraction, 0, count)}
	for _, value := range values {
		for _, interaction := range value.Interactions {
			combined.Interactions = append(combined.Interactions, cloneNPCInteraction(interaction))
		}
	}
	return combined, nil
}

func appendSceneDescriptionLists(values []dnd.SceneDescriptionList) (dnd.SceneDescriptionList, error) {
	count := 0
	present := false
	for _, value := range values {
		if value.Scenes != nil {
			present = true
		}
		count += len(value.Scenes)
	}
	if !present {
		return dnd.SceneDescriptionList{}, nil
	}
	combined := dnd.SceneDescriptionList{Scenes: make([]dnd.SceneDescription, 0, count)}
	for _, value := range values {
		combined.Scenes = append(combined.Scenes, value.Scenes...)
	}
	return combined, nil
}

func cloneCombatTurn(value dnd.CombatTurn) dnd.CombatTurn {
	clone := value
	clone.SourceRefs = cloneSourceRefs(value.SourceRefs)
	return clone
}

func cloneEnemyEvent(value dnd.EnemyEvent) dnd.EnemyEvent {
	clone := value
	clone.SourceRefs = cloneSourceRefs(value.SourceRefs)
	return clone
}

func cloneItemEvent(value dnd.ItemEvent) dnd.ItemEvent {
	clone := value
	if value.Quantity != nil {
		quantity := *value.Quantity
		clone.Quantity = &quantity
	}
	clone.SourceRefs = cloneSourceRefs(value.SourceRefs)
	return clone
}

func cloneSpellCast(value dnd.SpellCast) dnd.SpellCast {
	clone := value
	clone.SourceRefs = cloneSourceRefs(value.SourceRefs)
	return clone
}

func cloneNPC(value dnd.NPC) dnd.NPC {
	clone := value
	clone.SourceRefs = cloneSourceRefs(value.SourceRefs)
	return clone
}

func cloneNPCInteraction(value dnd.NPCInteraction) dnd.NPCInteraction {
	clone := value
	clone.SourceRefs = cloneSourceRefs(value.SourceRefs)
	return clone
}

func cloneSourceRefs(refs []source.SourceRef) []source.SourceRef {
	return slices.Clone(refs)
}