Solve captchas from Java with one function

import java.io.IOException;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/** bypass.so client: Java 17+, no dependencies. */
public final class Bypass {
    public static final String API_URL = "https://bypass.so";
    private static final HttpClient HTTP = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .build();

    private Bypass() {}

    /** Any API reply with errorId != 0. */
    public static final class BypassException extends RuntimeException {
        private static final long serialVersionUID = 1L;
        public final String code;
        public final String taskId;

        public BypassException(String code, String description, String taskId) {
            super(code + ": " + description);
            this.code = code;
            this.taskId = taskId;
        }
    }

    private static String key() {
        String key = System.getenv("BYPASS_API_KEY");
        return key == null ? "" : key;
    }

    public static Map<String, Object> solve(String type, Map<String, ?> params) throws InterruptedException {
        return solve(type, params, Duration.ofSeconds(120));
    }

    /** Creates a task and polls every 2 seconds until it is ready. Returns the solution plus taskId. */
    public static Map<String, Object> solve(String type, Map<String, ?> params, Duration timeout) throws InterruptedException {
        String key = key();
        if (key.isEmpty()) {
            throw new BypassException("ERROR_KEY_INVALID", "set the BYPASS_API_KEY environment variable", null);
        }
        Map<String, Object> body = new LinkedHashMap<>();
        body.put("clientKey", key);
        body.put("type", type);
        body.putAll(params);

        Map<String, Object> data = call(request("/createTask")
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(Json.write(body))));
        String taskId = (String) data.get("taskId");
        long deadline = System.nanoTime() + timeout.toNanos();

        while (!"ready".equals(data.get("status"))) {
            if ("failed".equals(data.get("status"))) {
                throw new BypassException("ERROR_CAPTCHA_UNSOLVABLE", "task failed", taskId);
            }
            if (System.nanoTime() > deadline) {
                throw new BypassException("CLIENT_TIMEOUT", "task " + taskId + " was not ready after " + timeout.toSeconds() + "s", taskId);
            }
            Thread.sleep(2_000);
            data = call(request("/getTaskResult/" + enc(taskId) + "?clientKey=" + enc(key)).GET());
        }
        Map<String, Object> solution = new LinkedHashMap<>(asMap(data.get("solution")));
        solution.put("taskId", taskId);
        return solution;
    }

    /** The token for widget types, or the text for recognition types. */
    public static String answer(Map<String, Object> solution) {
        for (String field : List.of("gRecaptchaResponse", "token", "text")) {
            if (solution.get(field) instanceof String value && !value.isEmpty()) {
                return value;
            }
        }
        return null;
    }

    public static Map<String, Object> balance() throws InterruptedException {
        return call(request("/balance").header("Authorization", "Bearer " + key()).GET());
    }

    public static Map<String, Object> reportBad(String taskId) throws InterruptedException {
        return call(request("/reportBad?task_id=" + enc(taskId))
                .header("Authorization", "Bearer " + key())
                .POST(HttpRequest.BodyPublishers.noBody()));
    }

    /** Encodes fields as application/x-www-form-urlencoded, for posting a token to your own form. */
    public static String form(Map<String, String> fields) {
        return fields.entrySet().stream()
                .map(e -> enc(e.getKey()) + "=" + enc(e.getValue()))
                .collect(Collectors.joining("&"));
    }

    private static HttpRequest.Builder request(String path) {
        return HttpRequest.newBuilder(URI.create(API_URL + path)).timeout(Duration.ofSeconds(30));
    }

    private static String enc(String s) {
        return URLEncoder.encode(s, StandardCharsets.UTF_8);
    }

    private static Map<String, Object> call(HttpRequest.Builder req) throws InterruptedException {
        HttpResponse<String> res;
        try {
            res = HTTP.send(req.build(), HttpResponse.BodyHandlers.ofString());
        } catch (IOException e) {
            throw new BypassException("HTTP_ERROR", e.toString(), null);
        }
        Object parsed;
        try {
            parsed = Json.parse(res.body());
        } catch (IllegalArgumentException e) {
            parsed = null;
        }
        if (!(parsed instanceof Map)) {
            throw new BypassException("HTTP_ERROR", "HTTP " + res.statusCode() + " without a JSON body", null);
        }
        Map<String, Object> data = asMap(parsed);
        if (data.get("errorId") instanceof Number id && id.intValue() != 0) {
            Object code = data.getOrDefault("errorCode", "ERROR_UNKNOWN");
            Object description = data.getOrDefault("errorDescription", "");
            throw new BypassException(String.valueOf(code), String.valueOf(description), (String) data.get("taskId"));
        }
        return data;
    }

    @SuppressWarnings("unchecked")
    private static Map<String, Object> asMap(Object value) {
        return value instanceof Map ? (Map<String, Object>) value : Map.of();
    }

    /** Just enough JSON: objects, arrays, strings, numbers, booleans and null. */
    static final class Json {
        private final String s;
        private int i;

        private Json(String s) {
            this.s = s;
        }

        static Object parse(String text) {
            Json p = new Json(text);
            p.ws();
            Object value = p.value();
            p.ws();
            if (p.i != p.s.length()) {
                throw p.error();
            }
            return value;
        }

        static String write(Object value) {
            StringBuilder b = new StringBuilder();
            write(b, value);
            return b.toString();
        }

        private static void write(StringBuilder b, Object v) {
            if (v == null) {
                b.append("null");
            } else if (v instanceof Number || v instanceof Boolean) {
                b.append(v);
            } else if (v instanceof Map<?, ?> m) {
                b.append('{');
                String sep = "";
                for (Map.Entry<?, ?> e : m.entrySet()) {
                    b.append(sep);
                    quote(b, String.valueOf(e.getKey()));
                    b.append(':');
                    write(b, e.getValue());
                    sep = ",";
                }
                b.append('}');
            } else if (v instanceof Iterable<?> list) {
                b.append('[');
                String sep = "";
                for (Object item : list) {
                    b.append(sep);
                    write(b, item);
                    sep = ",";
                }
                b.append(']');
            } else {
                quote(b, v.toString());
            }
        }

        private static void quote(StringBuilder b, String str) {
            b.append('"');
            for (char c : str.toCharArray()) {
                switch (c) {
                    case '"' -> b.append("\\\"");
                    case '\\' -> b.append("\\\\");
                    case '\n' -> b.append("\\n");
                    case '\r' -> b.append("\\r");
                    case '\t' -> b.append("\\t");
                    default -> {
                        if (c < 0x20) {
                            b.append(String.format("\\u%04x", (int) c));
                        } else {
                            b.append(c);
                        }
                    }
                }
            }
            b.append('"');
        }

        private IllegalArgumentException error() {
            return new IllegalArgumentException("invalid JSON at offset " + i);
        }

        private void ws() {
            while (i < s.length() && " \t\r\n".indexOf(s.charAt(i)) >= 0) {
                i++;
            }
        }

        private boolean peek(char c) {
            return i < s.length() && s.charAt(i) == c;
        }

        private void expect(char c) {
            if (!peek(c)) {
                throw error();
            }
            i++;
        }

        private Object value() {
            if (i >= s.length()) {
                throw error();
            }
            return switch (s.charAt(i)) {
                case '{' -> object();
                case '[' -> array();
                case '"' -> string();
                case 't' -> literal("true", Boolean.TRUE);
                case 'f' -> literal("false", Boolean.FALSE);
                case 'n' -> literal("null", null);
                default -> number();
            };
        }

        private Object literal(String word, Object value) {
            if (!s.startsWith(word, i)) {
                throw error();
            }
            i += word.length();
            return value;
        }

        private Map<String, Object> object() {
            Map<String, Object> map = new LinkedHashMap<>();
            expect('{');
            ws();
            if (peek('}')) {
                i++;
                return map;
            }
            while (true) {
                ws();
                String key = string();
                ws();
                expect(':');
                ws();
                map.put(key, value());
                ws();
                if (peek(',')) {
                    i++;
                } else {
                    expect('}');
                    return map;
                }
            }
        }

        private List<Object> array() {
            List<Object> list = new ArrayList<>();
            expect('[');
            ws();
            if (peek(']')) {
                i++;
                return list;
            }
            while (true) {
                ws();
                list.add(value());
                ws();
                if (peek(',')) {
                    i++;
                } else {
                    expect(']');
                    return list;
                }
            }
        }

        private String string() {
            expect('"');
            StringBuilder b = new StringBuilder();
            while (true) {
                if (i >= s.length()) {
                    throw error();
                }
                char c = s.charAt(i++);
                if (c == '"') {
                    return b.toString();
                }
                if (c != '\\') {
                    b.append(c);
                    continue;
                }
                if (i >= s.length()) {
                    throw error();
                }
                char e = s.charAt(i++);
                switch (e) {
                    case 'n' -> b.append('\n');
                    case 't' -> b.append('\t');
                    case 'r' -> b.append('\r');
                    case 'b' -> b.append('\b');
                    case 'f' -> b.append('\f');
                    case 'u' -> {
                        if (i + 4 > s.length()) {
                            throw error();
                        }
                        b.append((char) Integer.parseInt(s.substring(i, i + 4), 16));
                        i += 4;
                    }
                    default -> b.append(e);
                }
            }
        }

        private Number number() {
            int start = i;
            while (i < s.length() && "+-0123456789.eE".indexOf(s.charAt(i)) >= 0) {
                i++;
            }
            String t = s.substring(start, i);
            try {
                if (t.matches("-?\\d+")) {
                    return Long.valueOf(t);
                }
                return Double.valueOf(t);
            } catch (NumberFormatException e) {
                throw error();
            }
        }
    }
}