OpenExchangeApiClient.java

package com.openexchangeapi;

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.*;
import com.fasterxml.jackson.annotation.JsonAlias;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * Minimal OpenExchangeAPI Java SDK. All endpoints supported. API key is optional.
 * <p>
 * Usage:
 * <pre>
 *     OpenExchangeApiClient api = new OpenExchangeApiClient("YOUR_API_KEY");
 *     GetLatestRatesResponse latest = api.getLatest("EUR");
 *     System.out.println(latest.rates.get("USD"));
 * </pre>
 */
public class OpenExchangeApiClient {
    private final String apiKey;
    private final String baseUrl;
    private final HttpClient httpClient;
    private final ObjectMapper objectMapper;

    public OpenExchangeApiClient() {
        this(null, "https://api.openexchangeapi.com");
    }
    public OpenExchangeApiClient(String apiKey) {
        this(apiKey, "https://api.openexchangeapi.com");
    }
    public OpenExchangeApiClient(String apiKey, String baseUrl) {
        this.apiKey = apiKey;
        this.baseUrl = baseUrl.endsWith("/") ? baseUrl.substring(0, baseUrl.length() - 1) : baseUrl;
        this.httpClient = HttpClient.newHttpClient();
        this.objectMapper = new ObjectMapper();
    }

    private <T> T get(String path, Map<String, String> params, Class<T> clazz) throws IOException, InterruptedException {
        StringBuilder url = new StringBuilder(baseUrl + path);
        Map<String, String> qp = new LinkedHashMap<>();
        if (apiKey != null && !apiKey.isEmpty()) qp.put("app_id", apiKey);
        if (params != null) qp.putAll(params);
        if (!qp.isEmpty()) {
            url.append("?");
            url.append(qp.entrySet().stream().map(e -> e.getKey() + "=" + e.getValue()).reduce((a, b) -> a + "&" + b).orElse(""));
        }
        HttpRequest req = HttpRequest.newBuilder(URI.create(url.toString())).GET().build();
        HttpResponse<String> resp = httpClient.send(req, HttpResponse.BodyHandlers.ofString());
        if (resp.statusCode() >= 400) throw new IOException(resp.body());
        return objectMapper.readValue(resp.body(), clazz);
    }

    private <T> T get(String path, Map<String, String> params, TypeReference<T> typeRef) throws IOException, InterruptedException {
        StringBuilder url = new StringBuilder(baseUrl + path);
        Map<String, String> qp = new LinkedHashMap<>();
        if (apiKey != null && !apiKey.isEmpty()) qp.put("app_id", apiKey);
        if (params != null) qp.putAll(params);
        if (!qp.isEmpty()) {
            url.append("?");
            url.append(qp.entrySet().stream().map(e -> e.getKey() + "=" + e.getValue()).reduce((a, b) -> a + "&" + b).orElse(""));
        }
        HttpRequest req = HttpRequest.newBuilder(URI.create(url.toString())).GET().build();
        HttpResponse<String> resp = httpClient.send(req, HttpResponse.BodyHandlers.ofString());
        if (resp.statusCode() >= 400) throw new IOException(resp.body());
        return objectMapper.readValue(resp.body(), typeRef);
    }

    // --- API Methods ---
    /**
     * Get latest exchange rates.
     * @param base Optional base currency code (ISO 4217)
     * @return Latest rates response
     */
    public GetLatestRatesResponse getLatest(String base) throws IOException, InterruptedException {
        Map<String, String> params = base != null ? Map.of("base", base) : null;
        return get("/v1/latest", params, GetLatestRatesResponse.class);
    }
    /**
     * Get latest exchange rates (high precision).
     * @param base Optional base currency code (ISO 4217)
     * @return Latest precise rates response
     */
    public GetLatestPreciseRatesResponse getLatestPrecise(String base) throws IOException, InterruptedException {
        Map<String, String> params = base != null ? Map.of("base", base) : null;
        return get("/v1/latest-precise", params, GetLatestPreciseRatesResponse.class);
    }
    /**
     * Get historical exchange rates.
     * @param date Date in YYYY-MM-DD format
     * @param base Optional base currency code (ISO 4217)
     * @return Historical rates response
     */
    public GetHistoricalRatesResponse getHistorical(String date, String base) throws IOException, InterruptedException {
        if (date == null || date.isEmpty()) throw new IllegalArgumentException("date is required");
        Map<String, String> params = base != null ? Map.of("base", base) : null;
        return get("/v1/historical/" + date, params, GetHistoricalRatesResponse.class);
    }
    /**
     * Get historical exchange rates (high precision).
     * @param date Date in YYYY-MM-DD format
     * @param base Optional base currency code (ISO 4217)
     * @return Historical precise rates response
     */
    public GetHistoricalPreciseRatesResponse getHistoricalPrecise(String date, String base) throws IOException, InterruptedException {
        if (date == null || date.isEmpty()) throw new IllegalArgumentException("date is required");
        Map<String, String> params = base != null ? Map.of("base", base) : null;
        return get("/v1/historical-precise/" + date, params, GetHistoricalPreciseRatesResponse.class);
    }
    /**
     * Convert currency.
     * @param from Source currency code (ISO 4217)
     * @param to Target currency code (ISO 4217)
     * @param amount Amount to convert
     * @return Conversion result
     */
    public ConvertCurrencyResponse convert(String from, String to, double amount) throws IOException, InterruptedException {
        if (from == null || to == null) throw new IllegalArgumentException("from and to are required");
        Map<String, String> params = Map.of("from", from, "to", to, "amount", Double.toString(amount));
        return get("/v1/convert", params, ConvertCurrencyResponse.class);
    }
    /**
     * Convert currency (high precision).
     * @param from Source currency code (ISO 4217)
     * @param to Target currency code (ISO 4217)
     * @param amount Amount to convert (string for high precision)
     * @return Conversion result (high precision)
     */
    public ConvertCurrencyPreciseResponse convertPrecise(String from, String to, String amount) throws IOException, InterruptedException {
        if (from == null || to == null || amount == null) throw new IllegalArgumentException("from, to, and amount are required");
        Map<String, String> params = Map.of("from", from, "to", to, "amount", amount);
        return get("/v1/convert-precise", params, ConvertCurrencyPreciseResponse.class);
    }
    /**
     * List all supported currencies.
     * @param type Optional filter by currency type ("fiat" or "crypto")
     * @return List of currencies
     */
    public List<Currency> listCurrencies(String type) throws IOException, InterruptedException {
        Map<String, String> params = type != null ? Map.of("type", type) : null;
        return get("/v1/currencies", params, new TypeReference<List<Currency>>(){});
    }
    /**
     * Get currency by code.
     * @param code ISO 4217 currency code
     * @return Currency details
     */
    public GetCurrencyResponse getCurrency(String code) throws IOException, InterruptedException {
        if (code == null || code.isEmpty()) throw new IllegalArgumentException("code is required");
        return get("/v1/currencies/" + code, null, GetCurrencyResponse.class);
    }

    // --- Response Types ---
    /**
     * Response for /v1/latest endpoint (standard precision rates).
     */
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class GetLatestRatesResponse {
        public String base;
        public String date;
        public long timestamp;
        public Map<String, Double> rates;
    }
    /**
     * Response for /v1/latest-precise endpoint (high precision rates as strings).
     */
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class GetLatestPreciseRatesResponse {
        public String base;
        public String date;
        public long timestamp;
        public Map<String, String> rates;
        /**
         * Returns rates as doubles (parsed from strings).
         */
        public Map<String, Double> getRatesAsDouble() {
            Map<String, Double> out = new HashMap<>();
            if (rates != null) for (var e : rates.entrySet()) {
                try { out.put(e.getKey(), Double.parseDouble(e.getValue())); } catch (Exception ignore) {}
            }
            return out;
        }
    }
    /**
     * Response for /v1/historical/{date} endpoint (standard precision).
     */
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class GetHistoricalRatesResponse {
        public String base;
        public String date;
        public long timestamp;
        public Map<String, Double> rates;
    }
    /**
     * Response for /v1/historical-precise/{date} endpoint (high precision rates as strings).
     */
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class GetHistoricalPreciseRatesResponse {
        public String base;
        public String date;
        public long timestamp;
        public Map<String, String> rates;
        /**
         * Returns rates as doubles (parsed from strings).
         */
        public Map<String, Double> getRatesAsDouble() {
            Map<String, Double> out = new HashMap<>();
            if (rates != null) for (var e : rates.entrySet()) {
                try { out.put(e.getKey(), Double.parseDouble(e.getValue())); } catch (Exception ignore) {}
            }
            return out;
        }
    }
    /**
     * Response for /v1/convert endpoint (standard precision).
     */
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class ConvertCurrencyResponse {
        @JsonAlias("from") public String from;
        public String to;
        public double amount;
        public double rate;
        public double result;
    }
    /**
     * Response for /v1/convert-precise endpoint (high precision as strings).
     */
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class ConvertCurrencyPreciseResponse {
        @JsonAlias("from") public String from;
        public String to;
        public String amount;
        public String rate;
        public String result;
        /**
         * Amount as double (parsed from string).
         */
        public Double getAmountAsDouble() { try { return Double.parseDouble(amount); } catch (Exception e) { return null; } }
        /**
         * Rate as double (parsed from string).
         */
        public Double getRateAsDouble() { try { return Double.parseDouble(rate); } catch (Exception e) { return null; } }
        /**
         * Result as double (parsed from string).
         */
        public Double getResultAsDouble() { try { return Double.parseDouble(result); } catch (Exception e) { return null; } }
    }
    /**
     * Currency object returned by /v1/currencies and /v1/currencies/{code}.
     */
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class Currency {
        public String code;
        public String name;
        public String type;
        public int digits;
        public String symbol;
        public int iso_num;
        public Map<String, Object> meta;
    }
    /**
     * Response for /v1/currencies/{code} endpoint.
     */
    @JsonIgnoreProperties(ignoreUnknown = true)
    public static class GetCurrencyResponse {
        public Currency currency;
    }
}