gRPC Services

using Google.Protobuf.WellKnownTypes;
using Grpc.Core;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.Server.Kestrel.Core;
using Shop.Orders.V1;

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(kestrel =>
{
    kestrel.ListenAnyIP(8080, listen => listen.Protocols = HttpProtocols.Http1); // REST and health probes
    kestrel.ListenAnyIP(8081, listen => listen.Protocols = HttpProtocols.Http2); // gRPC over cleartext HTTP/2
});

builder.Services.AddGrpc(options =>
{
    options.EnableDetailedErrors = builder.Environment.IsDevelopment();
    options.MaxReceiveMessageSize = 1024 * 1024;
});
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.Authority = builder.Configuration["Auth:Authority"];
        options.Audience = "orders-grpc";
    });
builder.Services.AddAuthorization();
builder.Services.AddSingleton<IOrderRepository, InMemoryOrderRepository>();

var app = builder.Build();
app.UseAuthentication();
app.UseAuthorization();
// Without this, anyone who can reach port 8081 can cancel any order.
app.MapGrpcService<OrdersService>().RequireAuthorization();
app.MapGet("/healthz", () => "ok");
app.Run();

public sealed class OrdersService(IOrderRepository orders, ILogger<OrdersService> logger) : Orders.OrdersBase
{
    public override async Task<OrderReply> GetOrder(GetOrderRequest request, ServerCallContext context)
    {
        if (request.OrderId <= 0)
            throw new RpcException(new Status(StatusCode.InvalidArgument, "order_id must be greater than zero"));

        var order = await orders.FindAsync(request.OrderId, context.CancellationToken)
            ?? throw new RpcException(new Status(StatusCode.NotFound, $"Order {request.OrderId} was not found"));
        return ToReply(order);
    }

    public override async Task<OrderReply> CancelOrder(CancelOrderRequest request, ServerCallContext context)
    {
        // With under 100 ms left the caller will give up before the write commits; refuse the work.
        if (context.Deadline - DateTime.UtcNow < TimeSpan.FromMilliseconds(100))
            throw new RpcException(new Status(StatusCode.DeadlineExceeded, "Not enough time left to cancel the order"));

        var order = await orders.FindAsync(request.OrderId, context.CancellationToken)
            ?? throw new RpcException(new Status(StatusCode.NotFound, $"Order {request.OrderId} was not found"));

        if (order.State == OrderState.Shipped)
            throw new RpcException(new Status(StatusCode.FailedPrecondition, $"Order {order.Id} has already shipped"));

        var cancelled = order with { State = OrderState.Cancelled };
        await orders.SaveAsync(cancelled, context.CancellationToken);
        logger.LogInformation("Order {OrderId} cancelled by {Peer}: {Reason}", order.Id, context.Peer, request.Reason);
        return ToReply(cancelled);
    }

    private static OrderReply ToReply(Order order) => new()
    {
        OrderId = order.Id,
        CustomerId = order.CustomerId,
        Status = order.State switch
        {
            OrderState.Pending => OrderStatus.Pending,
            OrderState.Paid => OrderStatus.Paid,
            OrderState.Shipped => OrderStatus.Shipped,
            OrderState.Cancelled => OrderStatus.Cancelled,
            _ => OrderStatus.Unspecified
        },
        TotalCents = order.TotalCents,
        Currency = order.Currency,
        PlacedAt = Timestamp.FromDateTime(order.PlacedAtUtc)
    };
}

public enum OrderState { Pending, Paid, Shipped, Cancelled }

public sealed record Order(long Id, long CustomerId, OrderState State, long TotalCents, string Currency, DateTime PlacedAtUtc);

public interface IOrderRepository
{
    Task<Order?> FindAsync(long id, CancellationToken cancellationToken);
    Task SaveAsync(Order order, CancellationToken cancellationToken);
}

public sealed class InMemoryOrderRepository : IOrderRepository
{
    private readonly System.Collections.Concurrent.ConcurrentDictionary<long, Order> orders = new()
    {
        [2042] = new Order(2042, 17, OrderState.Paid, 4_998, "EUR", new DateTime(2026, 10, 20, 9, 30, 0, DateTimeKind.Utc)),
        [2043] = new Order(2043, 17, OrderState.Shipped, 12_500, "EUR", new DateTime(2026, 10, 21, 14, 5, 0, DateTimeKind.Utc))
    };

    public Task<Order?> FindAsync(long id, CancellationToken cancellationToken) =>
        Task.FromResult(orders.TryGetValue(id, out var order) ? order : null);

    public Task SaveAsync(Order order, CancellationToken cancellationToken)
    {
        orders[order.Id] = order;
        return Task.CompletedTask;
    }
}