var builder = WebApplication.CreateBuilder(args);

// Реєстрація Health Checks
builder.Services.AddHealthChecks()
    // Вбудована перевірка БД через EF Core
    .AddDbContextCheck<AppDbContext>()
    // Перевірка доступності URL
    .AddUrlGroup(new Uri("https://api.example.com/ping"), "external-api");

var app = builder.Build();

// Базовий ендпоінт
app.MapHealthChecks("/health");

// Розширений ендпоінт з деталями (для внутрішнього моніторингу)
app.MapHealthChecks("/health/detail", new HealthCheckOptions
{
    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
});

app.Run();

{
  "status": "Healthy"
}

builder.Services.AddHealthChecks()
    // SQL Server / PostgreSQL
    .AddNpgSql(
        connectionString: builder.Configuration.GetConnectionString("Default")!,
        name:             "postgresql",
        tags:             ["database", "ready"])

    // Redis
    .AddRedis(
        redisConnectionString: builder.Configuration.GetConnectionString("Redis")!,
        name:                  "redis",
        tags:                  ["cache", "ready"])

    // Зовнішнє API
    .AddUrlGroup(
        uri:     new Uri("https://payment-api.example.com/health"),
        name:    "payment-api",
        tags:    ["external", "ready"])

    // Доступне місце на диску
    .AddDiskStorageHealthCheck(
        setup:  s => s.AddDrive("C:\\", minimumFreeMegabytes: 1024),
        name:   "disk-storage",
        tags:   ["infrastructure"]);

// Health Check UI
builder.Services.AddHealthChecksUI(setup =>
{
    setup.SetEvaluationTimeInSeconds(30);   // Перевірка кожні 30 секунд
    setup.MaximumHistoryEntriesPerEndpoint(50);
    setup.AddHealthCheckEndpoint("Production API", "/health/detail");
}).AddInMemoryStorage();

// Liveness: лише чи живий процес (без зовнішніх залежностей)
app.MapHealthChecks("/health/live", new HealthCheckOptions
{
    Predicate = _ => false  // Жодних перевірок — просто «я живий»
});

// Readiness: готовність приймати трафік (із залежностями)
app.MapHealthChecks("/health/ready", new HealthCheckOptions
{
    Predicate      = hc => hc.Tags.Contains("ready"),
    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
});

// Детальний звіт для внутрішнього моніторингу
app.MapHealthChecks("/health/detail", new HealthCheckOptions
{
    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
})
.RequireAuthorization();  // Захищаємо від публічного доступу

// UI Dashboard
app.MapHealthChecksUI(config => config.UIPath = "/health-ui");

using Microsoft.Extensions.Diagnostics.HealthChecks;

public class DatabaseMigrationHealthCheck : IHealthCheck
{
    private readonly AppDbContext _db;
    private readonly ILogger<DatabaseMigrationHealthCheck> _logger;

    public DatabaseMigrationHealthCheck(
        AppDbContext db,
        ILogger<DatabaseMigrationHealthCheck> logger)
    {
        _db     = db;
        _logger = logger;
    }

    public async Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context,
        CancellationToken ct = default)
    {
        try
        {
            // Перевіряємо, чи всі міграції застосовані
            var pendingMigrations = await _db.Database
                .GetPendingMigrationsAsync(ct);

            var pendingList = pendingMigrations.ToList();

            if (pendingList.Count == 0)
            {
                return HealthCheckResult.Healthy(
                    "Всі міграції застосовані.");
            }

            return HealthCheckResult.Degraded(
                description: $"Є {pendingList.Count} незастосованих міграцій.",
                data: new Dictionary<string, object>
                {
                    ["pendingMigrations"] = pendingList
                });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Помилка перевірки міграцій БД.");

            return HealthCheckResult.Unhealthy(
                description: "Не вдалося підключитися до БД.",
                exception:   ex);
        }
    }
}

public class LicenseValidityHealthCheck : IHealthCheck
{
    private readonly ILicenseService _licenseService;

    public LicenseValidityHealthCheck(ILicenseService licenseService)
        => _licenseService = licenseService;

    public async Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context,
        CancellationToken ct = default)
    {
        var license = await _licenseService.GetCurrentAsync();

        if (license is null)
            return HealthCheckResult.Unhealthy("Ліцензія не знайдена.");

        var daysUntilExpiry = (license.ExpiresAt - DateTime.UtcNow).TotalDays;

        return daysUntilExpiry switch
        {
            < 0   => HealthCheckResult.Unhealthy(
                         $"Ліцензія прострочена {Math.Abs(daysUntilExpiry):F0} днів тому."),
            < 7   => HealthCheckResult.Degraded(
                         $"Ліцензія спливає через {daysUntilExpiry:F0} днів!"),
            _     => HealthCheckResult.Healthy(
                         $"Ліцензія дійсна. Спливає через {daysUntilExpiry:F0} днів.")
        };
    }
}

builder.Services.AddHealthChecks()
    .AddCheck<DatabaseMigrationHealthCheck>(
        name: "db-migrations",
        tags: ["database", "ready"])
    .AddCheck<LicenseValidityHealthCheck>(
        name:               "license",
        failureStatus:      HealthStatus.Degraded,
        tags:               ["business"]);