using Moq;

​

namespace MyProject.Tests;

​

public abstract class WithSubject<TSubject> where TSubject : class

{

    private readonly Dictionary<Type, object?> _explicitDependencies = new();

    private readonly Dictionary<Type, Mock> _dependencies = new();

    private TSubject? _subject;

​

    protected Mock<TDependency> The<TDependency>() where TDependency : class

    {

        // if we don't have the mock already, then create one

        if (!_dependencies.ContainsKey( typeof(TDependency) ))

            _dependencies.Add( typeof(TDependency), new Mock<TDependency>() );

        // we will definitely have it now, return it

        return (Mock<TDependency>) _dependencies[typeof(TDependency)];

    }

​

    protected Mock<TDependency> An<TDependency>() where TDependency : class

    {

        // just create a new one each time

        return new Mock<TDependency>();

    }

​

    protected void UseFor<TDependency>(TDependency? implementation)

    {

        _explicitDependencies.TryAdd(typeof(TDependency), implementation);

    }

​

    protected TSubject Subject

    {

        get

        {

            // sorta breaking the rules here, because this getter can be expensive the first time

            // but it's cached once fetched, and also only happens on-demand

            if (_subject is not null)

                return _subject;

​

            // now we build the subject

            try

            {

                _subject = BuildSubject();

            }

            catch (InvalidOperationException e)

            {

                throw new Exception($"{typeof(TSubject).Name} does not have a constructor that works with BuildSubject, and must be built manually", e);

            }

​

            return _subject;

        }

    }

​

    private TSubject BuildSubject()

    {

        // to build the subject, there are a few steps:

        // 1) enumerate the public constructors

        // 2) find the public constructor that takes the most parameters (this will almost always be the one with the most dependencies)

        // 3) iterate those dependencies

        // 4) check if we've already created one with a previous call to The<T> and use that if so

        // 5) create missing dependencies and add them to the dictionary otherwise

        // 6) construct the subject with the dependencies as parameters

        // 7) set the private variable, so it's no longer null

​

        var subjectType = typeof(TSubject);

        var bestConstructor = subjectType

            .GetConstructors()

            .MaxBy(c => c.GetParameters().Length);

​

        // shouldn't actually happen, because MaxBy will throw if there's no elements, but the .NET code doesn't have nullability decorators

        // so the compiler can't tell

        if (bestConstructor is null)

            throw new InvalidOperationException("No suitable constructors");

​

        var constructorParameters = new List<object?>();

​

        foreach (var p in bestConstructor.GetParameters())

        {

​

            var parameterType = p.ParameterType;

​

            if (!_explicitDependencies.TryGetValue(parameterType, out var implementation))

            {

​

                // ensure we have the dependency one way or another

                // TryAdd will no-op if the key already exists

                if (!_dependencies.TryGetValue(parameterType, out var mock))

                {

                    mock = CreateMock(parameterType);

                    _dependencies.TryAdd(parameterType, mock);

                }

                implementation = mock.Object;

            }

​

            // add the constructed dependency in the right order

            constructorParameters.Add(implementation);

        }

​

        // var instance = new TSubject(constructorParameters.ToArray());

        var instance = Activator.CreateInstance(subjectType, constructorParameters.ToArray());

        if (instance is null)

            throw new InvalidOperationException($"Could not construct an instance of {subjectType.Name}");

​

        return (TSubject)instance;

    }

​

    private Mock CreateMock(Type dependencyType)

    {

        // use reflections bullshit to close the generics so we get strong <T>

        var openMock = typeof(Mock<>).MakeGenericType(dependencyType);

        return (Mock)Activator.CreateInstance(openMock)!;

    }

}