// Illustrative outline only — not a complete, deployable project.
// Versions as of Jul 2026: .NET 8+, Amazon.Lambda.DurableExecution (NuGet), Lambda durable execution enabled at create time.
// Pattern: payment capture with human fraud review callback.
// Docs: https://docs.aws.amazon.com/durable-execution/sdk-reference/languages/csharp/

using Amazon.Lambda.Core;
using Amazon.Lambda.DurableExecution;
using Amazon.Lambda.RuntimeSupport;
using Amazon.Lambda.Serialization.SystemTextJson;

namespace PaymentPipeline;

public static class Program
{
    public static async Task Main()
    {
        var handler = new PaymentWorkflowHandler();
        var serializer = new DefaultLambdaJsonSerializer();
        using var wrapper = HandlerWrapper.GetHandlerWrapper<DurableExecutionInvocationInput, DurableExecutionInvocationOutput>(
            handler.HandleAsync, serializer);
        using var bootstrap = new LambdaBootstrap(wrapper);
        await bootstrap.RunAsync();
    }
}

public sealed class PaymentWorkflowHandler
{
    // Entry: service envelope in/out — delegate to WrapAsync.
    public Task<DurableExecutionInvocationOutput> HandleAsync(
        DurableExecutionInvocationInput input,
        ILambdaContext lambdaContext)
        => DurableFunction.WrapAsync<PaymentRequest, PaymentResult>(RunWorkflowAsync, input, lambdaContext);

    private async Task<PaymentResult> RunWorkflowAsync(PaymentRequest request, IDurableContext ctx)
    {
        // Step 1: idempotent authorization hold (checkpointed; replays skip re-execution if succeeded).
        var hold = await ctx.StepAsync(
            async (_, ct) => await PaymentGateway.AuthorizeHoldAsync(request, ct),
            name: "authorize-hold");

        // Step 2: parallel fraud signals (checkpoint each branch).
        var fraudScores = await ctx.ParallelAsync(
            new[]
            {
                ctx.StepAsync(async (_, ct) => await FraudService.ScoreDeviceAsync(request, ct), name: "score-device"),
                ctx.StepAsync(async (_, ct) => await FraudService.ScoreVelocityAsync(request, ct), name: "score-velocity"),
            },
            name: "fraud-parallel");

        if (fraudScores.Any(s => s.RequiresReview))
        {
            // Step 3: human-in-the-loop — execution suspends; no duration charge while waiting (on-demand).
            var review = await ctx.WaitForCallbackAsync<FraudReviewDecision>(
                timeout: TimeSpan.FromDays(3),
                name: "fraud-analyst-callback");

            if (!review.Approved)
                throw new InvalidOperationException("Fraud review rejected payment.");
        }

        // Step 4: capture + emit receipt (another checkpoint).
        var capture = await ctx.StepAsync(
            async (_, ct) => await PaymentGateway.CaptureAsync(hold, ct),
            name: "capture-funds");

        return new PaymentResult(request.OrderId, capture.TransactionId, Status: "captured");
    }
}

// Domain types and service stubs omitted — replace with your PSP / fraud provider clients.
public record PaymentRequest(string OrderId, decimal Amount, string CustomerId);
public record PaymentResult(string OrderId, string TransactionId, string Status);
public record FraudReviewDecision(bool Approved, string AnalystId);