// Simple default policy
var provider = new ResiliencePolicyProvider()
    .WithDefaultPolicy(p => p
        .WithMaxAttempts(3)
        .WithExponentialDelay(TimeSpan.FromSeconds(1))
        .WithJitter());

// Get and use the policy
var policy = provider.GetPolicy();
await policy.ExecuteAsync(async ct => 
{
    // Your operation here
    await SomeUnreliableOperationAsync(ct);
});

var provider = new ResiliencePolicyProvider()
    .WithPolicy("database", p => p
        .WithMaxAttempts(5)
        .WithLinearDelay(TimeSpan.FromSeconds(2))
        .WithTimeout(TimeSpan.FromSeconds(30))
        .WithUnhandledException<InvalidOperationException>())
    .WithPolicy<MyService>(p => p
        .WithMaxAttempts(3)
        .WithExponentialDelay(TimeSpan.FromSeconds(1))
        .WithCircuitBreaker(cb => cb
            .WithFailureRatio(0.5)
            .WithMinimumCalls(10)
            .WithBreakDuration(TimeSpan.FromSeconds(30))));

// Use specific policies
var dbPolicy = provider.GetPolicy("database");
var apiPolicy = provider.GetPolicy<MyService>();

var policy = new ResiliencePolicyBuilder()
    .WithCircuitBreaker(cb => cb
        .WithSamplingDuration(TimeSpan.FromSeconds(60))
        .WithFailureRatio(0.1) // 10% failure rate
        .WithMinimumCalls(100) // At least 100 calls before opening
        .WithBreakDuration(TimeSpan.FromSeconds(30))); // Stay open for 30 seconds

var policy = new ResiliencePolicyBuilder()
    .WithShouldRetry((attempt, exception) => 
    {
        // Custom logic for determining if we should retry
        return exception is HttpRequestException && attempt <= 3;
    })
    .WithGetDelay(attempt => 
    {
        // Custom delay calculation
        return TimeSpan.FromMilliseconds(Math.Pow(2, attempt) * 100);
    });

// Example with a hypothetical service
public class MyService
{
    private readonly IResiliencePolicy _policy;
    
    public MyService(IResiliencePolicyProvider resiliencePolicyProvider)
    {
        _policy = _resiliencePolicyProvider.GetPolicy<MyService>();
    }
    
    public async Task DoWorkAsync()
    {
        await _policy.ExecuteAsync(async ct => 
        {
            // Resilient operation
        });
    }
}

// Before (Polly)
var policy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => 
        TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

await policy.ExecuteAsync(async () => await MyOperationAsync());

// After (Foundatio)
var policy = new ResiliencePolicy()
    .WithMaxAttempts(3)
    .WithExponentialDelay(TimeSpan.FromSeconds(1))
    .WithUnhandledException<ArgumentException>(); // Exclude unhandled types

await policy.ExecuteAsync(async ct => await MyOperationAsync());

using Polly;
using Foundatio.Utility;

// Custom Polly wrapper implementing Foundatio's IResiliencePolicy
public class PollyResiliencePolicy : IResiliencePolicy
{
    private readonly IAsyncPolicy _pollyPolicy;

    public PollyResiliencePolicy(IAsyncPolicy pollyPolicy)
    {
        _pollyPolicy = pollyPolicy;
    }

    public async Task ExecuteAsync(Func<CancellationToken, Task> operation, CancellationToken cancellationToken = default)
    {
        await _pollyPolicy.ExecuteAsync(async (ct) => await operation(ct), cancellationToken);
    }

    public async Task<T> ExecuteAsync<T>(Func<CancellationToken, Task<T>> operation, CancellationToken cancellationToken = default)
    {
        return await _pollyPolicy.ExecuteAsync(async (ct) => await operation(ct), cancellationToken);
    }
}

// Custom provider that uses Polly policies
public class PollyResiliencePolicyProvider : IResiliencePolicyProvider
{
    private readonly Dictionary<string, IResiliencePolicy> _policies = new();
    private readonly IResiliencePolicy _defaultPolicy;

    public PollyResiliencePolicyProvider()
    {
        // Create default Polly policy
        var defaultPollyPolicy = Policy
            .Handle<Exception>()
            .WaitAndRetryAsync(3, retryAttempt => 
                TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
        
        _defaultPolicy = new PollyResiliencePolicy(defaultPollyPolicy);

        // Create named Polly policies
        var dbPollyPolicy = Policy
            .Handle<SqlException>()
            .Or<TimeoutException>()
            .WaitAndRetryAsync(5, retryAttempt => 
                TimeSpan.FromSeconds(retryAttempt * 2));
        
        _policies["database"] = new PollyResiliencePolicy(dbPollyPolicy);

        // Polly circuit breaker example
        var apiPollyPolicy = Policy
            .Handle<HttpRequestException>()
            .CircuitBreakerAsync(
                handledEventsAllowedBeforeBreaking: 5,
                durationOfBreak: TimeSpan.FromSeconds(30));
        
        _policies["external-api"] = new PollyResiliencePolicy(apiPollyPolicy);
    }

    public IResiliencePolicy GetPolicy(string name = null)
    {
        if (string.IsNullOrEmpty(name))
            return _defaultPolicy;

        return _policies.TryGetValue(name, out var policy) ? policy : _defaultPolicy;
    }
}

// Register the Polly-based provider with dependency injection
services.AddSingleton<IResiliencePolicyProvider, PollyResiliencePolicyProvider>();

// Now all Foundatio components will use Polly policies
var cache = new InMemoryCacheClient(new InMemoryMessageBus(), provider);
var queue = new InMemoryQueue<MyWorkItem>(provider);
// etc.

var circuitBreaker = new CircuitBreaker();

// Manually open the circuit
circuitBreaker.Open();

// Check circuit state
if (circuitBreaker.State == CircuitState.Closed)
{
    // Safe to proceed
}

// Manually close the circuit
circuitBreaker.Close();

var policy = new ResiliencePolicyBuilder()
    .WithShouldRetry((attempt, ex) => 
    {
        // Retry for HTTP errors but not for auth errors
        return ex is HttpRequestException && 
               !ex.Message.Contains("401") && 
               attempt <= 3;
    });