builder.Services.AddHttpClient<IPaymentGateway, PaymentGateway>(client =>
{
    client.BaseAddress = new Uri("https://payment-api.example.com");
    client.Timeout     = TimeSpan.FromSeconds(30);
})
.AddStandardResilienceHandler();  // Вмикає: Retry + Circuit Breaker + Timeout

using Polly;
using Polly.Retry;

builder.Services.AddHttpClient<IWeatherService, WeatherService>()
    .AddResilienceHandler("weather-retry", pipelineBuilder =>
    {
        pipelineBuilder.AddRetry(new RetryStrategyOptions<HttpResponseMessage>
        {
            // Максимальна кількість повторів (не рахуючи перший запит)
            MaxRetryAttempts = 3,

            // Базова затримка між спробами (exponential: 1s, 2s, 4s)
            Delay = TimeSpan.FromSeconds(1),
            BackoffType = DelayBackoffType.Exponential,

            // Додаємо випадковий «шум» (jitter) щоб уникнути «thundering herd»
            // Усі клієнти одночасно не ретраються у той самий момент
            UseJitter = true,

            // Які помилки вважати «ретраблями»
            ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
                .Handle<HttpRequestException>()
                .Handle<TimeoutRejectedException>()
                .HandleResult(r => r.StatusCode == HttpStatusCode.ServiceUnavailable)
                .HandleResult(r => r.StatusCode == HttpStatusCode.TooManyRequests),

            // Колбек при кожній спробі
            OnRetry = static args =>
            {
                Console.WriteLine(
                    $"Retry #{args.AttemptNumber}. Delay: {args.RetryDelay.TotalSeconds:F1}s");
                return ValueTask.CompletedTask;
            }
        });
    });

pipelineBuilder.AddCircuitBreaker(new CircuitBreakerStrategyOptions<HttpResponseMessage>
{
    // Мінімальна кількість запитів для розрахунку відсотка помилок
    MinimumThroughput = 10,

    // Якщо більше 50% запитів за останні 30 секунд завершились збоєм — відкриваємо
    FailureRatio = 0.5,

    // Вікно спостереження (sampling window)
    SamplingDuration = TimeSpan.FromSeconds(30),

    // Скільки часу тримати circuit breaker відкритим
    BreakDuration = TimeSpan.FromSeconds(15),

    ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
        .Handle<HttpRequestException>()
        .HandleResult(r => r.StatusCode >= HttpStatusCode.InternalServerError),

    OnOpened = static args =>
    {
        Console.WriteLine(
            $"⚡ Circuit Breaker відкрито! Причина: {args.Outcome.Exception?.Message}");
        return ValueTask.CompletedTask;
    },

    OnClosed = static _ =>
    {
        Console.WriteLine("✅ Circuit Breaker закрито — сервіс відновився.");
        return ValueTask.CompletedTask;
    }
});

try
{
    var result = await _httpClient.GetAsync("/api/products");
    // ...
}
catch (BrokenCircuitException)
{
    // Circuit Breaker відкритий — повертаємо cached або дефолтне значення
    return _cache.Get<List<Product>>("products") ?? [];
}

pipelineBuilder.AddTimeout(new TimeoutStrategyOptions
{
    // Якщо після 5 секунд немає відповіді — скасовуємо
    Timeout = TimeSpan.FromSeconds(5),

    OnTimeout = static args =>
    {
        Console.WriteLine(
            $"⏱ Timeout! Операція тривала більше {args.Timeout.TotalSeconds}s");
        return ValueTask.CompletedTask;
    }
});

pipelineBuilder.AddFallback(new FallbackStrategyOptions<HttpResponseMessage>
{
    ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
        .Handle<TimeoutRejectedException>()
        .Handle<BrokenCircuitException>()
        .Handle<HttpRequestException>(),

    // Що повертати при збої
    FallbackAction = static args =>
    {
        var fallbackResponse = new HttpResponseMessage(HttpStatusCode.OK)
        {
            Content = new StringContent(
                """{"products": [], "source": "cache", "degraded": true}""",
                Encoding.UTF8, "application/json")
        };
        return ValueTask.FromResult(fallbackResponse);
    },

    OnFallback = static args =>
    {
        Console.WriteLine(
            $"⚠️ Fallback активовано. Причина: {args.Outcome.Exception?.Message}");
        return ValueTask.CompletedTask;
    }
});

builder.Services.AddHttpClient<IPaymentGateway, PaymentGateway>(client =>
    client.BaseAddress = new Uri("https://payment-api.example.com"))
.AddResilienceHandler("payment-pipeline", pipeline =>
{
    // 1. Fallback (зовнішній — перший що спрацює при будь-якій помилці)
    pipeline.AddFallback(new FallbackStrategyOptions<HttpResponseMessage>
    {
        ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
            .Handle<Exception>(),
        FallbackAction = _ =>
        {
            var r = new HttpResponseMessage(HttpStatusCode.ServiceUnavailable)
            {
                Content = new StringContent("""{"error": "Payment service unavailable"}""")
            };
            return ValueTask.FromResult(r);
        }
    });

    // 2. Circuit Breaker
    pipeline.AddCircuitBreaker(new CircuitBreakerStrategyOptions<HttpResponseMessage>
    {
        FailureRatio      = 0.5,
        MinimumThroughput = 5,
        SamplingDuration  = TimeSpan.FromSeconds(10),
        BreakDuration     = TimeSpan.FromSeconds(30)
    });

    // 3. Retry (внутрішній — виконується до Circuit Breaker)
    pipeline.AddRetry(new RetryStrategyOptions<HttpResponseMessage>
    {
        MaxRetryAttempts = 3,
        Delay            = TimeSpan.FromMilliseconds(500),
        BackoffType      = DelayBackoffType.Exponential,
        UseJitter        = true,
        ShouldHandle     = new PredicateBuilder<HttpResponseMessage>()
            .Handle<HttpRequestException>()
            .HandleResult(r => r.StatusCode == HttpStatusCode.ServiceUnavailable)
    });

    // 4. Timeout на кожну спробу (найвнутрішніший)
    pipeline.AddTimeout(TimeSpan.FromSeconds(5));
});

using Polly;
using Polly.Registry;

public class ResilientRedisService
{
    private readonly ResiliencePipeline _pipeline;
    private readonly IConnectionMultiplexer _redis;

    public ResilientRedisService(
        ResiliencePipelineProvider<string> pipelineProvider,
        IConnectionMultiplexer redis)
    {
        _pipeline = pipelineProvider.GetPipeline("redis-pipeline");
        _redis    = redis;
    }

    public async Task<string?> GetAsync(string key)
    {
        return await _pipeline.ExecuteAsync(async ct =>
        {
            var db    = _redis.GetDatabase();
            var value = await db.StringGetAsync(key);
            return (string?)value;
        });
    }
}

builder.Services.AddResiliencePipeline("redis-pipeline", (pipelineBuilder, _) =>
{
    pipelineBuilder
        .AddRetry(new RetryStrategyOptions
        {
            MaxRetryAttempts  = 3,
            Delay             = TimeSpan.FromMilliseconds(100),
            BackoffType       = DelayBackoffType.Exponential,
            ShouldHandle      = new PredicateBuilder()
                .Handle<RedisException>()
                .Handle<TimeoutException>()
        })
        .AddTimeout(TimeSpan.FromSeconds(2));
});