// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System.Collections.Concurrent;
using System.Diagnostics.Tracing;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.HostFiltering;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Routing;
using Microsoft.AspNetCore.Routing.Constraints;
using Microsoft.AspNetCore.TestHost;
using Microsoft.AspNetCore.InternalTesting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
 
namespace Microsoft.AspNetCore.Tests;
 
public class WebHostTests
{
    [Fact]
    public void WebHostConfiguration_IncludesCommandLineArguments()
    {
        var builder = WebHost.CreateDefaultBuilder(new string[] { "--urls", "http://localhost:5001" });
        Assert.Equal("http://localhost:5001", builder.GetSetting(WebHostDefaults.ServerUrlsKey));
    }
 
    [Fact]
    public async Task WebHostConfiguration_HostFilterOptionsAreReloadable()
    {
        var host = WebHost.CreateDefaultBuilder()
            .Configure(app => { })
            .ConfigureAppConfiguration(configBuilder =>
            {
                configBuilder.Add(new ReloadableMemorySource());
            }).Build();
        var config = host.Services.GetRequiredService<IConfiguration>();
        var monitor = host.Services.GetRequiredService<IOptionsMonitor<HostFilteringOptions>>();
        var options = monitor.CurrentValue;
 
        Assert.Contains("*", options.AllowedHosts);
 
        var changed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
        monitor.OnChange(newOptions =>
        {
            changed.SetResult();
        });
 
        config["AllowedHosts"] = "NewHost";
 
        await changed.Task.TimeoutAfter(TimeSpan.FromSeconds(10));
        options = monitor.CurrentValue;
        Assert.Contains("NewHost", options.AllowedHosts);
    }
 
    [Fact]
    public async Task WebHostConfiguration_EnablesForwardedHeadersFromConfig()
    {
        using var host = WebHost.CreateDefaultBuilder()
            .ConfigureAppConfiguration(configBuilder =>
            {
                configBuilder.AddInMemoryCollection(new[]
                {
                        new KeyValuePair<string, string>("FORWARDEDHEADERS_ENABLED", "true" ),
                });
            })
            .UseTestServer()
            .Configure(app =>
            {
                Assert.True(app.Properties.ContainsKey("ForwardedHeadersAdded"), "Forwarded Headers");
                app.Run(context =>
                {
                    Assert.Equal("https", context.Request.Scheme);
                    return Task.CompletedTask;
                });
            }).Build();
 
        await host.StartAsync();
        var client = host.GetTestClient();
        client.DefaultRequestHeaders.Add("x-forwarded-proto", "https");
        var result = await client.GetAsync("http://localhost/");
        result.EnsureSuccessStatusCode();
    }
 
    [Fact]
    public void CreateDefaultBuilder_RegistersRouting()
    {
        var host = WebHost.CreateDefaultBuilder()
            .Configure(_ => { })
            .Build();
 
        var linkGenerator = host.Services.GetService(typeof(LinkGenerator));
        Assert.NotNull(linkGenerator);
    }
 
    [Fact]
    public void CreateDefaultBuilder_RegistersEventSourceLogger()
    {
        var listener = new TestEventListener();
        var host = WebHost.CreateDefaultBuilder()
            .Configure(_ => { })
            .Build();
 
        var logger = host.Services.GetRequiredService<ILogger<WebHostTests>>();
        logger.LogInformation("Request starting");
 
        var events = listener.EventData.ToArray();
        Assert.Contains(events, args =>
            args.EventSource.Name == "Microsoft-Extensions-Logging" &&
            args.Payload.OfType<string>().Any(p => p.Contains("Request starting")));
    }
 
    [Fact]
    public void WebHost_CreateDefaultBuilder_ConfiguresRegexInlineRouteConstraint_ByDefault()
    {
        var host = WebHost.CreateDefaultBuilder()
            .Configure(_ => { })
            .Build();
 
        var routeOptions = host.Services.GetService<IOptions<RouteOptions>>();
 
        Assert.True(routeOptions.Value.ConstraintMap.ContainsKey("regex"));
        Assert.Equal(typeof(RegexInlineRouteConstraint), routeOptions.Value.ConstraintMap["regex"]);
    }
 
    private class TestEventListener : EventListener
    {
        private volatile bool _disposed;
 
        private ConcurrentQueue<EventWrittenEventArgs> _events = new ConcurrentQueue<EventWrittenEventArgs>();
 
        public IEnumerable<EventWrittenEventArgs> EventData => _events;
 
        protected override void OnEventSourceCreated(EventSource eventSource)
        {
            if (eventSource.Name == "Microsoft-Extensions-Logging")
            {
                EnableEvents(eventSource, EventLevel.Informational);
            }
        }
 
        protected override void OnEventWritten(EventWrittenEventArgs eventData)
        {
            if (!_disposed)
            {
                _events.Enqueue(eventData);
            }
        }
 
        public override void Dispose()
        {
            _disposed = true;
            base.Dispose();
        }
    }
 
    private class ReloadableMemorySource : IConfigurationSource
    {
        public IConfigurationProvider Build(IConfigurationBuilder builder)
        {
            return new ReloadableMemoryProvider();
        }
    }
 
    private class ReloadableMemoryProvider : ConfigurationProvider
    {
        public override void Set(string key, string value)
        {
            base.Set(key, value);
            OnReload();
        }
    }
}