package schema import ( "encoding/json" "fmt" "maps" "slices" "strings" ) func decodeSourceSegments(raw []byte) ([]SourceSegment, error) { if !needsMemberResolution(raw, 2) { var segments []SourceSegment err := json.Unmarshal(raw, &segments) return segments, err } var decoded []sourceSegmentWithAliases if err := json.Unmarshal(raw, &decoded); err != nil { return nil, err } segments := make([]SourceSegment, len(decoded)) for i, segment := range decoded { segments[i] = SourceSegment(segment) } return segments, nil } type sourceSegmentWithAliases SourceSegment // Resolve repeated exact names before field conversion, then apply case // variants in the same key order as the original object round trip. func (s *sourceSegmentWithAliases) UnmarshalJSON(raw []byte) error { if !needsMemberResolution(raw, 1) { return json.Unmarshal(raw, (*SourceSegment)(s)) } var members map[string]json.RawMessage if err := json.Unmarshal(raw, &members); err != nil { return err } for _, key := range slices.Sorted(maps.Keys(members)) { var field any switch sourceMemberFor(key) { case memberID: field = &s.ID case memberSpeaker: field = &s.Speaker case memberStart: field = &s.Start case memberEnd: field = &s.End case memberText: field = &s.Text case memberCategories: field = &s.Categories default: continue } if err := json.Unmarshal(members[key], field); err != nil { return fmt.Errorf("field %q: %w", key, err) } } return nil } type sourceMember uint8 const ( memberID sourceMember = 1 << iota memberSpeaker memberStart memberEnd memberText memberCategories ) func sourceMemberFor(key string) sourceMember { switch { case strings.EqualFold(key, "id"): return memberID case strings.EqualFold(key, "speaker"): return memberSpeaker case strings.EqualFold(key, "start"): return memberStart case strings.EqualFold(key, "end"): return memberEnd case strings.EqualFold(key, "text"): return memberText case strings.EqualFold(key, "categories"): return memberCategories } return 0 } // needsMemberResolution looks for repeated recognized keys in valid JSON. // segmentDepth locates members within the array or a single segment. // Escaped keys use the compatibility decoder to resolve their spelling. func needsMemberResolution(raw []byte, segmentDepth int) bool { depth := 0 wantKey := false var seen sourceMember for i := 0; i < len(raw); i++ { switch raw[i] { case '{': depth++ if depth == segmentDepth { seen, wantKey = 0, true } case '[': depth++ case '}', ']': depth-- case ',': if depth == segmentDepth { wantKey = true } case '"': start := i + 1 escaped := false for i++; raw[i] != '"'; i++ { if raw[i] == '\\' { escaped = true i++ } } if depth != segmentDepth || !wantKey { continue } wantKey = false if escaped { return true } member := sourceMemberFor(string(raw[start:i])) if seen&member != 0 { return true } seen |= member } } return false }