// Program.cs - IIS 集成配置
var builder = WebApplication.CreateBuilder(args);

// 配置 Kestrel 和 IIS 集成
builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxRequestBodySize = 100 * 1024 * 1024; // 100MB
    options.Limits.RequestHeadersTimeout = TimeSpan.FromMinutes(2);
});

var app = builder.Build();

// 在 IIS 后面时，使用转发头部
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
    ForwardedHeaders = ForwardedHeaders.XForwardedFor
                     | ForwardedHeaders.XForwardedProto
});

app.Run();

// Program.cs - Kestrel 配置
var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    // HTTP 端口
    options.ListenAnyIP(5000);

    // HTTPS 端口
    options.ListenAnyIP(5001, listenOptions =>
    {
        listenOptions.UseHttps("/etc/ssl/certs/myapp.pfx", "password");
    });

    // 性能配置
    options.Limits.MaxConcurrentConnections = 1000;
    options.Limits.MaxConcurrentUpgradedConnections = 1000;
    options.Limits.MaxRequestBodySize = 50 * 1024 * 1024; // 50MB
    options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);
    options.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(30);
});

// Program.cs - 环境配置加载
var builder = WebApplication.CreateBuilder(args);

// 配置加载顺序（后加载的覆盖先加载的）
// 1. appsettings.json
// 2. appsettings.{Environment}.json
// 3. 用户机密（仅开发环境）
// 4. 环境变量
// 5. 命令行参数

builder.Configuration
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
    .AddJsonFile($"appsettings.{builder.Environment.EnvironmentName}.json",
        optional: true, reloadOnChange: true)
    .AddEnvironmentVariables()
    .AddCommandLine(args);

// 使用用户机密（开发环境）
// dotnet user-secrets init
// dotnet user-secrets set "ConnectionStrings:Default" "Server=..."

// 使用 Azure Key Vault（生产环境）
builder.Configuration.AddAzureKeyVault(
    new Uri("https://myapp-vault.vault.azure.net/"),
    new DefaultAzureCredential());

// 使用环境变量覆盖配置
// export ConnectionStrings__Default="Server=prod-db;..."
// export Redis__Connection="prod-redis:6379"

// Program.cs - 健康检查配置
builder.Services.AddHealthChecks()
    // 数据库健康检查
    .AddNpgSql(
        builder.Configuration.GetConnectionString("Default")!,
        name: "postgresql",
        tags: new[] { "db", "critical" })
    // Redis 健康检查
    .AddRedis(
        builder.Configuration["Redis:Connection"]!,
        name: "redis",
        tags: new[] { "cache", "critical" })
    // 自定义健康检查
    .AddCheck<DiskSpaceHealthCheck>(
        "disk-space",
        tags: new[] { "infrastructure" })
    // 外部 API 健康检查
    .AddUrlGroup(
        new Uri("https://api.example.com/health"),
        name: "external-api",
        tags: new[] { "external" });

var app = builder.Build();

// 映射健康检查端点
app.MapHealthChecks("/health", new HealthCheckOptions
{
    Predicate = _ => true,
    ResponseWriter = WriteHealthCheckResponse
});

// 就绪检查（仅检查关键依赖）
app.MapHealthChecks("/health/ready", new HealthCheckOptions
{
    Predicate = check => check.Tags.Contains("critical"),
    ResponseWriter = WriteHealthCheckResponse
});

// 存活检查
app.MapHealthChecks("/health/live", new HealthCheckOptions
{
    Predicate = _ => false  // 不检查任何依赖，仅确认应用存活
});

/// <summary>
/// 磁盘空间健康检查
/// </summary>
public class DiskSpaceHealthCheck : IHealthCheck
{
    private readonly long _minimumFreeMB;

    public DiskSpaceHealthCheck(long minimumFreeMB = 500)
    {
        _minimumFreeMB = minimumFreeMB;
    }

    public Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context,
        CancellationToken cancellationToken = default)
    {
        var drives = DriveInfo.GetDrives()
            .Where(d => d.IsReady && d.DriveType == DriveType.Fixed);

        foreach (var drive in drives)
        {
            var freeMB = drive.AvailableFreeSpace / (1024 * 1024);
            if (freeMB < _minimumFreeMB)
            {
                return Task.FromResult(HealthCheckResult.Unhealthy(
                    $"磁盘 {drive.Name} 空间不足: {freeMB}MB 剩余" +
                    $"（最低要求: {_minimumFreeMB}MB）"));
            }
        }

        return Task.FromResult(HealthCheckResult.Healthy("磁盘空间充足"));
    }
}

/// <summary>
/// 健康检查响应格式化
/// </summary>
static async Task WriteHealthCheckResponse(
    HttpContext context, HealthReport report)
{
    context.Response.ContentType = "application/json";

    var response = new
    {
        Status = report.Status.ToString(),
        TotalDuration = report.TotalDuration.TotalMilliseconds + "ms",
        Checks = report.Entries.Select(e => new
        {
            Name = e.Key,
            Status = e.Value.Status.ToString(),
            Duration = e.Value.Duration.TotalMilliseconds + "ms",
            Description = e.Value.Description,
            Error = e.Value.Exception?.Message
        })
    };

    await context.Response.WriteAsJsonAsync(response);
}

// 安装 NuGet 包
// dotnet add package prometheus-net.AspNetCore

// Program.cs - 配置 Prometheus 指标
using Prometheus;

var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

// 启用 HTTP 请求指标收集
app.UseHttpMetrics();

// 暴露 Prometheus 指标端点
app.MapMetrics();  // 默认路径: /metrics

app.Run();

/// <summary>
/// 业务指标收集服务
/// </summary>
public class BusinessMetricsService
{
    // 订单创建计数器
    private static readonly Counter OrderCreatedCounter = Metrics
        .CreateCounter("myapp_orders_created_total", "创建的订单总数",
            new CounterConfiguration
            {
                LabelNames = new[] { "payment_method" }
            });

    // 请求处理时间直方图
    private static readonly Histogram RequestDuration = Metrics
        .CreateHistogram("myapp_request_duration_seconds", "请求处理时间",
            new HistogramConfiguration
            {
                LabelNames = new[] { "endpoint" },
                Buckets = Histogram.LinearBuckets(0.1, 0.1, 10)
            });

    // 在线用户数仪表盘
    private static readonly Gauge OnlineUsers = Metrics
        .CreateGauge("myapp_online_users", "当前在线用户数");

    public void RecordOrderCreated(string paymentMethod)
    {
        OrderCreatedCounter.WithLabels(paymentMethod).Inc();
    }

    public IDisposable MeasureRequestDuration(string endpoint)
    {
        return RequestDuration.WithLabels(endpoint).NewTimer();
    }

    public void SetOnlineUsers(int count)
    {
        OnlineUsers.Set(count);
    }
}

// 安装 NuGet 包
// dotnet add package Serilog.AspNetCore
// dotnet add package Serilog.Sinks.File
// dotnet add package Serilog.Sinks.Seq

// Program.cs - Serilog 配置
using Serilog;

Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Information()
    .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
    .Enrich.FromLogContext()
    .Enrich.WithMachineName()
    .Enrich.WithEnvironmentName()
    // 控制台输出
    .WriteTo.Console()
    // 文件输出（按日期滚动）
    .WriteTo.File(
        path: "logs/myapp-.log",
        rollingInterval: RollingInterval.Day,
        retainedFileCountLimit: 30,
        outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff} " +
            "[{Level:u3}] {Message:lj}{NewLine}{Exception}")
    // Seq 集中日志平台
    .WriteTo.Seq("http://localhost:5341")
    .CreateLogger();

var builder = WebApplication.CreateBuilder(args);
builder.Host.UseSerilog();

var app = builder.Build();

// 请求日志中间件
app.UseSerilogRequestLogging(options =>
{
    options.MessageTemplate =
        "HTTP {RequestMethod} {RequestPath} 响应 {StatusCode} 耗时 {Elapsed:0.0000}ms";
});

app.Run();

// 响应压缩配置
builder.Services.AddResponseCompression(options =>
{
    options.EnableForHttps = true;
    options.Providers.Add<BrotliCompressionProvider>();
    options.Providers.Add<GzipCompressionProvider>();
});

builder.Services.Configure<BrotliCompressionProviderOptions>(options =>
{
    options.Level = CompressionLevel.Fastest;
});

app.UseResponseCompression();

// Program.cs - 安全加固配置
var app = builder.Build();

// HTTPS 重定向
app.UseHttpsRedirection();

// HSTS（HTTP Strict Transport Security）
app.UseHsts();

// 安全头部
app.Use(async (context, next) =>
{
    context.Response.Headers["X-Content-Type-Options"] = "nosniff";
    context.Response.Headers["X-Frame-Options"] = "DENY";
    context.Response.Headers["X-XSS-Protection"] = "1; mode=block";
    context.Response.Headers["Referrer-Policy"] = "strict-origin-when-cross-origin";
    context.Response.Headers["Content-Security-Policy"] = "default-src 'self'";
    context.Response.Headers.Remove("Server");
    context.Response.Headers.Remove("X-Powered-By");
    await next();
});

// 速率限制
builder.Services.AddRateLimiter(options =>
{
    options.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, string>(
        context => RateLimitPartition.GetFixedWindowLimiter(
            partitionKey: context.Connection.RemoteIpAddress?.ToString() ?? "unknown",
            factory: _ => new FixedWindowRateLimiterOptions
            {
                AutoReplenishment = true,
                PermitLimit = 100,
                Window = TimeSpan.FromMinutes(1)
            }));

    options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
});

app.UseRateLimiter();

// 使用达梦数据库（DM8）
// dotnet add package Dm

// 配置达梦数据库连接
builder.Services.AddDbContext<DefaultDbContext>(options =>
{
    options.UseDm(builder.Configuration.GetConnectionString("DmDatabase"));
});