using DurableWait.Model;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask.Client;
using Microsoft.Extensions.Logging;
using System.Text.Json;

namespace DurableWait.Apis;

public class BeginFlowWithHttpPost
{
    private readonly Processing _processing;
    private readonly ILogger<BeginFlowWithHttpPost> _logger;

    public BeginFlowWithHttpPost(ILogger<BeginFlowWithHttpPost> logger, Processing processing)
    {
        _logger = logger;
        _processing = processing;
    }

    [Function(Constants.BeginFlowWithHttpPost)]
    public async Task<IActionResult> HttpStart(
      [HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest request,
      [DurableClient] DurableTaskClient client)
    {
        _logger.LogInformation("Started new flow");

        var beginRequestData = await JsonSerializer.DeserializeAsync<BeginRequestData>(request.Body);
        _logger.LogInformation("Started new flow with ID = '{beginRequestDataId}'.", beginRequestData.Id);

        return await _processing.ProcessFlow(beginRequestData, request, client);
    }
}

using DurableWait.Model;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.DurableTask.Client;
using Microsoft.Extensions.Logging;
using System.Net;

namespace DurableWait;

public class Processing
{
    private readonly ILogger<Processing> _logger;

    public Processing(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger<Processing>();
    }

    public async Task<IActionResult> ProcessFlow(
        BeginRequestData beginRequestData,
        HttpRequest request,
        DurableTaskClient client)
    {
        var instanceId = await client.ScheduleNewOrchestrationInstanceAsync(Constants.MyOrchestration, beginRequestData);
        _logger.LogInformation("Started orchestration with ID = '{instanceId}'.", instanceId);

        // Create a timeout using CancellationTokenSource
        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));

        OrchestrationMetadata data;
        try
        {
            data = await client.WaitForInstanceCompletionAsync(instanceId, getInputsAndOutputs: true, cts.Token);
        }
        catch (OperationCanceledException)
        {
            // Timeout occurred
            await client.TerminateInstanceAsync(instanceId, "Timeout something took too long");
            return new ContentResult()
            {
                Content = "{ \"error\": \"Timeout something took too long\" }",
                ContentType = "application/json",
                StatusCode = (int)HttpStatusCode.InternalServerError
            };
        }

        // Check if completed
        if (data == null || data.RuntimeStatus != OrchestrationRuntimeStatus.Completed)
        {
            await client.TerminateInstanceAsync(instanceId, "Timeout something took too long");
            return new ContentResult()
            {
                Content = "{ \"error\": \"Timeout something took too long\" }",
                ContentType = "application/json",
                StatusCode = (int)HttpStatusCode.InternalServerError
            };
        }
        var output = data.ReadOutputAs<MyOrchestrationDto>();

        var completeResponseData = new CompleteResponseData
        {
            BeginRequestData = output.BeginRequest,
            Id2 = output.BeginRequest.Id + ".v2",
            MyActivityTwoResult = output.MyActivityTwoResult
        };

        return new OkObjectResult(completeResponseData);
    }
}

using DurableWait.Model;
using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.Extensions.Logging;

namespace DurableWait.Orchestrations;

public class MyOrchestration
{
    private readonly ILogger<MyOrchestration> _logger;

    public MyOrchestration(ILogger<MyOrchestration> logger)
    {
        _logger = logger;
    }

    [Function(Constants.MyOrchestration)]
    public async Task<MyOrchestrationDto> RunOrchestrator(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        var myOrchestrationDto = new MyOrchestrationDto
        {
            BeginRequest = context.GetInput<BeginRequestData>()
        };

        if (!context.IsReplaying)
        {
            _logger.LogWarning("begin MyOrchestration with input id {myOrchestrationDtoBeginRequestId}", myOrchestrationDto.BeginRequest.Id);
        }

        var myActivityOne = await context.CallActivityAsync<string>(
            Constants.MyActivityOne, context.GetInput<BeginRequestData>());

        myOrchestrationDto.MyActivityOneResult = myActivityOne;

        if (!context.IsReplaying)
        {
            _logger.LogWarning("myActivityOne completed {myActivityOne}", myActivityOne);
        }

        var myActivityTwo = await context.CallActivityAsync<string>(
            Constants.MyActivityTwo, myOrchestrationDto);

        myOrchestrationDto.MyActivityTwoResult = myActivityTwo;

        if (!context.IsReplaying)
        {
            _logger.LogWarning("myActivityTwo completed {myActivityTwo}", myActivityTwo);
        }

        return myOrchestrationDto;
    }
}

using Azure.Identity;
using DurableWait;
using DurableWait.Activities;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System.Reflection;

var builder = FunctionsApplication.CreateBuilder(args);

builder.ConfigureFunctionsWebApplication();

builder.Services
    .AddApplicationInsightsTelemetryWorkerService()
    .ConfigureFunctionsApplicationInsights();

builder.Services.AddOptions<MyConfiguration>()
    .Configure<IConfiguration>((settings, configuration) =>
    {
        configuration.GetSection("MyConfiguration").Bind(settings);
    });

builder.Services.AddOptions<MyConfigurationSecrets>()
    .Configure<IConfiguration>((settings, configuration) =>
    {
        configuration.GetSection("MyConfigurationSecrets").Bind(settings);
    });

builder.Services.AddLogging();
builder.Services.AddScoped<MyActivities>();
builder.Services.AddScoped<Processing>();

var keyVaultEndpoint = builder.Configuration["AzureKeyVaultEndpoint"];

if (!string.IsNullOrEmpty(keyVaultEndpoint))
{
    // using Key Vault, either local dev or deployed
    builder.Configuration
        .SetBasePath(Environment.CurrentDirectory)
        .AddAzureKeyVault(new Uri(keyVaultEndpoint), new DefaultAzureCredential())
        .AddJsonFile("local.settings.json", optional: true)
        .AddEnvironmentVariables();
}
else
{
    // local dev no Key Vault
    builder.Configuration
        .SetBasePath(Environment.CurrentDirectory)
        .AddJsonFile("local.settings.json", optional: true)
        .AddUserSecrets(Assembly.GetExecutingAssembly(), optional: true)
        .AddEnvironmentVariables();
}

builder.Build().Run();