106 lines
3.3 KiB
Go
106 lines
3.3 KiB
Go
package itemoccurrences
|
|
|
|
import (
|
|
"sort"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
|
|
itemregistry "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/items/registry"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/shared"
|
|
)
|
|
|
|
type orderedItemOccurrenceResponse struct {
|
|
value itemOccurrenceResponse
|
|
earliest int
|
|
hasEvidence bool
|
|
}
|
|
|
|
func canonicalizeResponse(response *extractionResponse, order shared.SourceRefOrder, sourceID string) {
|
|
if response == nil {
|
|
return
|
|
}
|
|
ordered := make([]orderedItemOccurrenceResponse, len(response.Occurrences))
|
|
for index := range response.Occurrences {
|
|
earliest, hasEvidence := canonicalizeItemOccurrence(&response.Occurrences[index], order, sourceID)
|
|
ordered[index] = orderedItemOccurrenceResponse{
|
|
value: response.Occurrences[index],
|
|
earliest: earliest,
|
|
hasEvidence: hasEvidence,
|
|
}
|
|
}
|
|
sort.SliceStable(ordered, func(left, right int) bool {
|
|
if ordered[left].hasEvidence != ordered[right].hasEvidence {
|
|
return ordered[left].hasEvidence
|
|
}
|
|
if !ordered[left].hasEvidence {
|
|
return false
|
|
}
|
|
return ordered[left].earliest < ordered[right].earliest
|
|
})
|
|
for index := range ordered {
|
|
response.Occurrences[index] = ordered[index].value
|
|
}
|
|
}
|
|
|
|
func canonicalizeItemOccurrence(occurrence *itemOccurrenceResponse, order shared.SourceRefOrder, sourceID string) (int, bool) {
|
|
if occurrence == nil {
|
|
return 0, false
|
|
}
|
|
refs := order.Canonicalize(itemOccurrenceSourceRefs(occurrence.SourceRefs, sourceID))
|
|
occurrence.SourceRefs = itemOccurrenceResponseRefs(refs)
|
|
return order.EarliestValid(refs)
|
|
}
|
|
|
|
func canonicalItemOccurrenceList(response extractionResponse, sourceID string, registry *itemregistry.Registry) dnd.ItemOccurrenceList {
|
|
if response.Occurrences == nil {
|
|
return dnd.ItemOccurrenceList{}
|
|
}
|
|
occurrences := make([]dnd.ItemOccurrence, 0, len(response.Occurrences))
|
|
for _, occurrence := range response.Occurrences {
|
|
item, found := registry.LookupID(occurrence.ItemID)
|
|
if !found || item.Name != occurrence.Name {
|
|
continue
|
|
}
|
|
occurrences = append(occurrences, dnd.ItemOccurrence{
|
|
ItemID: occurrence.ItemID,
|
|
Name: occurrence.Name,
|
|
Kind: dnd.ItemOccurrenceKind(occurrence.Kind),
|
|
Quantity: cloneQuantity(occurrence.Quantity),
|
|
From: occurrence.From,
|
|
To: occurrence.To,
|
|
SourceRefs: itemOccurrenceSourceRefs(occurrence.SourceRefs, sourceID),
|
|
})
|
|
}
|
|
return dnd.ItemOccurrenceList{Occurrences: occurrences}
|
|
}
|
|
|
|
func itemOccurrenceSourceRefs(refs []itemOccurrenceSourceRefResponse, sourceID string) []source.SourceRef {
|
|
if refs == nil {
|
|
return nil
|
|
}
|
|
values := make([]source.SourceRef, len(refs))
|
|
for index, ref := range refs {
|
|
values[index] = source.SourceRef{SourceID: sourceID, StartUnitID: ref.StartSegment, EndUnitID: ref.EndSegment}
|
|
}
|
|
return values
|
|
}
|
|
|
|
func itemOccurrenceResponseRefs(refs []source.SourceRef) []itemOccurrenceSourceRefResponse {
|
|
if refs == nil {
|
|
return nil
|
|
}
|
|
values := make([]itemOccurrenceSourceRefResponse, len(refs))
|
|
for index, ref := range refs {
|
|
values[index] = itemOccurrenceSourceRefResponse{StartSegment: ref.StartUnitID, EndSegment: ref.EndUnitID}
|
|
}
|
|
return values
|
|
}
|
|
|
|
func cloneQuantity(value *int) *int {
|
|
if value == nil {
|
|
return nil
|
|
}
|
|
quantity := *value
|
|
return &quantity
|
|
}
|