#nullable enable

using System;

using Microsoft.Extensions.DependencyInjection;

using Microsoft.Extensions.DependencyInjection.Extensions;

using Microsoft.Extensions.Options;

using Microsoft.Extensions.Configuration;

using Microsoft.AspNetCore.Http.Extensions;

using System.Text.Json;

public class Program

{

    public const string OptionsJson = """

        {

            "Name": "myname",

            "OAuth": "/.well-known/oauth-protected-resource/{resource}",

            "Jwks": "/.well-known/jwks"

        }

        """;

    public static void Main()

    {

        Uri test = new ("https://example.com/test");

        Uri test1 = new ("https://example.com");

        Uri oauth = new (ProtectedResourceConstants.DefaultOAuthProtectedResourcePathSuffix);

        Uri jwks = new (ProtectedResourceConstants.JsonWebKeySetPathSuffix);

        IServiceCollection coll = new ServiceCollection();

        var options = JsonSerializer.Deserialize<TestOptions>(OptionsJson);

        var builder = new UriBuilder(

            scheme: Uri.UriSchemeHttps,

            host: "",

            port: -1,

            pathValue: null

            );

            //Console.WriteLine(test.AbsolutePath.TrimStart('/').ToLowerInvariant());

        //Console.WriteLine(test1.AbsolutePath.TrimStart('/').ToLowerInvariant());

        //coll.AddKeyedSingleton<ITest, Test>("keyed");

        //coll.AddKeyedSingleton<ITest, Test>(null);

        //coll.AddScoped<IExternalService, ExternalService>();

        //coll.Configure<TestOptions>("keyed",options => { options.Name = "keyed"; });

        //coll.Configure<TestOptions>(null,options => { options.Name = "default"; });

        //var sp = coll.BuildServiceProvider();

        //Console.WriteLine(sp.GetServices<ITest>());

        //var keyedService = sp.GetRequiredOrKeyedRequiredService<ITest>("keyed");

        //var unKeyed = sp.GetRequiredOrKeyedRequiredService<ITest>(null);

        //Console.WriteLine(keyedService.GetName());

        //Console.WriteLine(unKeyed.GetName());

        //var ext = sp.GetService<IExternalService>();

        //Console.WriteLine(ext.GetNameExt());

        Console.WriteLine(oauth.IsAbsoluteUri);

        Console.WriteLine(jwks.IsAbsoluteUri);

        Console.WriteLine(options.OAuth.IsAbsoluteUri);

        Console.WriteLine(options.Jwks.IsAbsoluteUri);

        Console.WriteLine(builder.Uri);

​

​

    }

}

​

public class TestOptions

{

    public string Name {get; set;}

    public Uri OAuth {get; set; }

    public Uri Jwks {get; set;}

}

public interface ITest 

{

    public string GetName();

}

​

public class Test : ITest

{

    public string Name;

    public Test([ServiceKey] string? serviceKey = null)

    {

        Name = serviceKey ?? "default";

    }

    public string GetName()

    {

        return Name;

    }

}

​

public class ExternalService(ITest testService, IOptionsMonitor<TestOptions> monitor) : IExternalService

{

    public string GetOptions() => monitor.GetKeyedOrCurrent("keyed").Name;

    public string GetNameExt()

    {

        return testService.GetName();

    }

}

public interface IExternalService

{

    public string GetNameExt();

    public string GetOptions();

}

internal static class ServiceProviderExtensions

{

        public static TOptions GetKeyedOrCurrent<TOptions>(

        this IOptionsMonitor<TOptions> optionsMonitor, string? serviceKey)

        where TOptions : class

    {

        if (serviceKey is null)

        {

            return optionsMonitor.CurrentValue;

        }

​

        return optionsMonitor.Get(serviceKey);

    }

    /// <summary>

    /// Gets a keyed service from the <see cref="IServiceProvider"/>, or a non-keyed service if the key is <see langword="null"/>.

    /// </summary>

    /// <typeparam name="T">The type of service object to get.</typeparam>

    /// <param name="provider">The <see cref="IServiceProvider"/> to retrieve the service object from.</param>

    /// <param name="serviceKey">An optional string that specifies the key of service object to get.</param>

    /// <returns>A service object of type <typeparamref name="T"/>.</returns>

    /// <exception cref="InvalidOperationException">There is no service of type <typeparamref name="T"/> registered.</exception>

    public static T GetRequiredOrKeyedRequiredService<T>(this IServiceProvider provider, string? serviceKey)

        where T : notnull

    {

        return serviceKey is null

            ? provider.GetRequiredService<T>()

            : provider.GetRequiredKeyedService<T>(serviceKey);

    }

}

public static class ProtectedResourceConstants

{

    public const string DefaultOAuthProtectedResourcePathSuffix = "/.well-known/oauth-protected-resource/{resource}";

    public const string JsonWebKeySetPathSuffix = "/.well-known/jwks";

​

    public static class WWWAuthenticateKeys

    {

        public const string UnsignedResourceMetadata = "resource_metadata";

        public const string SignedResourceMetadata = "signed_metadata";

    }

    public static class AuthenticationSchemes

    {

        public const string DPoP = "DPoP";

    }

}