class CustomMatcher : IArgumentMatcher, IDescribeNonMatches, IArgumentMatcher<int>
{
    public string DescribeFor(object argument) => "failed";
    public bool IsSatisfiedBy(object argument) => false;
    public bool IsSatisfiedBy(int argument) => false;
    public override string ToString() => "Custom match";
}

[Test]
public void CustomArgMatch() {
    //ArgumentMatcher.Enqueue<int>(new CustomMatcher());
    var spec = new ArgumentSpecification(typeof(int), new CustomMatcher());
    SubstitutionContext.Current.ThreadContext.EnqueueArgumentSpecification(spec);
    _something.Received().Add(23, 0);
}
/*
  Failed CustomArgMatch [52 ms]
  Error Message:
   NSubstitute.Exceptions.ReceivedCallsException : Expected to receive a call matching:
        Add(23, Custom match)
Actually received no matching calls.
*/

    private class GenericToNonGenericMatcherProxy<T> : IArgumentMatcher
    {
        protected readonly IArgumentMatcher<T> _matcher;

        public GenericToNonGenericMatcherProxy(IArgumentMatcher<T> matcher)
        {
            _matcher = matcher;
        }

        public bool IsSatisfiedBy(object? argument) => _matcher.IsSatisfiedBy((T?)argument!);

        public override string ToString() => _matcher?.ToString() ?? ""; // TODO: fix nullability stuff here
    }

    private class GenericToNonGenericMatcherProxyWithDescribe<T> : GenericToNonGenericMatcherProxy<T>, IDescribeNonMatches
    {
        public GenericToNonGenericMatcherProxyWithDescribe(IArgumentMatcher<T> matcher) : base(matcher)
        {
            if (matcher is not IDescribeNonMatches) throw new SubstituteInternalException("Should implement IDescribeNonMatches type.");
        }

        public string DescribeFor(object? argument) => ((IDescribeNonMatches)_matcher).DescribeFor(argument);

        public override string ToString() => _matcher?.ToString() ?? "";    // TODO: fix nullability stuff here
    }

public class ArgumentFormatter : IArgumentFormatter
{
    internal static IArgumentFormatter Default { get; } = new ArgumentFormatter();
    public string Format(object? argument, bool highlight)
    {
        var formatted = Format(argument);
        return highlight ? "*" + formatted + "*" : formatted;
    }

    private string Format(object? arg)
    {
        return arg switch
        {
            null => "<null>",
            string str => $"\"{str}\"",
            { } obj when HasDefaultToString(obj) => arg.GetType().GetNonMangledTypeName(), // <===
            _ => arg.ToString() ?? string.Empty
        };

        static bool HasDefaultToString(object obj)
            => obj.GetType().GetMethod(nameof(ToString), Type.EmptyTypes)!.DeclaringType == typeof(object); // <=== if obj is a proxy, we can't tell if it's overridden on the matcher itself
    }
}

public interface IFormatable
{
    string Format(Func<object? ,string> format);
    // Alternative if exposing the proxied object through this property is no problem:
    // object? Arg {get;}
}
public class ArgumentFormatter : IArgumentFormatter
{
    private string Format(object? arg)
    {
        return arg switch
        {
            IFormattable f => f.Format(Format),
            // IFormattable f => Format(f.Arg),
            null => "<null>",
            string str => $"\"{str}\"",
            { } obj when HasDefaultToString(obj) => arg.GetType().GetNonMangledTypeName(), // <===
            _ => arg.ToString() ?? string.Empty
        };
        // (...)
    }
}
private class GenericToNonGenericMatcherProxy<T> : IArgumentMatcher, IFormatable
{
    public string Format(Func<object? ,string> format) => format(_matcher);
    // public object? Arg => _matcher;
    // (...)
}

public class ArgumentSpecification : IArgumentSpecification
{
    public string FormatArgument(object? argument)
    {
        var isSatisfiedByArg = IsSatisfiedBy(argument);

        return _matcher is IArgumentFormatter matcherFormatter
            ? matcherFormatter.Format(argument, highlight: !isSatisfiedByArg)
            : ArgumentFormatter.Default.Format(argument, highlight: !isSatisfiedByArg);
    }
    // (...)
}

private class GenericToNonGenericMatcherProxy<T> : IArgumentMatcher, IArgumentFormatter
{
    string Format(object? arg, bool highlight) =>
        _matcher is IArgumentFormatter matcherFormatter
            ? matcherFormatter.Format(argument, highlight)
            : ArgumentFormatter.Default.Format(argument, highlight);
    // (...)
}

public abstract class ArgumentMatcher<T> : IArgumentMatcher<T>, IArgumentMatcher
{
    /// <inheritdoc cref="IArgumentMatcher.ToString" />
    public abstract override string ToString();
    public abstract bool IsSatisfiedBy(T? argument);
    bool IArgumentMatcher.IsSatisfiedBy(object? argument) =>IsSatisfiedBy((T?)argument);
}

    /// <summary>
    /// Enqueues a matcher for the method argument in current position and returns the value which should be
    /// passed back to the method you invoke.
    /// </summary>
    public static ref T? Enqueue<T>(IArgumentMatcher<T> argumentMatcher)
    {
        var matcher = switch argumentMatcher
        {
            null => throw new ArgumentNullException(nameof(argumentMatcher)),
            IArgumentMatcher m => m,
            IDescribeNonMatches => new ArgumentMatcher.GenericToNonGenericMatcherProxyWithDescribe<T>(argumentMatcher),
            _ => new ArgumentMatcher.GenericToNonGenericMatcherProxy<T>(argumentMatcher)
        }
        return ref ArgumentMatcher.EnqueueArgSpecification<T>(new ArgumentSpecification(typeof (T), matcher));
    }