Solve captchas from C# / .NET with one function

using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text.Json;
using System.Text.Json.Nodes;

namespace BypassSo;

/// <summary>Any API reply with errorId != 0.</summary>
public sealed class BypassException(string code, string description, string? taskId = null)
    : Exception($"{code}: {description}")
{
    public string Code { get; } = code;
    public string? TaskId { get; } = taskId;
}

public sealed class Solution
{
    public string? Text { get; init; }
    public string? Token { get; init; }
    public string? GRecaptchaResponse { get; init; }
    public string? TokenField { get; init; }
    public double? TokenLifetime { get; init; }
    public string TaskId { get; set; } = "";

    /// <summary>The token for widget types, or the text for recognition types.</summary>
    public string? Answer => GRecaptchaResponse ?? Token ?? Text;
}

public sealed record Balance(long Credits, decimal BalanceUsd);

public sealed record ReportResult(string TaskId, long Refunded, decimal BalanceUsd);

public sealed class BypassClient
{
    private const string ApiUrl = "https://bypass.so";
    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web);
    private readonly HttpClient _http;
    private readonly string _key;

    public BypassClient(HttpClient? http = null, string? apiKey = null)
    {
        _http = http ?? new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
        _key = apiKey ?? Environment.GetEnvironmentVariable("BYPASS_API_KEY") ?? "";
    }

    /// <summary>Creates a task and polls every 2 seconds until it is ready (default timeout 120 s).</summary>
    public async Task<Solution> SolveAsync(
        string type,
        IReadOnlyDictionary<string, object?> parameters,
        TimeSpan? timeout = null,
        CancellationToken cancellationToken = default)
    {
        if (_key == "")
        {
            throw new BypassException("ERROR_KEY_INVALID", "set the BYPASS_API_KEY environment variable");
        }
        var limit = timeout ?? TimeSpan.FromSeconds(120);
        using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
        cts.CancelAfter(limit);

        var body = new Dictionary<string, object?>(parameters) { ["clientKey"] = _key, ["type"] = type };
        var data = await SendAsync(HttpMethod.Post, "/createTask", JsonContent.Create(body), false, cts.Token);
        var taskId = (string?)data["taskId"] ?? "";
        var poll = $"/getTaskResult/{Uri.EscapeDataString(taskId)}?clientKey={Uri.EscapeDataString(_key)}";

        try
        {
            while ((string?)data["status"] != "ready")
            {
                if ((string?)data["status"] == "failed")
                {
                    throw new BypassException("ERROR_CAPTCHA_UNSOLVABLE", "task failed", taskId);
                }
                await Task.Delay(TimeSpan.FromSeconds(2), cts.Token);
                data = await SendAsync(HttpMethod.Get, poll, null, false, cts.Token);
            }
        }
        catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
        {
            throw new BypassException("CLIENT_TIMEOUT", $"task {taskId} was not ready after {limit.TotalSeconds}s", taskId);
        }

        var solution = data["solution"]?.Deserialize<Solution>(JsonOptions) ?? new Solution();
        solution.TaskId = taskId;
        return solution;
    }

    public async Task<Balance> GetBalanceAsync(CancellationToken cancellationToken = default)
    {
        var data = await SendAsync(HttpMethod.Get, "/balance", null, true, cancellationToken);
        return data.Deserialize<Balance>(JsonOptions)!;
    }

    /// <summary>Flags a wrong answer. The price is refunded once and the task is closed.</summary>
    public async Task<ReportResult> ReportBadAsync(string taskId, CancellationToken cancellationToken = default)
    {
        var data = await SendAsync(HttpMethod.Post, $"/reportBad?task_id={Uri.EscapeDataString(taskId)}", null, true, cancellationToken);
        return data.Deserialize<ReportResult>(JsonOptions)!;
    }

    private async Task<JsonObject> SendAsync(HttpMethod method, string path, HttpContent? content, bool bearer, CancellationToken cancellationToken)
    {
        using var request = new HttpRequestMessage(method, ApiUrl + path) { Content = content };
        if (bearer)
        {
            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _key);
        }

        HttpResponseMessage response;
        try
        {
            response = await _http.SendAsync(request, cancellationToken);
        }
        catch (HttpRequestException e)
        {
            throw new BypassException("HTTP_ERROR", e.Message);
        }

        using (response)
        {
            var raw = await response.Content.ReadAsStringAsync(cancellationToken);
            JsonObject? data;
            try
            {
                data = JsonNode.Parse(raw) as JsonObject;
            }
            catch (JsonException)
            {
                data = null;
            }
            if (data is null)
            {
                throw new BypassException("HTTP_ERROR", $"HTTP {(int)response.StatusCode} without a JSON body");
            }
            if (data["errorId"]?.GetValue<int>() is int errorId && errorId != 0)
            {
                throw new BypassException(
                    (string?)data["errorCode"] ?? "ERROR_UNKNOWN",
                    (string?)data["errorDescription"] ?? "",
                    (string?)data["taskId"]);
            }
            return data;
        }
    }
}