Document versioning

const (
    // ModeFull stores complete document snapshots
    ModeFull = "full"
    
    // ModeDiff stores only the changes between versions
    ModeDiff = "diff"

    // OpSet represents a field set/change operation
    OpSet = "set"
    
    // OpUnset represents a field removal operation
    OpUnset = "unset"
)

// SaveVersion saves a version snapshot before an update
func (m *Manager) SaveVersion(ctx context.Context, opts *SaveVersionOpts) error {
    // Get the next version number
    nextVersion, err := m.getNextVersion(ctx, opts.Collection, opts.DocID)
    if err != nil {
        return fmt.Errorf("failed to get next version: %w", err)
    }

    // Build the version document
    versionDoc := map[string]interface{}{
        "_id":        primitive.NewObjectID(),
        "collection": opts.Collection,
        "doc_id":     opts.DocID,
        "version":    nextVersion,
        "mode":       opts.Mode,
        "updated_by": opts.UpdatedBy,
        "updated_at": time.Now().UTC(),
    }

    if opts.ChangeReason != "" {
        versionDoc["change_reason"] = opts.ChangeReason
    }

    // Handle based on mode
    switch opts.Mode {
    case ModeFull:
        versionDoc["data"] = opts.Document
    
    case ModeDiff:
        // First version must always be full
        if nextVersion == 1 {
            versionDoc["mode"] = ModeFull
            versionDoc["data"] = opts.Document
        } else {
            changes := CalculateDiff(opts.Document, opts.NewDocument)
            versionDoc["changes"] = changes
        }
    }

    coll := m.store.Collection(VersionsCollection)
    _, err = coll.InsertOne(ctx, versionDoc)
    return err
}

// GetVersions lists all versions for a document
func (m *Manager) GetVersions(ctx context.Context, collection, docID string) ([]*VersionInfo, error) {
    filter := bson.M{
        "collection": collection,
        "doc_id":     docID,
    }

    results, err := m.store.Find(ctx, VersionsCollection, filter, &store.FindOptions{
        Sort: bson.D{{Key: "version", Value: 1}},
    })
    if err != nil {
        return nil, fmt.Errorf("failed to get versions: %w", err)
    }

    versions := make([]*VersionInfo, 0, len(results))
    for _, doc := range results {
        info := &VersionInfo{
            Version:      getVersionNumber(doc),
            UpdatedBy:    doc["updated_by"].(string),
            UpdatedAt:    doc["updated_at"].(time.Time),
            ChangeReason: doc["change_reason"].(string),
        }
        versions = append(versions, info)
    }

    return versions, nil
}

// GetVersionData reconstructs document at a specific version
func (m *Manager) GetVersionData(ctx context.Context, collection, docID string, version int) (map[string]interface{}, error) {
    // Get the target version first to check its mode
    targetVersion, err := m.GetVersion(ctx, collection, docID, version)
    if err != nil {
        return nil, err
    }

    // If it's full mode, return the data directly
    if targetVersion.Mode == ModeFull {
        return targetVersion.Data, nil
    }

    // For diff mode, we need to reconstruct from version 1
    filter := bson.M{
        "collection": collection,
        "doc_id":     docID,
        "version":    bson.M{"$lte": version},
    }

    results, err := m.store.Find(ctx, VersionsCollection, filter, &store.FindOptions{
        Sort: bson.D{{Key: "version", Value: 1}},
    })
    if err != nil {
        return nil, fmt.Errorf("failed to get versions: %w", err)
    }

    // Start with base document (deep copy)
    data := deepCopyMap(versions[0].Data)

    // Apply diffs in order
    for i := 1; i < len(versions); i++ {
        v := versions[i]
        if v.Mode == ModeFull {
            data = deepCopyMap(v.Data)
        } else {
            applyChanges(data, v.Changes)
        }
    }

    return data, nil
}

// DiffVersions compares two versions and returns the changes
func (m *Manager) DiffVersions(ctx context.Context, collection, docID string, v1, v2 int) ([]FieldChange, error) {
    // Get data for both versions
    data1, err := m.GetVersionData(ctx, collection, docID, v1)
    if err != nil {
        return nil, fmt.Errorf("failed to get version %d: %w", v1, err)
    }

    data2, err := m.GetVersionData(ctx, collection, docID, v2)
    if err != nil {
        return nil, fmt.Errorf("failed to get version %d: %w", v2, err)
    }

    return CalculateDiff(data1, data2), nil
}

// CalculateDiff calculates the changes between two documents
func CalculateDiff(old, new map[string]interface{}) []FieldChange {
    changes := make([]FieldChange, 0)
    calculateDiffRecursive("", old, new, &changes)

    // Sort changes by field name for consistent ordering
    sort.Slice(changes, func(i, j int) bool {
        return changes[i].Field < changes[j].Field
    })

    return changes
}

// calculateDiffRecursive recursively calculates diffs
func calculateDiffRecursive(prefix string, old, new map[string]interface{}, changes *[]FieldChange) {
    // Track all keys from both maps
    allKeys := make(map[string]bool)
    for k := range old {
        allKeys[k] = true
    }
    for k := range new {
        allKeys[k] = true
    }

    for key := range allKeys {
        fieldPath := key
        if prefix != "" {
            fieldPath = prefix + "." + key
        }

        oldVal, oldExists := old[key]
        newVal, newExists := new[key]

        if !oldExists {
            // Field was added
            *changes = append(*changes, FieldChange{
                Field: fieldPath,
                Op:    OpSet,
                From:  nil,
                To:    newVal,
            })
        } else if !newExists {
            // Field was removed
            *changes = append(*changes, FieldChange{
                Field: fieldPath,
                Op:    OpUnset,
                From:  oldVal,
                To:    nil,
            })
        } else if !deepEqual(oldVal, newVal) {
            // Check if both are maps for recursive diff
            oldMap, oldIsMap := oldVal.(map[string]interface{})
            newMap, newIsMap := newVal.(map[string]interface{})

            if oldIsMap && newIsMap {
                calculateDiffRecursive(fieldPath, oldMap, newMap, changes)
            } else {
                // Field was changed
                *changes = append(*changes, FieldChange{
                    Field: fieldPath,
                    Op:    OpSet,
                    From:  oldVal,
                    To:    newVal,
                })
            }
        }
    }
}

// GetDataForRestore gets document data for restoring to a version
func (m *Manager) GetDataForRestore(ctx context.Context, collection, docID string, version int) (map[string]interface{}, error) {
    return m.GetVersionData(ctx, collection, docID, version)
}

// CleanupVersions removes old versions based on retention policy
func (m *Manager) CleanupVersions(ctx context.Context, collection string, cfg *config.CollectionVersioningConfig) error {
    // Get all unique doc_ids in this collection
    pipeline := []bson.M{
        {"$match": bson.M{"collection": collection}},
        {"$group": bson.M{"_id": "$doc_id"}},
    }

    docIDs, err := m.store.Aggregate(ctx, VersionsCollection, pipeline)
    if err != nil {
        return fmt.Errorf("failed to get document IDs: %w", err)
    }

    for _, doc := range docIDs {
        docID := doc["_id"].(string)
        if err := m.cleanupDocumentVersions(ctx, collection, docID, cfg); err != nil {
            return err
        }
    }

    return nil
}