droboticflow/internal/api/annotation_invalid_slice_consolidation.go

84 lines
2.8 KiB
Go

package api
import (
"fmt"
"reflect"
"sort"
"strings"
"droboticflow/internal/domain"
)
// Consolidation is an explicit submission choice, never a migration or a
// cancel-cut. Action records are not passed by pointer or rewritten here.
func consolidateInvalidActionSlices(input []domain.SliceSegment, actions []domain.AnnotationSegment, selected []string) ([]domain.SliceSegment, []domain.SliceOperation, error) {
if len(selected) == 0 {
return input, nil, nil
}
ordered := append([]domain.SliceSegment(nil), input...)
sort.Slice(ordered, func(i, j int) bool { return ordered[i].Start < ordered[j].Start })
eligible := map[string]int{}
for i := 1; i < len(ordered)-1; i++ {
l, c, r := ordered[i-1], ordered[i], ordered[i+1]
if l.IsDiscarded() || c.IsDiscarded() || r.IsDiscarded() || strings.TrimSpace(c.Name) == "" || l.Name != c.Name || r.Name != c.Name || !reflect.DeepEqual(l.Dictionary, c.Dictionary) || !reflect.DeepEqual(r.Dictionary, c.Dictionary) || l.End != c.Start || c.End != r.Start {
continue
}
cursor, has, valid := c.Start, false, true
inner := append([]domain.AnnotationSegment(nil), actions...)
sort.Slice(inner, func(i, j int) bool { return inner[i].Start < inner[j].Start })
for _, a := range inner {
if a.End <= c.Start || a.Start >= c.End {
continue
}
if a.Start != cursor || a.End > c.End || a.End <= a.Start || !a.IsInvalid {
valid = false
break
}
cursor, has = a.End, true
}
if valid && has && cursor == c.End {
eligible[c.ID] = i
}
}
edges := make([]bool, len(ordered))
seen := map[string]bool{}
for _, id := range selected {
i, ok := eligible[id]
if !ok || seen[id] {
return nil, nil, fmt.Errorf("所选无效区间的相邻切片已变化,请重新核对后提交")
}
seen[id] = true
edges[i-1], edges[i] = true, true
}
var result []domain.SliceSegment
var operations []domain.SliceOperation
for i := 0; i < len(ordered); {
j := i
for j < len(ordered)-1 && edges[j] {
j++
}
merged := ordered[i]
if j > i {
// Keep original IDs in audit provenance; reuse the leftmost stable ID.
merged.SourceIDs = nil
provenance := map[string]bool{}
ids := []string{}
for k := i; k <= j; k++ {
ids = append(ids, ordered[k].ID)
for _, id := range append([]string{ordered[k].ID}, ordered[k].SourceIDs...) {
if !provenance[id] {
merged.SourceIDs = append(merged.SourceIDs, id)
provenance[id] = true
}
}
}
merged.End = ordered[j].End
merged.EndTimestampUS = ordered[j].EndTimestampUS
operations = append(operations, domain.SliceOperation{Type: "consolidate_invalid_actions", SegmentIDs: ids, Before: append([]domain.SliceSegment(nil), ordered[i:j+1]...), After: []domain.SliceSegment{merged}})
}
result = append(result, merged)
i = j + 1
}
return result, operations, nil
}