EnvelopeGenerator/EnvelopeGenerator.Server/EnvelopeGenerator.Server.Client/Services/EnvelopeService.cs

using EnvelopeGenerator.Application.Common.Dto;
using EnvelopeGenerator.Application.Envelopes.Commands;
using Microsoft.AspNetCore.WebUtilities;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;

namespace EnvelopeGenerator.Server.Client.Services;

/// <summary>
/// Retrieves <see cref="EnvelopeDto"/>s from the API.
/// </summary>
public class EnvelopeService(IHttpClientFactory clientFactory)
{
    private static readonly JsonSerializerOptions _jsonOptions = new(JsonSerializerDefaults.Web);
    private sealed record DeleteEnvelopeRequest(string Reason);
    private sealed record ErrorResponse(string? Message);

    /// <summary>
    /// Fetches envelopes from the API with optional filters.
    /// </summary>
    /// <exception cref="HttpRequestException">Thrown when the API request fails.</exception>
    public async Task<IEnumerable<EnvelopeDto>?> GetAsync(
        int? id = null,
        string? uuid = null,
        bool? onlyActive = null,
        bool? onlyCompleted = null,
        CancellationToken cancel = default)
    {
        var baseUrl = $"/api/Envelope";
        var queryParams = new Dictionary<string, string?>();

        if (id.HasValue)
        {
            queryParams["Id"] = id.Value.ToString();
        }
        if (!string.IsNullOrEmpty(uuid))
        {
            queryParams["Uuid"] = uuid;
        }
        if (onlyActive.HasValue)
        {
            queryParams["OnlyActive"] = onlyActive.Value.ToString();
        }
        if (onlyCompleted.HasValue)
        {
            queryParams["OnlyCompleted"] = onlyCompleted.Value.ToString();
        }

        var url = QueryHelpers.AddQueryString(baseUrl, queryParams);

        var httpClient = clientFactory.CreateClient("EnvelopeGenerator.Server");
        var response = await httpClient.GetAsync(url, cancel);

        if (!response.IsSuccessStatusCode)
        {
            var statusCode = (int)response.StatusCode;
            var reasonPhrase = response.ReasonPhrase ?? "Unknown error";
            throw new HttpRequestException(
                $"Failed to load envelopes. Status: {statusCode} ({reasonPhrase})",
                null,
                response.StatusCode);
        }

        return await response.Content.ReadFromJsonAsync<IEnumerable<EnvelopeDto>>(_jsonOptions, cancel);
    }

    public async Task DeleteAsync(int envelopeId, string reason, CancellationToken cancel = default)
    {
        var httpClient = clientFactory.CreateClient("EnvelopeGenerator.Server");
        using var request = new HttpRequestMessage(HttpMethod.Delete, $"/api/Envelope/{envelopeId}")
        {
            Content = JsonContent.Create(new DeleteEnvelopeRequest(reason), options: _jsonOptions)
        };

        var response = await httpClient.SendAsync(request, cancel);
        if (response.IsSuccessStatusCode)
            return;

        string? message = null;
        try
        {
            var error = await response.Content.ReadFromJsonAsync<ErrorResponse>(_jsonOptions, cancel);
            message = error?.Message;
        }
        catch
        {
            message = null;
        }

        var statusCode = (int)response.StatusCode;
        var reasonPhrase = response.ReasonPhrase ?? "Unknown error";
        throw new HttpRequestException(
            $"Failed to delete envelope. Status: {statusCode} ({reasonPhrase}){(string.IsNullOrWhiteSpace(message) ? string.Empty : $" - {message}")}",
            null,
            response.StatusCode);
    }

    public async Task<SaveEnvelopeDraftResultDto?> SaveDraftAsync(
        SaveEnvelopeDraftCommand request,
        CancellationToken cancel = default)
    {
        var httpClient = clientFactory.CreateClient("EnvelopeGenerator.Server");
        var payload = new
        {
            EnvelopeId = request.EnvelopeId,
            Title = request.Title,
            Message = request.Message,
            TFAEnabled = request.TFAEnabled,
            Document = request.Document is null
                ? null
                : new { DataAsBase64 = request.Document.DataAsBase64 },
            Receivers = request.Receivers.Select(r => new
            {
                EmailAddress = r.EmailAddress,
                Name = r.Name,
                PhoneNumber = r.PhoneNumber,
                Fields = r.Fields.Select(f => new { X = f.X, Y = f.Y, Page = f.Page }).ToList()
            }).ToList()
        };

        var response = await httpClient.PostAsJsonAsync("/api/Envelope/draft", payload, _jsonOptions, cancel);

        if (response.IsSuccessStatusCode)
            return await response.Content.ReadFromJsonAsync<SaveEnvelopeDraftResultDto>(_jsonOptions, cancel);

        string? message = null;
        try
        {
            var error = await response.Content.ReadFromJsonAsync<ErrorResponse>(_jsonOptions, cancel);
            message = error?.Message;
        }
        catch
        {
            message = null;
        }

        var statusCode = (int)response.StatusCode;
        var reasonPhrase = response.ReasonPhrase ?? "Unknown error";
        throw new HttpRequestException(
            $"Failed to save envelope draft. Status: {statusCode} ({reasonPhrase}){(string.IsNullOrWhiteSpace(message) ? string.Empty : $" - {message}")}",
            null,
            response.StatusCode);
    }
}