import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.*;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class SingularApiClient {
    private static final int MAX_RETRIES = 3;
    private static final long BASE_DELAY_MS = 1000;
    private static final long MAX_DELAY_MS = 60000;
    private static final HttpClient client = HttpClient.newHttpClient();

    public static ApiResponse exponentialBackoffRequest(String url, Map<String, String> params) {
        for (int attempt = 0; attempt < MAX_RETRIES; attempt++) {
            try {
                HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create(url))
                    .header("Content-Type", "application/x-www-form-urlencoded")
                    .timeout(Duration.ofSeconds(10))
                    .POST(HttpRequest.BodyPublishers.ofString(buildFormBody(params)))
                    .build();

                HttpResponse<String> response = client.send(
                    request, HttpResponse.BodyHandlers.ofString());

                // Valid responses always return HTTP 200; check the body's status field.
                if (response.statusCode() == 200) {
                    JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();
                    if ("ok".equals(json.get("status").getAsString())) {
                        return new ApiResponse(true, response.body(), false);
                    }
                    String reason = json.has("reason")
                        ? json.get("reason").getAsString() : "Unknown error";
                    if (!isRetryableError(reason)) {
                        return new ApiResponse(false, reason, false);
                    }
                    // Retryable error: fall through to the backoff delay.
                }

            } catch (Exception error) {
                // Network/timeout errors are retryable.
                if (attempt == MAX_RETRIES - 1) {
                    return new ApiResponse(false, error.getMessage(), true);
                }
            }

            // Wait before the next attempt, with jitter to avoid a thundering herd.
            if (attempt < MAX_RETRIES - 1) {
                long delay = Math.min(BASE_DELAY_MS * (1L << attempt), MAX_DELAY_MS);
                long jitter = (long) (Math.random() * 1000);
                try {
                    Thread.sleep(delay + jitter);
                } catch (InterruptedException interrupted) {
                    Thread.currentThread().interrupt();
                }
            }
        }
        return new ApiResponse(false, "Max retries exceeded", true);
    }

    private static boolean isRetryableError(String reason) {
        String lower = reason.toLowerCase();
        for (String keyword : new String[] {"invalid", "missing", "should have", "no device id"}) {
            if (lower.contains(keyword)) {
                return false;
            }
        }
        return true;
    }

    private static String buildFormBody(Map<String, String> params) {
        StringBuilder body = new StringBuilder();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (body.length() > 0) {
                body.append('&');
            }
            body.append(URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8))
                .append('=')
                .append(URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8));
        }
        return body.toString();
    }
}

class ApiResponse {
    public final boolean success;
    public final String message;
    public final boolean retryable;

    public ApiResponse(boolean success, String message, boolean retryable) {
        this.success = success;
        this.message = message;
        this.retryable = retryable;
    }
}