var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDaprClient();

var app = builder.Build();

public class OrderService
{
    private readonly DaprClient _daprClient;

    public OrderService(DaprClient daprClient)
    {
        _daprClient = daprClient;
    }

    // Appel POST avec body et réponse typée
    public async Task<OrderConfirmation> CreateOrderAsync(Order order)
    {
        return await _daprClient.InvokeMethodAsync<Order, OrderConfirmation>(
            HttpMethod.Post,
            "order-service",   // app-id du service cible
            "orders",          // route de l'endpoint
            order);            // body de la requête
    }

    // Appel GET avec réponse typée
    public async Task<WeatherForecast[]> GetWeatherAsync()
    {
        return await _daprClient.InvokeMethodAsync<WeatherForecast[]>(
            HttpMethod.Get,
            "weather-api",
            "weatherforecast");
    }

    // Appel sans réponse (fire and forget)
    public async Task NotifyAsync(Notification notification)
    {
        await _daprClient.InvokeMethodAsync(
            "notification-service",
            "notify",
            notification);
    }
}

try
{
    var result = await _daprClient.InvokeMethodAsync<Order, OrderConfirmation>(
        HttpMethod.Post, "order-service", "orders", order);
}
catch (InvocationException ex)
{
    Console.WriteLine($"Erreur {ex.Response.StatusCode} lors de l'appel à order-service");
    var body = await ex.Response.Content.ReadAsStringAsync();
    Console.WriteLine($"Détail : {body}");
}

builder.Services.AddSingleton(sp =>
    new DaprClientBuilder().Build().CreateInvokeHttpClient("order-service"));

public class OrderService
{
    private readonly HttpClient _httpClient;

    public OrderService(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public async Task<OrderConfirmation?> CreateOrderAsync(Order order)
    {
        var response = await _httpClient.PostAsJsonAsync("/orders", order);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<OrderConfirmation>();
    }

    public async Task<WeatherForecast[]?> GetWeatherAsync()
    {
        return await _httpClient.GetFromJsonAsync<WeatherForecast[]>("/weatherforecast");
    }
}

builder.Services.AddHttpClient("order-service", client =>
{
    // Le base address pointe vers le sidecar Dapr
    // DAPR_HTTP_PORT est 3500 par défaut
    var daprPort = Environment.GetEnvironmentVariable("DAPR_HTTP_PORT") ?? "3500";
    client.BaseAddress = new Uri($"http://localhost:{daprPort}/v1.0/invoke/order-service/method/");
});

public class OrderService
{
    private readonly HttpClient _httpClient;

    public OrderService(IHttpClientFactory httpClientFactory)
    {
        _httpClient = httpClientFactory.CreateClient("order-service");
    }

    public async Task<OrderConfirmation?> CreateOrderAsync(Order order)
    {
        // L'URL relative est ajoutée au base address
        // → http://localhost:3500/v1.0/invoke/order-service/method/orders
        var response = await _httpClient.PostAsJsonAsync("orders", order);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<OrderConfirmation>();
    }
}

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/weatherforecast", () =>
{
    var forecasts = Enumerable.Range(1, 5).Select(i => new WeatherForecast
    {
        Date = DateOnly.FromDateTime(DateTime.Now.AddDays(i)),
        TemperatureC = Random.Shared.Next(-20, 55),
        Summary = "Sunny"
    });
    return forecasts;
});

app.MapPost("/orders", (Order order) =>
{
    // Traitement de la commande...
    return Results.Ok(new OrderConfirmation
    {
        OrderId = Guid.NewGuid(),
        Status = "Created"
    });
});

app.Run();

var builder = DistributedApplication.CreateBuilder(args);

var weatherApi = builder.AddProject<Projects.WeatherApi>("weather-api")
    .WithDaprSidecar();

var orderService = builder.AddProject<Projects.OrderService>("order-service")
    .WithDaprSidecar();

builder.AddProject<Projects.Frontend>("frontend")
    .WithDaprSidecar()
    .WithReference(weatherApi)
    .WithReference(orderService);

builder.Build().Run();

builder.Services.AddDaprClient(daprBuilder =>
{
    daprBuilder.UseGrpcEndpoint("http://localhost:50001");
});

using Grpc.Core;
using ProductService;

namespace ProductService.Services;

public class ProductCatalogService : ProductCatalog.ProductCatalogBase
{
    private static readonly List<ProductReply> _products =
    [
        new() { ProductId = 1, Name = "Clavier mécanique", Description = "Clavier RGB switches red", Price = 89.99, InStock = true },
        new() { ProductId = 2, Name = "Souris gaming", Description = "Souris sans fil 25000 DPI", Price = 59.99, InStock = true },
        new() { ProductId = 3, Name = "Écran 27 pouces", Description = "Écran 4K IPS 144Hz", Price = 449.99, InStock = false }
    ];

    public override Task<ProductReply> GetProduct(GetProductRequest request, ServerCallContext context)
    {
        var product = _products.FirstOrDefault(p => p.ProductId == request.ProductId);

        if (product is null)
        {
            throw new RpcException(new Status(StatusCode.NotFound,
                $"Produit {request.ProductId} introuvable"));
        }

        return Task.FromResult(product);
    }

    public override Task<GetProductsReply> GetProducts(GetProductsRequest request, ServerCallContext context)
    {
        var reply = new GetProductsReply();
        reply.Products.AddRange(_products);
        return Task.FromResult(reply);
    }
}

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddGrpc();

var app = builder.Build();

app.MapGrpcService<ProductCatalogService>();

app.Run();

using Dapr.Client;
using ProductService;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDaprClient();

var app = builder.Build();

// GET /products → liste tous les produits via Dapr + gRPC
app.MapGet("/products", async (DaprClient daprClient) =>
{
    var request = daprClient.CreateInvokeMethodRequest(
        HttpMethod.Post,
        "product-service",
        "product.ProductCatalog/GetProducts");

    // Sérialiser le body Protobuf en bytes
    var protoRequest = new GetProductsRequest();
    request.Content = new ByteArrayContent(protoRequest.ToByteArray());
    request.Content.Headers.ContentType =
        new System.Net.Http.Headers.MediaTypeHeaderValue("application/grpc");

    var response = await daprClient.InvokeMethodAsync<GetProductsReply>(
        "product-service",
        "product.ProductCatalog/GetProducts");

    return response.Products.Select(p => new
    {
        p.ProductId,
        p.Name,
        p.Description,
        p.Price,
        p.InStock
    });
});

app.Run();

using Grpc.Core;
using Grpc.Net.Client;
using ProductService;

var builder = WebApplication.CreateBuilder(args);

// Créer le channel gRPC vers le sidecar Dapr
var daprGrpcPort = Environment.GetEnvironmentVariable("DAPR_GRPC_PORT") ?? "50001";
var channel = GrpcChannel.ForAddress($"http://localhost:{daprGrpcPort}");

// Enregistrer le client gRPC typé
builder.Services.AddSingleton(new ProductCatalog.ProductCatalogClient(channel));

var app = builder.Build();

app.MapGet("/products/{id:int}", async (int id, ProductCatalog.ProductCatalogClient client) =>
{
    // Ajouter le header dapr-app-id pour cibler le bon service
    var headers = new Metadata
    {
        { "dapr-app-id", "product-service" }
    };

    try
    {
        var reply = await client.GetProductAsync(
            new GetProductRequest { ProductId = id },
            headers);

        return Results.Ok(new
        {
            reply.ProductId,
            reply.Name,
            reply.Description,
            reply.Price,
            reply.InStock
        });
    }
    catch (RpcException ex) when (ex.StatusCode == StatusCode.NotFound)
    {
        return Results.NotFound(new { Message = ex.Status.Detail });
    }
});

app.MapGet("/products", async (ProductCatalog.ProductCatalogClient client) =>
{
    var headers = new Metadata
    {
        { "dapr-app-id", "product-service" }
    };

    var reply = await client.GetProductsAsync(
        new GetProductsRequest(),
        headers);

    return reply.Products.Select(p => new
    {
        p.ProductId,
        p.Name,
        p.Description,
        p.Price,
        p.InStock
    });
});

app.Run();

using Grpc.Core;
using ProductService;

var builder = WebApplication.CreateBuilder(args);

var daprGrpcPort = Environment.GetEnvironmentVariable("DAPR_GRPC_PORT") ?? "50001";

// Enregistrer le client gRPC via la factory
builder.Services
    .AddGrpcClient<ProductCatalog.ProductCatalogClient>(options =>
    {
        options.Address = new Uri($"http://localhost:{daprGrpcPort}");
    })
    .AddCallCredentials((context, metadata) =>
    {
        // Ajouter le header dapr-app-id automatiquement à chaque appel
        metadata.Add("dapr-app-id", "product-service");
        return Task.CompletedTask;
    });

var app = builder.Build();

// Les endpoints sont plus simples : plus besoin de gérer le header manuellement
app.MapGet("/products/{id:int}", async (int id, ProductCatalog.ProductCatalogClient client) =>
{
    try
    {
        var reply = await client.GetProductAsync(
            new GetProductRequest { ProductId = id });

        return Results.Ok(new
        {
            reply.ProductId,
            reply.Name,
            reply.Description,
            reply.Price,
            reply.InStock
        });
    }
    catch (RpcException ex) when (ex.StatusCode == StatusCode.NotFound)
    {
        return Results.NotFound(new { Message = ex.Status.Detail });
    }
});

app.MapGet("/products", async (ProductCatalog.ProductCatalogClient client) =>
{
    var reply = await client.GetProductsAsync(new GetProductsRequest());

    return reply.Products.Select(p => new
    {
        p.ProductId,
        p.Name,
        p.Description,
        p.Price,
        p.InStock
    });
});

app.Run();

var builder = DistributedApplication.CreateBuilder(args);

var productService = builder.AddProject<Projects.ProductService>("product-service")
    .WithDaprSidecar(new DaprSidecarOptions
    {
        AppProtocol = "grpc"
    });

builder.AddProject<Projects.ShopFrontend>("shop-frontend")
    .WithDaprSidecar()
    .WithReference(productService);

builder.Build().Run();

throw new RpcException(new Status(StatusCode.NotFound, "Produit introuvable"));

try
{
    var reply = await client.GetProductAsync(request);
}
catch (RpcException ex) when (ex.StatusCode == StatusCode.NotFound)
{
    // Gérer le 404
}
catch (RpcException ex) when (ex.StatusCode == StatusCode.Unavailable)
{
    // Le service est down
}

var client = new DaprClientBuilder().Build();

var order = new Order { ProductId = 42, Quantity = 2 };
var result = await client.InvokeMethodAsync<Order, OrderConfirmation>(
    "order-service", "create", order);

// Sauvegarder un état
await client.SaveStateAsync("statestore", "order-42", order);

// Lire un état
var saved = await client.GetStateAsync<Order>("statestore", "order-42");

// Supprimer un état
await client.DeleteStateAsync("statestore", "order-42");

await client.PublishEventAsync("pubsub", "orders", new OrderCreated
{
    OrderId = 42,
    CreatedAt = DateTime.UtcNow
});

app.MapPost("/orders", [Topic("pubsub", "orders")] (OrderCreated evt) =>
{
    Console.WriteLine($"Commande reçue : {evt.OrderId}");
    return Results.Ok();
});

// Output binding : envoyer un email via SendGrid
await client.InvokeBindingAsync("sendgrid", "create", new
{
    To = "user@example.com",
    Subject = "Confirmation",
    Body = "Votre commande a été validée."
});

var secret = await client.GetSecretAsync("vault", "db-connection-string");
var connectionString = secret["db-connection-string"];

public interface IOrderActor : IActor
{
    Task SubmitOrder(Order order);
    Task<OrderStatus> GetStatus();
}

public class OrderActor : Actor, IOrderActor
{
    public OrderActor(ActorHost host) : base(host) { }

    public async Task SubmitOrder(Order order)
    {
        await StateManager.SetStateAsync("order", order);
    }

    public async Task<OrderStatus> GetStatus()
    {
        return await StateManager.GetStateAsync<OrderStatus>("order");
    }
}

var builder = WebApplication.CreateBuilder(args);

// Ajouter les services Dapr
builder.Services.AddDaprClient();

var app = builder.Build();

// Activer le middleware Dapr (CloudEvents, Pub/Sub)
app.UseCloudEvents();
app.MapSubscribeHandler();

app.MapPost("/orders", [Topic("pubsub", "orders")] (OrderCreated evt) =>
{
    Console.WriteLine($"Commande reçue : {evt.OrderId}");
    return Results.Ok();
});

app.Run();

var builder = DistributedApplication.CreateBuilder(args);

var stateStore = builder.AddDaprStateStore("statestore");
var pubSub = builder.AddDaprPubSub("pubsub");

builder.AddProject<Projects.OrderService>("order-service")
    .WithDaprSidecar()
    .WithReference(stateStore)
    .WithReference(pubSub);

builder.Build().Run();

// ❌ Sans résilience : une erreur réseau = une erreur utilisateur
public async Task<Client> GetClientAsync(int id)
{
    var response = await httpClient.GetAsync($"/api/clients/{id}");
    response.EnsureSuccessStatusCode(); // lève une exception si 5xx
    return await response.Content.ReadFromJsonAsync<Client>();
}

// ✅ Avec Polly : retry automatique sur erreurs transitoires
var pipeline = new ResiliencePipelineBuilder<HttpResponseMessage>()
    .AddRetry(new RetryStrategyOptions<HttpResponseMessage>
    {
        MaxRetryAttempts = 3,
        Delay = TimeSpan.FromMilliseconds(500),
        BackoffType = DelayBackoffType.Exponential,
        ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
            .HandleResult(r => r.StatusCode == HttpStatusCode.ServiceUnavailable)
    })
    .Build();

var pipeline = new ResiliencePipelineBuilder()
    .AddRetry(new RetryStrategyOptions
    {
        MaxRetryAttempts = 3,               // 3 tentatives max
        Delay = TimeSpan.FromSeconds(1),    // délai initial
        BackoffType = DelayBackoffType.Exponential, // 1s, 2s, 4s
        UseJitter = true,                   // ajoute un aléa pour éviter les "thundering herds"
        OnRetry = args =>
        {
            Console.WriteLine($"Retry #{args.AttemptNumber} après {args.RetryDelay}");
            return ValueTask.CompletedTask;
        }
    })
    .Build();

// Utilisation
var result = await pipeline.ExecuteAsync(async ct =>
{
    return await httpClient.GetStringAsync("https://api.example.com/data", ct);
});

var pipeline = new ResiliencePipelineBuilder()
    .AddCircuitBreaker(new CircuitBreakerStrategyOptions
    {
        FailureRatio = 0.5,                          // 50% d'échecs déclenche l'ouverture
        MinimumThroughput = 10,                       // au moins 10 appels avant d'évaluer
        SamplingDuration = TimeSpan.FromSeconds(30),  // fenêtre d'évaluation
        BreakDuration = TimeSpan.FromSeconds(15),     // durée du circuit ouvert
        OnOpened = args =>
        {
            Console.WriteLine($"Circuit OUVERT pour {args.BreakDuration}");
            return ValueTask.CompletedTask;
        },
        OnClosed = _ =>
        {
            Console.WriteLine("Circuit FERMÉ");
            return ValueTask.CompletedTask;
        }
    })
    .Build();

var pipeline = new ResiliencePipelineBuilder()
    .AddTimeout(new TimeoutStrategyOptions
    {
        Timeout = TimeSpan.FromSeconds(5),
        OnTimeout = args =>
        {
            Console.WriteLine($"Timeout après {args.Timeout}");
            return ValueTask.CompletedTask;
        }
    })
    .Build();

var pipeline = new ResiliencePipelineBuilder()
    // Timeout global : 30s pour l'ensemble (retries inclus)
    .AddTimeout(new TimeoutStrategyOptions
    {
        Timeout = TimeSpan.FromSeconds(30)
    })
    .AddRetry(new RetryStrategyOptions
    {
        MaxRetryAttempts = 3,
        Delay = TimeSpan.FromSeconds(1),
        BackoffType = DelayBackoffType.Exponential
    })
    // Timeout par tentative : 5s max par appel individuel
    .AddTimeout(new TimeoutStrategyOptions
    {
        Timeout = TimeSpan.FromSeconds(5)
    })
    .Build();

var pipeline = new ResiliencePipelineBuilder<HttpResponseMessage>()
    .AddFallback(new FallbackStrategyOptions<HttpResponseMessage>
    {
        FallbackAction = args =>
        {
            var fallbackResponse = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent("[]") // liste vide comme fallback
            };
            return Outcome.FromResultAsValueTask(fallbackResponse);
        },
        ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
            .Handle<HttpRequestException>()
            .Handle<TimeoutRejectedException>()
            .HandleResult(r => !r.IsSuccessStatusCode)
    })
    .Build();

var pipeline = new ResiliencePipelineBuilder()
    .AddRateLimiter(new SlidingWindowRateLimiter(
        new SlidingWindowRateLimiterOptions
        {
            PermitLimit = 100,                           // 100 appels max
            Window = TimeSpan.FromMinutes(1),            // par minute
            SegmentsPerWindow = 6,                       // 6 segments de 10s
            QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
            QueueLimit = 10                              // 10 appels en file d'attente max
        }))
    .Build();

var pipeline = new ResiliencePipelineBuilder<HttpResponseMessage>()
    // 1. Fallback (le plus externe) : valeur de repli si tout échoue
    .AddFallback(new FallbackStrategyOptions<HttpResponseMessage>
    {
        FallbackAction = _ => Outcome.FromResultAsValueTask(
            new HttpResponseMessage(HttpStatusCode.OK)
            { Content = new StringContent("{\"cache\": true}") }),
        ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
            .Handle<Exception>()
    })
    // 2. Timeout global : 30s pour l'ensemble
    .AddTimeout(TimeSpan.FromSeconds(30))
    // 3. Retry : 3 tentatives avec backoff
    .AddRetry(new RetryStrategyOptions<HttpResponseMessage>
    {
        MaxRetryAttempts = 3,
        Delay = TimeSpan.FromSeconds(1),
        BackoffType = DelayBackoffType.Exponential,
        ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
            .Handle<HttpRequestException>()
            .HandleResult(r => r.StatusCode >= HttpStatusCode.InternalServerError)
    })
    // 4. Circuit breaker : coupe si trop d'échecs
    .AddCircuitBreaker(new CircuitBreakerStrategyOptions<HttpResponseMessage>
    {
        FailureRatio = 0.5,
        MinimumThroughput = 10,
        SamplingDuration = TimeSpan.FromSeconds(30),
        BreakDuration = TimeSpan.FromSeconds(15),
        ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
            .Handle<HttpRequestException>()
            .HandleResult(r => r.StatusCode >= HttpStatusCode.InternalServerError)
    })
    // 5. Timeout par tentative : 5s max par appel
    .AddTimeout(TimeSpan.FromSeconds(5))
    .Build();

builder.Services
    .AddHttpClient("CatalogueApi", client =>
    {
        client.BaseAddress = new Uri("https://api.catalogue.com");
    })
    .AddStandardResilienceHandler(); // pipeline de résilience standard

builder.Services
    .AddHttpClient("CatalogueApi", client =>
    {
        client.BaseAddress = new Uri("https://api.catalogue.com");
    })
    .AddStandardResilienceHandler(options =>
    {
        options.Retry.MaxRetryAttempts = 5;
        options.Retry.Delay = TimeSpan.FromMilliseconds(500);
        options.CircuitBreaker.BreakDuration = TimeSpan.FromSeconds(30);
        options.AttemptTimeout.Timeout = TimeSpan.FromSeconds(3);
        options.TotalRequestTimeout.Timeout = TimeSpan.FromSeconds(60);
    });

public class CatalogueService
{
    private readonly HttpClient _httpClient;

    public CatalogueService(IHttpClientFactory factory)
    {
        _httpClient = factory.CreateClient("CatalogueApi");
    }

    public async Task<List<Produit>> GetProduitsAsync(CancellationToken ct = default)
    {
        // Les stratégies de résilience sont appliquées automatiquement
        var response = await _httpClient.GetAsync("/api/produits", ct);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<List<Produit>>(ct) ?? [];
    }
}

// Enregistrement
builder.Services
    .AddHttpClient<CatalogueService>(client =>
    {
        client.BaseAddress = new Uri("https://api.catalogue.com");
    })
    .AddStandardResilienceHandler();

// Le service reçoit directement un HttpClient configuré
public class CatalogueService(HttpClient httpClient)
{
    public async Task<List<Produit>> GetProduitsAsync(CancellationToken ct = default)
    {
        return await httpClient.GetFromJsonAsync<List<Produit>>("/api/produits", ct) ?? [];
    }
}

// Enregistrement d'un pipeline nommé
builder.Services.AddResiliencePipeline("database", builder =>
{
    builder
        .AddRetry(new RetryStrategyOptions
        {
            MaxRetryAttempts = 3,
            Delay = TimeSpan.FromMilliseconds(200),
            BackoffType = DelayBackoffType.Exponential,
            ShouldHandle = new PredicateBuilder()
                .Handle<SqlException>(ex => ex.IsTransient)
        })
        .AddTimeout(TimeSpan.FromSeconds(10));
});

// Utilisation via injection
public class CommandeRepository(ResiliencePipelineProvider<string> pipelineProvider)
{
    public async Task<Commande?> GetByIdAsync(int id, CancellationToken ct = default)
    {
        var pipeline = pipelineProvider.GetPipeline("database");

        return await pipeline.ExecuteAsync(async token =>
        {
            return await dbContext.Commandes.FindAsync([id], token);
        }, ct);
    }
}

// Les métriques sont émises automatiquement
// Compteurs disponibles :
// - polly.strategy.attempt.duration   (durée de chaque tentative)
// - polly.strategy.pipeline.duration  (durée totale du pipeline)
// - polly.strategy.attempt.count      (nombre de tentatives)

// Pour activer les métriques dans OpenTelemetry :
builder.Services.AddOpenTelemetry()
    .WithMetrics(metrics =>
    {
        metrics.AddMeter("Polly"); // active les métriques Polly
    });

// ❌ Sans jitter : tous les clients réessaient au même instant
.AddRetry(new RetryStrategyOptions
{
    Delay = TimeSpan.FromSeconds(2),
    BackoffType = DelayBackoffType.Exponential,
    UseJitter = false // ← thundering herd
})

// ✅ Avec jitter : les retries sont désynchronisés
.AddRetry(new RetryStrategyOptions
{
    Delay = TimeSpan.FromSeconds(2),
    BackoffType = DelayBackoffType.Exponential,
    UseJitter = true // ← les délais varient aléatoirement
})

// ❌ Retrier une erreur 400 Bad Request n'a aucun sens
.AddRetry(new RetryStrategyOptions<HttpResponseMessage>
{
    ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
        .HandleResult(r => !r.IsSuccessStatusCode) // ← inclut les 400, 401, 404...
})

// ✅ Retrier uniquement les erreurs transitoires (5xx, timeout)
.AddRetry(new RetryStrategyOptions<HttpResponseMessage>
{
    ShouldHandle = new PredicateBuilder<HttpResponseMessage>()
        .Handle<HttpRequestException>()
        .Handle<TimeoutRejectedException>()
        .HandleResult(r => r.StatusCode >= HttpStatusCode.InternalServerError)
        .HandleResult(r => r.StatusCode == HttpStatusCode.RequestTimeout)
        .HandleResult(r => r.StatusCode == HttpStatusCode.TooManyRequests)
})

// ✅ Toujours passer le CancellationToken à travers le pipeline
var result = await pipeline.ExecuteAsync(
    async ct => await httpClient.GetAsync(url, ct),
    cancellationToken  // ← permet l'annulation depuis l'appelant
);

// ✅ Le circuit breaker protège le service en panne
// Le retry gère les erreurs ponctuelles
.AddRetry(...)
.AddCircuitBreaker(...)

// ❌ Synchrone : le thread est bloqué pendant toute la durée de l'appel HTTP
public IActionResult GetData()
{
    var client = new HttpClient();
    var response = client.Send(new HttpRequestMessage(HttpMethod.Get, "https://api.example.com/data"));
    var content = new StreamReader(response.Content.ReadAsStream()).ReadToEnd();
    return Ok(content);
}

// ✅ Asynchrone : le thread est libéré pendant l'appel HTTP
public async Task<IActionResult> GetData()
{
    var client = new HttpClient();
    var response = await client.GetAsync("https://api.example.com/data");
    var content = await response.Content.ReadAsStringAsync();
    return Ok(content);
}

public async Task EnvoyerEmailAsync(string destinataire, string message)
{
    await smtpClient.SendMailAsync(destinataire, message);
    // Pas de valeur de retour
}

public async Task<Client> GetClientAsync(int id)
{
    var client = await dbContext.Clients.FindAsync(id);
    return client; // retourne un Client, encapsulé dans Task<Client>
}

// Si le cache contient la valeur, pas besoin d'allouer un Task
public ValueTask<Client> GetClientAsync(int id)
{
    if (_cache.TryGetValue(id, out var client))
        return new ValueTask<Client>(client); // pas d'allocation

    return new ValueTask<Client>(GetClientFromDbAsync(id)); // allocation Task si nécessaire
}

private async Task<Client> GetClientFromDbAsync(int id)
{
    return await dbContext.Clients.FindAsync(id);
}

// Ce qu'on écrit
public async Task<string> GetDataAsync()
{
    var response = await httpClient.GetAsync("https://api.example.com");
    var content = await response.Content.ReadAsStringAsync();
    return content.ToUpper();
}

// Ce que le compilateur produit
private struct GetDataAsyncStateMachine : IAsyncStateMachine
{
    public int _state;  // -1 = début, 0 = après 1er await, 1 = après 2ème await
    public AsyncTaskMethodBuilder<string> _builder;
    public HttpClient httpClient;

    // Variables locales "promues" en champs
    private HttpResponseMessage _response;
    private string _content;

    // Awaiters pour chaque await
    private TaskAwaiter<HttpResponseMessage> _awaiter1;
    private TaskAwaiter<string> _awaiter2;

    public void MoveNext()
    {
        try
        {
            switch (_state)
            {
                case -1: // début de la méthode
                    _awaiter1 = httpClient.GetAsync("https://api.example.com").GetAwaiter();
                    if (!_awaiter1.IsCompleted)
                    {
                        _state = 0;
                        _builder.AwaitUnsafeOnCompleted(ref _awaiter1, ref this);
                        return; // le thread est libéré ICI
                    }
                    goto case 0;

                case 0: // reprise après le 1er await
                    _response = _awaiter1.GetResult();
                    _awaiter2 = _response.Content.ReadAsStringAsync().GetAwaiter();
                    if (!_awaiter2.IsCompleted)
                    {
                        _state = 1;
                        _builder.AwaitUnsafeOnCompleted(ref _awaiter2, ref this);
                        return; // le thread est libéré ICI
                    }
                    goto case 1;

                case 1: // reprise après le 2ème await
                    _content = _awaiter2.GetResult();
                    _builder.SetResult(_content.ToUpper());
                    return;
            }
        }
        catch (Exception ex)
        {
            _builder.SetException(ex);
        }
    }
}

// WPF : après await, on est de retour sur le thread UI
private async void Button_Click(object sender, RoutedEventArgs e)
{
    var data = await httpClient.GetStringAsync("https://api.example.com");
    TextBlock.Text = data; // ✅ OK : on est sur le thread UI
}

// Dans du code de bibliothèque (pas de UI, pas de contexte HTTP)
public async Task<string> GetDataAsync()
{
    var response = await httpClient.GetAsync(url).ConfigureAwait(false);
    // La reprise se fait sur n'importe quel thread du pool
    var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
    return content;
}

// ❌ async void : les exceptions ne sont pas capturables
public async void EnvoyerNotification()
{
    await httpClient.PostAsync(url, content);
    // Si une exception est levée, elle crashe l'application
    // car personne ne peut await cette méthode (pas de Task)
}

// ✅ async Task : les exceptions sont propagées via le Task
public async Task EnvoyerNotificationAsync()
{
    await httpClient.PostAsync(url, content);
}

// Seul cas acceptable pour async void
private async void Button_Click(object sender, RoutedEventArgs e)
{
    try
    {
        await DoWorkAsync();
    }
    catch (Exception ex)
    {
        // Toujours un try-catch dans un async void !
        MessageBox.Show(ex.Message);
    }
}

// ❌ DEADLOCK en WPF / ASP.NET classique
public void GetData()
{
    var data = GetDataAsync().Result; // bloque le thread UI
    // GetDataAsync attend de revenir sur le thread UI (SynchronizationContext)
    // Mais le thread UI est bloqué par .Result → DEADLOCK
}

public async Task<string> GetDataAsync()
{
    var result = await httpClient.GetStringAsync(url);
    // await veut revenir sur le thread UI, mais il est bloqué
    return result;
}

// ✅ Solution 1 : utiliser await partout (async all the way)
public async Task<string> GetData()
{
    return await GetDataAsync();
}

// ✅ Solution 2 : ConfigureAwait(false) dans la méthode appelée
public async Task<string> GetDataAsync()
{
    var result = await httpClient.GetStringAsync(url).ConfigureAwait(false);
    return result;
}

// ❌ async/await inutile : crée une machine à états pour rien
public async Task<Client> GetClientAsync(int id)
{
    return await repository.GetByIdAsync(id);
}

// ✅ Retourner directement le Task
public Task<Client> GetClientAsync(int id)
{
    return repository.GetByIdAsync(id);
}

// ✅ Garder async car il y a de la logique avant le await
public async Task<Client> GetClientAsync(int id)
{
    if (id <= 0) throw new ArgumentException("Id invalide");
    return await repository.GetByIdAsync(id);
    // Sans async, l'exception serait levée à l'appel, pas encapsulée dans le Task
}

// ❌ Le Task est créé mais jamais attendu : fire-and-forget silencieux
public async Task TraiterCommandeAsync(Commande cmd)
{
    EnvoyerConfirmationAsync(cmd.Email); // ⚠️ pas de await !
    // L'exécution continue immédiatement
    // Si EnvoyerConfirmationAsync lève une exception, elle est perdue
}

// ✅ Toujours await les Task
public async Task TraiterCommandeAsync(Commande cmd)
{
    await EnvoyerConfirmationAsync(cmd.Email);
}

// ❌ Séquentiel : 3 secondes au total (1 + 1 + 1)
var client = await GetClientAsync(id);          // attend 1s
var commandes = await GetCommandesAsync(id);    // attend 1s
var factures = await GetFacturesAsync(id);      // attend 1s

// ✅ Parallèle : ~1 seconde au total (les 3 en même temps)
var clientTask = GetClientAsync(id);
var commandesTask = GetCommandesAsync(id);
var facturesTask = GetFacturesAsync(id);

await Task.WhenAll(clientTask, commandesTask, facturesTask);

var client = clientTask.Result;      // déjà terminé, pas de blocage
var commandes = commandesTask.Result;
var factures = facturesTask.Result;

// OU en C# plus concis :
var (client, commandes, factures) = (
    await clientTask,
    await commandesTask,
    await facturesTask
);

public async Task<string> GetDataAvecTimeoutAsync(CancellationToken cancellationToken = default)
{
    using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
    cts.CancelAfter(TimeSpan.FromSeconds(5)); // timeout de 5 secondes

    try
    {
        return await httpClient.GetStringAsync(url, cts.Token);
    }
    catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
    {
        throw new TimeoutException("L'appel a dépassé le délai de 5 secondes.");
    }
}

public async Task<T> AvecRetryAsync<T>(Func<Task<T>> operation, int maxRetries = 3)
{
    for (int i = 0; i < maxRetries; i++)
    {
        try
        {
            return await operation();
        }
        catch (HttpRequestException) when (i < maxRetries - 1)
        {
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, i))); // backoff exponentiel
        }
    }
    throw new InvalidOperationException("Ne devrait pas arriver");
}

// Utilisation
var data = await AvecRetryAsync(() => httpClient.GetStringAsync(url));

// Producteur : chaque élément est produit de façon asynchrone
public async IAsyncEnumerable<Client> GetClientsEnStreamAsync(
    [EnumeratorCancellation] CancellationToken ct = default)
{
    var page = 0;
    while (true)
    {
        var batch = await dbContext.Clients
            .OrderBy(c => c.Id)
            .Skip(page * 100)
            .Take(100)
            .ToListAsync(ct);

        if (batch.Count == 0) yield break;

        foreach (var client in batch)
            yield return client;

        page++;
    }
}

// Consommateur : itère de manière asynchrone
await foreach (var client in GetClientsEnStreamAsync())
{
    Console.WriteLine(client.Nom);
}

var channel = Channel.CreateBounded<Commande>(100);

// Producteur
_ = Task.Run(async () =>
{
    await foreach (var cmd in GetCommandesEnStreamAsync())
    {
        await channel.Writer.WriteAsync(cmd);
    }
    channel.Writer.Complete();
});

// Consommateur
await foreach (var cmd in channel.Reader.ReadAllAsync())
{
    await TraiterCommandeAsync(cmd);
}

// ✅ Décharger un calcul lourd du thread UI
private async void CalculerButton_Click(object sender, RoutedEventArgs e)
{
    var resultat = await Task.Run(() => CalculComplexe(donnees));
    ResultatTextBlock.Text = resultat.ToString(); // retour sur le thread UI
}

// ❌ Ne pas wrapper un appel déjà asynchrone dans Task.Run
public Task<string> GetDataAsync()
{
    return Task.Run(async () =>
    {
        return await httpClient.GetStringAsync(url);
    });
}
// httpClient.GetStringAsync est déjà asynchrone, Task.Run gaspille un thread

// ✅ Appeler directement
public Task<string> GetDataAsync()
{
    return httpClient.GetStringAsync(url);
}

// Les opérateurs reçoivent des delegates (Func<T, bool>)
public static IEnumerable<T> Where<T>(
    this IEnumerable<T> source,
    Func<T, bool> predicate);

// Les opérateurs reçoivent des arbres d'expressions (Expression<Func<T, bool>>)
public static IQueryable<T> Where<T>(
    this IQueryable<T> source,
    Expression<Func<T, bool>> predicate);

Func<int, bool> estPair = x => x % 2 == 0;

// C'est un delegate : on peut l'appeler
bool resultat = estPair(42); // true

Expression<Func<int, bool>> estPair = x => x % 2 == 0;

// C'est un arbre : on peut l'analyser
// estPair.Body → (x % 2) == 0
// estPair.Body.NodeType → Equal
// estPair.Body.Left → (x % 2)
// estPair.Body.Left.Left → x
// estPair.Body.Left.Right → 2

Expression<Func<int, bool>> expr = x => x > 5 && x < 100;

// On peut "visiter" l'arbre
var body = (BinaryExpression)expr.Body;          // &&
var left = (BinaryExpression)body.Left;          // x > 5
var right = (BinaryExpression)body.Right;        // x < 100

Console.WriteLine(body.NodeType);   // AndAlso
Console.WriteLine(left.NodeType);   // GreaterThan
Console.WriteLine(right.NodeType);  // LessThan

// Et on peut aussi le compiler en delegate pour l'exécuter
Func<int, bool> func = expr.Compile();
Console.WriteLine(func(42));  // true
Console.WriteLine(func(3));   // false

// Source IEnumerable<T> (liste en mémoire)
List<Client> clientsEnMemoire = GetClients();

var actifs1 = clientsEnMemoire
    .Where(c => c.IsActif)           // Func<Client, bool> → filtre en mémoire
    .OrderBy(c => c.Nom)             // tri en mémoire
    .Select(c => c.Nom)              // projection en mémoire
    .ToList();

// Source IQueryable<T> (DbSet Entity Framework)
IQueryable<Client> clientsDb = dbContext.Clients;

var actifs2 = clientsDb
    .Where(c => c.IsActif)           // Expression → traduit en WHERE IsActif = 1
    .OrderBy(c => c.Nom)             // Expression → traduit en ORDER BY Nom
    .Select(c => c.Nom)              // Expression → traduit en SELECT Nom
    .ToList();                        // exécute la requête SQL

var resultat = dbContext.Clients
    .Where(c => c.IsActif)        // ← IQueryable : traduit en SQL
    .AsEnumerable()                // ← bascule vers IEnumerable !
    .Where(c => c.Nom.Length > 5) // ← IEnumerable : exécuté en mémoire
    .ToList();

IQueryable<Client> query = dbContext.Clients.Where(c => c.IsActif);
Console.WriteLine(query is IQueryable);    // True → monde SQL

IEnumerable<Client> enumerable = query.AsEnumerable();
// enumerable est toujours un IQueryable sous le capot,
// mais les opérateurs LINQ utilisés seront ceux de Enumerable (pas Queryable)

// ❌ EF ne sait pas traduire une méthode perso
var resultat = dbContext.Clients
    .Where(c => MonFormateur.Formater(c.Nom) == "ALICE")
    .ToList();
// → Exception : "The LINQ expression could not be translated"

// ❌ Certaines méthodes .NET ne sont pas supportées non plus
var resultat = dbContext.Clients
    .Where(c => c.DateCreation.ToString("yyyy-MM-dd") == "2025-01-01")
    .ToList();
// → Exception ou évaluation côté client selon la version d'EF

// ❌ Pas possible dans un arbre d'expression
Expression<Func<Client, string>> expr = c =>
{
    if (c.IsVip) return "VIP";  // instruction → erreur de compilation
    return "Standard";
};

// ✅ Utiliser l'opérateur ternaire (c'est une expression)
Expression<Func<Client, string>> expr = c =>
    c.IsVip ? "VIP" : "Standard";

// EF traduit en : CASE WHEN IsVip = 1 THEN 'VIP' ELSE 'Standard' END

IQueryable<Commande> query = dbContext.Commandes;

// Ajout conditionnel de filtres
if (dateDebut.HasValue)
    query = query.Where(c => c.Date >= dateDebut.Value);

if (dateFin.HasValue)
    query = query.Where(c => c.Date <= dateFin.Value);

if (!string.IsNullOrEmpty(recherche))
    query = query.Where(c => c.Reference.Contains(recherche));

// Le SQL final ne contient QUE les filtres ajoutés
var resultats = await query
    .OrderByDescending(c => c.Date)
    .Take(50)
    .ToListAsync();

IEnumerable<Commande> query = commandesEnMemoire;

if (dateDebut.HasValue)
    query = query.Where(c => c.Date >= dateDebut.Value);

// Fonctionne, mais filtre en mémoire sur des données déjà chargées
var resultats = query.ToList();

// ❌ AsQueryable() ne transforme PAS une liste en requête SQL
var listeEnMemoire = new List<int> { 1, 2, 3, 4, 5 };
var queryable = listeEnMemoire.AsQueryable();

// queryable est un IQueryable, mais le "provider" est EnumerableQuery
// → le Where est toujours exécuté en mémoire !
var resultat = queryable.Where(x => x > 3).ToList();

// Option 1 : exposer IQueryable (flexible mais couplé)
public interface IClientRepository
{
    IQueryable<Client> GetAll(); // l'appelant ajoute ses filtres
}

// Option 2 : exposer IEnumerable avec des paramètres explicites (découplé)
public interface IClientRepository
{
    Task<IReadOnlyList<Client>> GetActifs(string? recherche = null, int? limit = null);
}