public class VariantsServerVariablesParser : INotificationHandler<ServerVariablesParsingNotification>
{
    public void Handle(ServerVariablesParsingNotification notification)
    {
        if (!notification.ServerVariables.TryGetValue("umbracoSettings", out object? umbracoSettingsObject)
            || umbracoSettingsObject is not IDictionary<string, object> umbracoSettings)
        {
            umbracoSettings = new Dictionary<string, object>();
            notification.ServerVariables.Add("umbracoSettings", umbracoSettings);
        }

        umbracoSettings["showAllowSegmentationForDocumentTypes"] = true;
    }
}

public class VariantsComposer : IComposer
{
    public void Compose(IUmbracoBuilder builder)
    {
        builder.AddNotificationHandler<ServerVariablesParsingNotification, VariantsServerVariablesParser>();
    }
}

// Only create segments if they don't exist yet. After saving and publishing, all variants likely already exist on the document type, so you don't want to add them again.
// Notice that `segments` here is whatever you make it. For me it's a list of names and ids, passed in from some external code.
foreach (var segment in segments.Where(s => !newVariants.Any(v => v.Language?.Id == variant.Language?.Id && v.Segment == s.Id)))
{
    var newVariant = new ContentVariantDisplay
    {
        AllowedActions = new List<string>(variant.AllowedActions),
        DisplayName = segment.Name,
        Language = variant.Language,
        Segment = segment.Id,
        State = ContentSavedState.NotCreated, // 👈 State has to be 'NotCreated'
        Tabs = variant.Tabs.Select(x => new Tab<ContentPropertyDisplay>
        {
            Alias = x.Alias,
            IsActive = x.IsActive,
            Expanded = x.Expanded,
            Id = x.Id,
            Key = x.Key,
            Label = x.Label,
            Type = x.Type,
            Properties = x.Properties?.Select(p => new ContentPropertyDisplay
            {
                Alias = p.Alias,
                Config = p.Config,
                ConfigNullable = p.ConfigNullable,
                Culture = p.Culture,
                DataTypeKey = p.DataTypeKey,
                Description = p.Description,
                Editor = p.Editor,
                HideLabel = p.HideLabel,
                Id = p.Id,
                IsSensitive = p.IsSensitive,
                Label = p.Label,
                LabelOnTop = p.LabelOnTop,
                PropertyEditor = p.PropertyEditor,
                Readonly = p.Readonly,
                Segment = variantProps.Contains(p.Alias) ? segment.Id : null, // 👈 This value must be set to the segment, but only if this property varies by segment.
                SupportsReadOnly = p.SupportsReadOnly,
                Validation = p.Validation,
                Value = variantProps.Contains(p.Alias) ? null : p.Value, // 👈 The value must only be copied if the property is not variant by segment
                Variations = p.Variations,
                View = p.View,
            }),
        })
    };

    additionalVariants.Add(newVariant);
}

notification.Content.Variants = newVariants
            .OrderBy(v => IsDefaultLanguage(v) ? 0 : 1)
            .ThenBy(v => IsDefaultSegment(v) ? 0 : 1)
            .ThenBy(v => v?.Language?.Name)
            .ThenBy(v => v.Segment)
            .ToList();

private static bool IsDefaultLanguage(ContentVariantDisplay variant) =>
        variant.Language == null || variant.Language.IsDefault;

private static bool IsDefaultSegment(ContentVariantDisplay variant) => variant.Segment == null;

[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
public class SegmentAttribute : Attribute, IFilterFactory
{
    public bool IsReusable => false;

    public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
    {
        return ActivatorUtilities.CreateInstance<InternalSegmentActionFilter>(serviceProvider);
    }

    private sealed class InternalSegmentActionFilter : IActionFilter
    {
        private readonly IVariationContextAccessor _variationContextAccessor;
        private readonly IUmbracoContextAccessor _umbracoContextAccessor;

        public InternalSegmentActionFilter(IVariationContextAccessor variationContextAccessor, IUmbracoContextAccessor umbracoContextAccessor)
        {
            _variationContextAccessor = variationContextAccessor;
            _umbracoContextAccessor = umbracoContextAccessor;
        }

        public void OnActionExecuted(ActionExecutedContext context)
        {
            // Method not needed, but part of the interface
        }

        public void OnActionExecuting(ActionExecutingContext context)
        {
            // Use the request context to find out which segment the visitor is in. My `.GetSegment()` extension method uses the query string
            var segment = context.HttpContext.GetSegment();
            var currentPage = _umbracoContextAccessor.GetRequiredUmbracoContext().PublishedRequest.PublishedContent
                ?? throw new InvalidOperationException("The segment action filter can only be used on actions that are related to an umbraco page");

            // You need to find out if the current content actually varies by segment and by the exact segment of the user, because if you assign a segment that does not exist, you'll get an empty page!
            // there is no proper way to check if a page varies by segment, other than enumerating all properties and check if any of them vary by segment AND at least one of the variant properties has a value.
            // You'll likely need to check on your culture as well, this example assumes that the culture is null.
            var segmentShouldBeApplied = currentPage.Properties.Any(p => p.PropertyType.VariesBySegment() && p.HasValue(null, segment.Id));

            if (segmentShouldBeApplied)
            {
                var variationContext = new VariationContext(_variationContextAccessor.VariationContext?.Culture, segment.Id);
                _variationContextAccessor.VariationContext = variationContext;
            }
        }
    }
}