/// <summary>
/// The <see cref="System.IDisposable.Dispose"/> method ends the scope lifetime. Once Dispose
/// is called, any scoped services that have been resolved from
/// <see cref="Microsoft.Extensions.DependencyInjection.IServiceScope.ServiceProvider"/> will be
/// disposed.
/// </summary>
public interface IServiceScope : IDisposable
{
    /// <summary>
    /// The <see cref="System.IServiceProvider"/> used to resolve dependencies from the scope.
    /// </summary>
    IServiceProvider ServiceProvider { get; }
}

// Dependency.cs
public class SingletonDependency : Dependency
{
}

public class ScopedDependency : Dependency
{
}

public class TransientDependency : Dependency
{
}

public class Dependency
{
    private readonly Guid id;

    public Dependency()
    {
        this.id = Guid.NewGuid();
    }

    public override string? ToString()
    {
        return $"{this.GetType().Name}: {this.id}";
    }
}

// Program.cs
public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        // Add services to the container.

        builder.Services.AddControllers();

        builder.Services.AddSingleton<SingletonDependency>();
        builder.Services.AddScoped<ScopedDependency>();
        builder.Services.AddTransient<TransientDependency>();

        var app = builder.Build();

        // Configure the HTTP request pipeline.

        app.UseHttpsRedirection();

        app.UseAuthorization();

        app.MapControllers();

        app.Run();
    }
}

// TestsController.cs
[Route("api/[controller]")]
[ApiController]
public class TestsController : ControllerBase
{
    private readonly SingletonDependency singletonDependency;
    private readonly ScopedDependency scopedDependency;
    private readonly TransientDependency transientDependency;

    public TestsController(SingletonDependency singletonDependency, ScopedDependency scopedDependency, TransientDependency transientDependency)
    {
        this.singletonDependency = singletonDependency;
        this.scopedDependency = scopedDependency;
        this.transientDependency = transientDependency;
    }

    [HttpGet]
    public ActionResult Get()
    {
        Console.WriteLine("\n---Dependencies injected in constructor---");
        Console.WriteLine(this.singletonDependency);
        Console.WriteLine(this.scopedDependency);
        Console.WriteLine(this.transientDependency);

        var singleton1 = this.HttpContext.RequestServices.GetService<SingletonDependency>();
        var scoped1 = this.HttpContext.RequestServices.GetService<ScopedDependency>();
        var transient1 = this.HttpContext.RequestServices.GetService<TransientDependency>();

        Console.WriteLine("\n---Dependencies resolved from RequestServices---");
        Console.WriteLine(singleton1);
        Console.WriteLine(scoped1);
        Console.WriteLine(transient1);

        using (var scope = this.HttpContext.RequestServices.CreateScope())
        {
            var singleton2 = scope.ServiceProvider.GetService<SingletonDependency>();
            var scoped2 = scope.ServiceProvider.GetService<ScopedDependency>();
            var transient2 = scope.ServiceProvider.GetService<TransientDependency>();

            Console.WriteLine("\n---Dependencies resolved from a scope---");
            Console.WriteLine(singleton2);
            Console.WriteLine(scoped2);
            Console.WriteLine(transient2);
        }

        using (var scope = this.HttpContext.RequestServices.CreateScope())
        {
            var singleton3 = scope.ServiceProvider.GetService<SingletonDependency>();
            var scoped3 = scope.ServiceProvider.GetService<ScopedDependency>();
            var transient3 = scope.ServiceProvider.GetService<TransientDependency>();

            Console.WriteLine("\n---Dependencies resolved from a new scope---");
            Console.WriteLine(singleton3);
            Console.WriteLine(scoped3);
            Console.WriteLine(transient3);
        }

        var singleton4 = this.HttpContext.RequestServices.GetService<SingletonDependency>();
        var scoped4 = this.HttpContext.RequestServices.GetService<ScopedDependency>();
        var transient4 = this.HttpContext.RequestServices.GetService<TransientDependency>();

        Console.WriteLine("\n---Dependencies resolved from RequestServices again---");
        Console.WriteLine(singleton4);
        Console.WriteLine(scoped4);
        Console.WriteLine(transient4);

        this.HttpContext.Features.Set<IServiceProvidersFeature>(null);
        var singleton5 = this.HttpContext.RequestServices.GetService<SingletonDependency>();
        var scoped5 = this.HttpContext.RequestServices.GetService<ScopedDependency>();
        var transient5 = this.HttpContext.RequestServices.GetService<TransientDependency>();

        Console.WriteLine("\n---Dependencies resolved from a new RequestServices---");
        Console.WriteLine(singleton5);
        Console.WriteLine(scoped5);
        Console.WriteLine(transient5);

        return new OkObjectResult("Success");
    }
}

public sealed class DefaultHttpContext : HttpContext
{
    private static readonly Func<DefaultHttpContext, IServiceProvidersFeature> _newServiceProvidersFeature = context => new RequestServicesFeature(context, context.ServiceScopeFactory);

    private FeatureReferences<FeatureInterfaces> _features;

    public DefaultHttpContext(IFeatureCollection features)
    {
        _features.Initalize(features);
        _request = new DefaultHttpRequest(this);
        _response = new DefaultHttpResponse(this);
    }

    private IServiceProvidersFeature ServiceProvidersFeature =>
        _features.Fetch(ref _features.Cache.ServiceProviders, this, _newServiceProvidersFeature)!;

    public override IServiceProvider RequestServices
    {
        get { return ServiceProvidersFeature.RequestServices; }
        set { ServiceProvidersFeature.RequestServices = value; }
    }

    struct FeatureInterfaces
    {
        public IItemsFeature? Items;
        public IServiceProvidersFeature? ServiceProviders;
        public IHttpAuthenticationFeature? Authentication;
        public IHttpRequestLifetimeFeature? Lifetime;
        public ISessionFeature? Session;
        public IHttpRequestIdentifierFeature? RequestIdentifier;
    }
}

public struct FeatureReferences<TCache>
{
    public void Initalize(IFeatureCollection collection)
    {
        Revision = collection.Revision;
        Collection = collection;
    }

    public IFeatureCollection Collection { get; private set; }

    public int Revision { get; private set; }

    // cache is a public field because the code calling Fetch must
    // be able to pass ref values that "dot through" the TCache struct memory,
    // if it was a Property then that getter would return a copy of the memory
    // preventing the use of "ref"
    public TCache? Cache;

    // Careful with modifications to the Fetch method; it is carefully constructed for inlining
    // See: https://github.com/aspnet/HttpAbstractions/pull/704
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public TFeature? Fetch<TFeature, TState>(
        ref TFeature? cached,
        TState state,
        Func<TState, TFeature?> factory) where TFeature : class?
    {
        var flush = false;
        var revision = Collection?.Revision ?? ContextDisposed();
        if (Revision != revision)
        {
            // Clear cached value to force call to UpdateCached
            cached = null!;
            // Collection changed, clear whole feature cache
            flush = true;
        }

        return cached ?? UpdateCached(ref cached!, state, factory, revision, flush);
    }

    // Update and cache clearing logic, when the fast-path in Fetch isn't applicable
    private TFeature? UpdateCached<TFeature, TState>(ref TFeature? cached, TState state, Func<TState, TFeature?> factory, int revision, bool flush) where TFeature : class?
    {
        if (flush)
        {
            // Collection detected as changed, clear cache
            Cache = default;
        }

        cached = Collection.Get<TFeature>();
        if (cached == null)
        {
            // Item not in collection, create it with factory
            cached = factory(state);
            // Add item to IFeatureCollection
            Collection.Set(cached);
            // Revision changed by .Set, update revision to new value
            Revision = Collection.Revision;
        }
        else if (flush)
        {
            // Cache was cleared, but item retrieved from current Collection for version
            // so use passed in revision rather than making another virtual call
            Revision = revision;
        }

        return cached;
    }
}

public class RequestServicesFeature : IServiceProvidersFeature, IDisposable, IAsyncDisposable
{
    private readonly IServiceScopeFactory? _scopeFactory;
    private IServiceProvider? _requestServices;
    private IServiceScope? _scope;
    private bool _requestServicesSet;
    private readonly HttpContext _context;

    public RequestServicesFeature(HttpContext context, IServiceScopeFactory? scopeFactory)
    {
        _context = context;
        _scopeFactory = scopeFactory;
    }

    public IServiceProvider RequestServices
    {
        get
        {
            if (!_requestServicesSet && _scopeFactory != null)
            {
                _context.Response.RegisterForDisposeAsync(this);
                _scope = _scopeFactory.CreateScope();
                _requestServices = _scope.ServiceProvider;
                _requestServicesSet = true;
            }
            return _requestServices!;
        }

        set
        {
            _requestServices = value;
            _requestServicesSet = true;
        }
    }

    public ValueTask DisposeAsync()
    {
        switch (_scope)
        {
            case IAsyncDisposable asyncDisposable:
                var vt = asyncDisposable.DisposeAsync();
                if (!vt.IsCompletedSuccessfully)
                {
                    return Awaited(this, vt);
                }
                // If its a IValueTaskSource backed ValueTask,
                // inform it its result has been read so it can reset
                vt.GetAwaiter().GetResult();
                break;
            case IDisposable disposable:
                disposable.Dispose();
                break;
        }

        _scope = null;
        _requestServices = null;

        return default;

        static async ValueTask Awaited(RequestServicesFeature servicesFeature, ValueTask vt)
        {
            await vt;
            servicesFeature._scope = null;
            servicesFeature._requestServices = null;
        }
    }

    public void Dispose()
    {
        DisposeAsync().AsTask().GetAwaiter().GetResult();
    }
}