using FluentAssertions;
using FluentAssertions.Primitives;
using JetBrains.Annotations;
using System;
using System.Reflection;

public static class FluentAssertionsExtensions
{
    /// <summary>
    /// Asserts that all public properties of the object and its nested objects are not null,
    /// with an optional predicate for excluding specific properties.
    /// </summary>
    /// <param name="assertions">The FluentAssertions assertion context.</param>
    /// <param name="exclusionPredicate">A predicate to exclude specific properties from the null-check. Defaults to no exclusions.</param>
    /// <param name="because">A formatted explanation for why the assertion should be met.</param>
    /// <param name="becauseArgs">Arguments to format the <paramref name="because"/> string.</param>
    [AssertionMethod]
    public static void HaveAllPropertiesNotNull(
        this ObjectAssertions assertions,
        Func<PropertyInfo, bool>? exclusionPredicate = null,
        string because = "",
        params object[] becauseArgs)
    {
        // Ensure the subject is not null
        var subject = assertions.Subject;
        if (subject == null)
        {
            throw new ArgumentNullException(nameof(assertions.Subject), "Subject must not be null.");
        }

        // Delegate to the core recursive implementation
        AssertPropertiesAreNotNull(subject, exclusionPredicate, because, becauseArgs);
    }

    /// <summary>
    /// Recursively asserts that all properties of the given object are not null.
    /// </summary>
    /// <param name="obj">The object to validate.</param>
    /// <param name="exclusionPredicate">A predicate to exclude specific properties.</param>
    /// <param name="because">A formatted explanation for why the assertion should be met.</param>
    /// <param name="becauseArgs">Arguments to format the <paramref name="because"/> string.</param>
    private static void AssertPropertiesAreNotNull(
        object? obj,
        Func<PropertyInfo, bool>? exclusionPredicate,
        string because,
        params object[] becauseArgs)
    {
        if (obj == null) return;

        exclusionPredicate ??= _ => false; // Default to no exclusions

        var properties = obj.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);

        foreach (var property in properties)
        {
            // Skip excluded properties
            if (exclusionPredicate(property))
                continue;

            var value = property.GetValue(obj);

            // Assert property is not null
            value.Should().NotBeNull(
                $"property '{property.Name}' must not be null{(string.IsNullOrEmpty(because) ? "" : " because " + because)}",
                becauseArgs);

            // Recursively validate nested properties
            if (value != null && !IsPrimitive(property.PropertyType))
            {
                AssertPropertiesAreNotNull(value, exclusionPredicate, because, becauseArgs);
            }
        }
    }

    /// <summary>
    /// Determines whether a type is considered "primitive" for the purpose of stopping recursion.
    /// </summary>
    /// <param name="type">The type to check.</param>
    /// <returns>True if the type is primitive or commonly treated as a leaf node; otherwise, false.</returns>
    private static bool IsPrimitive(Type type)
    {
        return type.IsPrimitive
            || type.IsEnum
            || type == typeof(string)
            || type == typeof(decimal)
            || type == typeof(DateTime)
            || type == typeof(TimeSpan)
            || type == typeof(Guid);
    }
}

    someModel.Should().HaveAllPropertiesNotNull(
        exclusionPredicate: property => property.Name == "Id",
        because: "all required properties must be initialized");   

            antragImportViewModel.Should().HaveAllPropertiesNotNull(x => x.Name == "Id" || x.Name == "SomeOtherProperty");
            
            // or more modern:L
            antragImportViewModel.Should().HaveAllPropertiesNotNull(x => x.Name is "Id" or "SomeOtherProperty");

exclusionPredicate: property => property.PropertyType == typeof(byte[])

exclusionPredicate: property => property.GetCustomAttribute<ObsoleteAttribute>() != null