using System.Threading.RateLimiting;
using Dpz.Core.Infrastructure.RateLimiting;
using Microsoft.AspNetCore.DataProtection.KeyManagement;
using Microsoft.AspNetCore.HttpOverrides;
using Microsoft.AspNetCore.Localization;
using Microsoft.AspNetCore.RateLimiting;
using Microsoft.Extensions.Primitives;
using OpenIddict.Client.AspNetCore;
using Serilog.Events;
using StackExchange.Redis;

const string corsScheme = "Open-Dpz-Core";

Log.Logger = new LoggerConfiguration().Enrich.FromLogContext().CreateBootstrapLogger();

try
{
    var builder = WebApplication.CreateBuilder(args);
    builder.Host.UseAgileConfig(new ConfigClient(builder.Configuration));

    // 开发环境下重新加载本地配置，覆盖配置中心的特定节点
    if (builder.Environment.IsDevelopment())
    {
        builder.Configuration.AddJsonFile(
            "appsettings.Development.json",
            optional: true,
            reloadOnChange: true
        );
    }

    var configuration = builder.Configuration;
    LibraryHost =
        configuration["LibraryHost"]
        ?? throw new InvalidConfigurationException(
            "configuration node LibraryHost is null or empty"
        );
    AssetsHost =
        configuration["AssetsHost"]
        ?? throw new InvalidConfigurationException(
            "configuration node AssetsHost is null or empty"
        );

    var logSeq = configuration.GetSection("LogSeq").Get<LogSeq>();

    // ReSharper disable once RedundantAssignment
    Func<LogEvent, bool>? filter = null;
#if DEBUG
    filter = x =>
    {
        if (
            !x.Properties.TryGetValue("RequestPath", out var requestPath)
            || requestPath is not ScalarValue pathValue
        )
        {
            return false;
        }

        var pathPrefixes = new[] { "/js", "/css" };
        var path = pathValue.Value?.ToString();
        return path != null
            && pathPrefixes.Any(p => path.StartsWith(p, StringComparison.OrdinalIgnoreCase));
    };
#endif
    builder.Host.ConfigurationLog(logSeq, filter);

    builder
        .WebHost.UseKestrel(
            (_, option) =>
            {
                option.AddServerHeader = false;
                option.ConfigureHttpsDefaults(x =>
                    x.SslProtocols = SslProtocols.Tls12 | SslProtocols.Tls13
                );
            }
        )
        .UseIIS()
        .UseIISIntegration();

    #region services

    var services = builder.Services;

    services.Configure<ForwardedHeadersOptions>(options =>
    {
        options.ForwardedHeaders =
            ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
        options.KnownIPNetworks.Clear();
        options.KnownProxies.Clear();
    });

    services.AddMvc(x =>
    {
        x.Filters.Add(typeof(GlobalFilter));
        x.Filters.Add(new TypeFilterAttribute(typeof(ExceptionHandleAttribute)));
    });
    //压缩
    services.AddResponseCompression(options =>
    {
        options.Providers.Add<BrotliCompressionProvider>();
        options.Providers.Add<GzipCompressionProvider>();
        options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat([
            "application/font-woff2",
            "image/svg+xml",
            "text/plain",
            "application/lrc",
        ]);
        options.EnableForHttps = true;
    });

    services.Configure<BrotliCompressionProviderOptions>(options =>
    {
        options.Level = CompressionLevel.Optimal;
    });

    services.Configure<ZstandardCompressionProviderOptions>(options =>
    {
        options.CompressionOptions = new ZstandardCompressionOptions
        {
            // 取值范围 1-22，数值越高，压缩率越高，但速度越慢
            Quality = 6,
        };
    });

    services.Configure<GzipCompressionProviderOptions>(options =>
    {
        options.Level = CompressionLevel.Optimal;
    });

#if DEBUG
    services.Configure<KestrelServerOptions>(options =>
    {
        options.Limits.MaxRequestBodySize = int.MaxValue;
    });
#endif
    services.AddRateLimiter(options =>
    {
        options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
        options.AddFixedWindowLimiter(
            "comment",
            opt =>
            {
                opt.AutoReplenishment = true;
                opt.PermitLimit = 3;
                opt.Window = TimeSpan.FromMinutes(1);
                opt.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
                opt.QueueLimit = 2;
            }
        );
        // 前端遥测接口按客户端 IP 分区限流，避免匿名接口被滥用
        options.AddPolicy(
            "telemetry",
            httpContext =>
                RateLimitPartition.GetFixedWindowLimiter(
                    httpContext.Request.GetIpAddress(),
                    _ => new FixedWindowRateLimiterOptions
                    {
                        AutoReplenishment = true,
                        PermitLimit = 20,
                        Window = TimeSpan.FromMinutes(1),
                        QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
                        QueueLimit = 0,
                    }
                )
        );
    });

    services
        .AddWebMarkupMin(x =>
        {
            x.AllowMinificationInDevelopmentEnvironment = true;
            x.AllowCompressionInDevelopmentEnvironment = true;
        })
        .AddHtmlMinification(x =>
        {
            var settings = x.MinificationSettings;
            settings.RemoveOptionalEndTags = false;
        })
        .AddXmlMinification()
        .AddHttpCompression(option =>
        {
            /*
             * WebMarkupMin 默认把所有 text/* 媒体类型（见 MediaTypeHelpers.IsTextBasedMediaType）都纳入压缩范围。
             * 只有“既做 minify 又做压缩”的请求才会走缓冲分支：内容先写进 _cachedStream，压缩器在
             * FinishAsync（响应尚未开始）里才补 Content-Encoding / Vary。
             *
             * 而 JSON / text/plain / text/css 这类只压不 minify 的内容没有缓冲，WebMarkupMin 要等到第一次
             * WriteAsync 才写 Content-Encoding / Vary；此时 UseResponseCaching 已对底层流 DisableBuffering，
             * 响应已经开始 → HttpHeaders 只读 → InvalidOperationException: Headers are read-only。
             *
             * 所以这里把 WebMarkupMin 的压缩范围收敛到它真正会 minify 的媒体类型（HTML/XHTML/XML），
             * 其余类型统一交给上面的 AddResponseCompression 处理。
             */
            option.SupportedMediaTypePredicate = mediaType =>
                MediaTypeGroupConstants.Html.Contains(mediaType)
                || MediaTypeGroupConstants.Xhtml.Contains(mediaType)
                || MediaTypeGroupConstants.Xml.Contains(mediaType);

            option.CompressorFactories = new List<ICompressorFactory>
            {
                new BuiltInBrotliCompressorFactory(
                    new BuiltInBrotliCompressionSettings { Level = CompressionLevel.Optimal }
                ),
                new DeflateCompressorFactory(
                    new DeflateCompressionSettings { Level = CompressionLevel.Optimal }
                ),
                new GZipCompressorFactory(
                    new GZipCompressionSettings { Level = CompressionLevel.Optimal }
                ),
            };
        });

    // 设备识别
    services.AddDetection();
    // .AddDevice().AddBrowser()
    // .AddPlatform()
    // .AddEngine()
    // .AddCrawler();

    //注册 响应服务
    services.AddResponsive();

    //services.AddHostedService<TimedHostedService>();
    services.AddControllersWithViews();

    //注册 缓存中间件
    services.AddResponseCaching();

    var redisConnectionString =
        configuration.GetConnectionString("redis")
        ?? throw new Exception("configuration node redis is null or empty");
    services.AddBusinessServices(configuration);
    services.AddDefaultServices().AddInject().AddMessageQueueServices();

    // 注册限流服务
    services.AddIpRateLimit(configuration);

    // Cors
    services.AddCors(options =>
    {
        options.AddPolicy(
            corsScheme,
            cfg =>
            {
                cfg.WithOrigins(configuration.GetSection("Origins").Get<string[]>() ?? [])
                    .WithMethods("GET", "PUT", "POST", "DELETE", "PATCH", "OPTIONS")
                    .AllowAnyHeader();
            }
        );
    });

    //注册 身份认证服务
    services
        .AddAuthentication(x =>
        {
            x.DefaultAuthenticateScheme = AuthorizeCookieName;
            x.DefaultSignInScheme = AuthorizeCookieName;
            x.DefaultChallengeScheme = OpenIddictClientAspNetCoreDefaults.AuthenticationScheme;
        })
        .AddCookie(
            AuthorizeCookieName,
            options =>
            {
                options.LoginPath = "/connect/oidc";
                options.AccessDeniedPath = "/connect/oidc";
                options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
                options.Cookie.HttpOnly = true;
                options.Cookie.SameSite = SameSiteMode.Lax;
            }
        );

    //services.AddAuthorization(x => )

    services
        .AddIdentityCore<VmUserInfo>(x =>
            x.ClaimsIdentity.SecurityStampClaimType = AuthorizeCookieName
        )
        .AddUserStore<UserStore>()
        .AddSignInManager<ApplicationSignInManager>();
    services.AddDataProtection().SetApplicationName(AuthorizeCookieName);
    services
        .AddOptions<KeyManagementOptions>()
        .Configure<IServiceScopeFactory>(
            (options, factory) =>
            {
                options.XmlRepository = new XmlRepositoryService(
                    factory,
                    AuthorizeCookieName + ".Key"
                );
            }
        );

    services.AddOpenIddictClient(configuration);

    //register SignalR
    services
        .AddSignalR(x =>
        {
            x.HandshakeTimeout = TimeSpan.FromMinutes(2);
            x.MaximumReceiveMessageSize = 32768;
        })
        .AddStackExchangeRedis(
            redisConnectionString,
            options =>
            {
                options.Configuration.ChannelPrefix = RedisChannel.Literal("Dpz.Core.signalR");
            }
        );

    // 添加Hangfire 服务
    services.HangfireService(configuration);

    #endregion


    var app = builder.Build();

    #region configuration

    if (app.Environment.IsDevelopment())
    {
        //app.UseDeveloperExceptionPage();
        app.UseRouteDebugger();
    }
    app.UseHtmlErrorPages();
    app.UseForwardedHeaders();

    var supportedCultures = new[] { new CultureInfo("zh-CN") };
    app.UseRequestLocalization(
        new RequestLocalizationOptions
        {
            DefaultRequestCulture = new RequestCulture("zh-CN"),
            // Formatting numbers, dates, etc.
            SupportedCultures = supportedCultures,
            // UI strings that we have localized.
            SupportedUICultures = supportedCultures,
        }
    );

    var webRootStaticAssets = WebRootStaticAssets.Create(app.Services);

    app.UseSerilogRequestLogging(options =>
    {
        // wwwroot 下正常响应的静态资源请求不属于业务事件，降级到 Verbose（低于全局 Information，不进入任何 sink）
        // 4xx/5xx 保持默认级别，爬虫探测与静态资源故障仍可追溯
        options.GetLevel = (httpContext, _, exception) =>
        {
            var statusCode = httpContext.Response.StatusCode;
            if (
                exception == null
                && statusCode is >= 200 and <= 399
                && webRootStaticAssets.IsStaticAsset(httpContext.Request.Path)
            )
            {
                return LogEventLevel.Verbose;
            }

            return statusCode > 499 ? LogEventLevel.Error : LogEventLevel.Information;
        };

        options.EnrichDiagnosticContext = (diagnosticContext, httpContext) =>
        {
            diagnosticContext.Set("RequestHost", httpContext.Request.Host.Value);
            diagnosticContext.Set("RequestScheme", httpContext.Request.Scheme);
            diagnosticContext.Set("UserAgent", httpContext.Request.Headers.UserAgent.ToString());
            diagnosticContext.Set("IpAddress", httpContext.Request.GetIpAddress());

            var referer = httpContext.Request.Headers.Referer;
            if (!StringValues.IsNullOrEmpty(referer))
            {
                diagnosticContext.Set("Referer", referer);
            }
        };
    });

    //启用压缩
    app.UseResponseCompression();

    // 启用身份认证
    // 必须在限流和机器人拦截之前，已登录用户的放行判断才能生效
    app.UseAuthentication();

    // 添加IP限流中间件
    app.UseIpRateLimit();

    // 设备识别
    // 必须在 RejectBots 之前，浏览器版本判定依赖检测结果
    app.UseDetection();

    // 拒绝爬虫
    app.UseRejectBots();

    // app.UseHsts();
    // app.UseHttpsRedirection();

    //启用静态文件
    app.UseStaticFiles(
        new StaticFileOptions()
        {
            OnPrepareResponse = ctx =>
            {
                // 这些目录与文件体积小、访问频繁、内容基本不变，设置客户端缓存省掉重复下载
                // 文件名不带内容指纹，故不追加 immutable，只承诺 max-age 内复用
                var requestPath = ctx.Context.Request.Path;
                if (CacheableStaticPaths.Any(requestPath.StartsWithSegments))
                {
                    ctx.Context.Response.Headers.Append("Cache-Control", "public,max-age=2592000");
                    ctx.Context.Response.Headers.Append(
                        "Expires",
                        DateTime.UtcNow.AddDays(30).ToString("R", CultureInfo.InvariantCulture)
                    );
                }
            },
        }
    );

    // 根据跨应用资料变更标记，在当前请求上下文刷新用户 Cookie Claims
    // 放在静态文件之后，避免每个静态资源请求都访问用户资料缓存
    app.UseUserProfileRefresh();

    app.UseWebMarkupMin();

    //启用缓存中间件
    app.UseResponseCaching();

    //启用响应服务
    app.UseResponsive();

    app.UseCors(corsScheme);

    app.UseRouting().UseMiddleware<HttpResponseHeaderHandel>().UseRecordRequest();

    app.MapGet(
        "/ping",
        requestDelegate: async context =>
        {
            await context.Response.WriteAsJsonAsync(context.Request.Headers);
        }
    );

    app.UseDevToolsEndpoint();
    app.UseVersionEndpoint();

    //启用身份授权
    app.UseAuthorization();

    // 端点限流（EnableRateLimiting 特性依赖此中间件）
    app.UseRateLimiter();

    // 路由
    app.ConfigurationRoute();

    // 使用 hangfire UI,及周期性任务调度
    app.HangfireSetting();

    #endregion

    Log.Information("Starting web core host");

    app.Run();
}
catch (Exception ex)
{
    Console.Error.WriteLine(ex);
    Log.Fatal(ex, "Host terminated unexpectedly");
}

public partial class Program
{
    /// <summary>
    /// 身份认证Cookie名称
    /// </summary>
    public const string AuthorizeCookieName = "Dpz.Web.Core.Authoriza";

    /// <summary>
    /// library host
    /// </summary>
    public static string LibraryHost { get; private set; } = "";

    /// <summary>
    /// assets host
    /// </summary>
    public static string AssetsHost { get; private set; } = "";

    /// <summary>
    /// 需要设置客户端缓存的 wwwroot 目录与文件，内容基本不变但文件名不带内容指纹
    /// </summary>
    private static readonly PathString[] CacheableStaticPaths =
    [
        "/images",
        "/hanzi-data",
        "/data",
        "/favicon.ico",
        "/favicon.png",
    ];

    /// <summary>
    /// 任务调度面板地址
    /// </summary>
    public const string HangfireDashboardPath = "/runtask";
}