package com.example.dcav2gui;

import static com.example.dcav2gui.MainActivity.globalSettings;

import android.app.AlertDialog;
import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.widget.Toast;

import com.example.dcav2gui.ui.earners.EarnerData;
import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public class EarnerInterface {

    private static final String API_BASE_URL = globalSettings.apiUrl;
    private static final String API_KEY = globalSettings.earnApiKey;
    private static final OkHttpClient httpClient = new OkHttpClient();


    public static void sendRequestGlobalData(Context context) {
        new Thread(() -> {
            try {
                EarnerGlobalData result = getEarnerGlobalData(true);
                new Handler(Looper.getMainLooper()).post(() -> showSimpleDialog("Global data", result.toString(), context));
            } catch (IOException e) {
                e.printStackTrace();
                new Handler(Looper.getMainLooper()).post(() -> Toast.makeText(context, "Failed to get global status", Toast.LENGTH_SHORT).show());
            }
        }).start();
    }

    public static void sendRequestTotalBalance(String exchange, Context context) {
        new Thread(() -> {
            try {
                JsonObject result = getTotalBalance(exchange, true);
                String dialogTitle = "Balances";
                String dialogMessage = "Trading balance: " + result.get("trading_balance").getAsString() +
                        " | Earning balance " + result.get("earning_balance").getAsString();
                new Handler(Looper.getMainLooper()).post(() -> showSimpleDialog(dialogTitle, dialogMessage, context));
            } catch (IOException e) {
                e.printStackTrace();
                new Handler(Looper.getMainLooper()).post(() -> Toast.makeText(context, "Failed to get total balance", Toast.LENGTH_SHORT).show());
            }
        }).start();
    }

    public static void sendRequestGetStepSize(String exchange, Context context) {
        new Thread(() -> {
            try {
                JsonObject result = getStepSize(exchange, true);
                new Handler(Looper.getMainLooper()).post(() -> showJsonDialog(result, context));
            } catch (IOException e) {
                e.printStackTrace();
                new Handler(Looper.getMainLooper()).post(() -> Toast.makeText(context, "Failed to get step size", Toast.LENGTH_SHORT).show());
            }
        }).start();
    }

    public static void sendRequestGetPercentage(String exchange, Context context) {
        new Thread(() -> {
            try {
                JsonObject result = getPercentage(exchange, true);
                new Handler(Looper.getMainLooper()).post(() -> showJsonDialog(result, context));
            } catch (IOException e) {
                e.printStackTrace();
                new Handler(Looper.getMainLooper()).post(() -> Toast.makeText(context, "Failed to get percentage", Toast.LENGTH_SHORT).show());
            }
        }).start();
    }

    public static void sendRequestLastSubscription(String exchange, Context context) {
        new Thread(() -> {
            try {
                JsonObject result = getLastSubscription(exchange, true);
                String dialogTitle = "Last subscription";
                String dialogMessage = result.get("last_subscription").toString();
                new Handler(Looper.getMainLooper()).post(() -> showSimpleDialog(dialogTitle, dialogMessage, context));
            } catch (IOException e) {
                e.printStackTrace();
                new Handler(Looper.getMainLooper()).post(() -> Toast.makeText(context, "Failed to get last subscription", Toast.LENGTH_SHORT).show());
            }
        }).start();
    }

    public static void sendRequestLastRedemption(String exchange, Context context) {
        new Thread(() -> {
            try {
                JsonObject result = getLastRedemption(exchange, true);
                String dialogTitle = "Last redemption";
                String dialogMessage = result.get("last_redemption").toString();
                new Handler(Looper.getMainLooper()).post(() -> showSimpleDialog(dialogTitle, dialogMessage, context));
            } catch (IOException e) {
                e.printStackTrace();
                new Handler(Looper.getMainLooper()).post(() -> Toast.makeText(context, "Failed to get last redemption", Toast.LENGTH_SHORT).show());
            }
        }).start();
    }

    public static void sendRequestGetTimeBetweenSubscriptions(String exchange, Context context) {
        new Thread(() -> {
            try {
                JsonObject result = getTimeBetweenSubscriptions(exchange, true);
                new Handler(Looper.getMainLooper()).post(() -> showJsonDialog(result, context));
            } catch (IOException e) {
                e.printStackTrace();
                new Handler(Looper.getMainLooper()).post(() -> Toast.makeText(context, "Failed to get last redemption", Toast.LENGTH_SHORT).show());
            }
        }).start();
    }

    public static void sendRequestGetTimeBetweenRedemptions(String exchange, Context context) {
        new Thread(() -> {
            try {
                JsonObject result = getTimeBetweenRedemptions(exchange, true);
                new Handler(Looper.getMainLooper()).post(() -> showJsonDialog(result, context));
            } catch (IOException e) {
                e.printStackTrace();
                new Handler(Looper.getMainLooper()).post(() -> Toast.makeText(context, "Failed to get last redemption", Toast.LENGTH_SHORT).show());
            }
        }).start();
    }

    public static void sendRequestGetMinimumAmountInTradingAccount(String exchange, Context context) {
        new Thread(() -> {
            try {
                JsonObject result = getMinimumAmountInTradingAccount(exchange, true);
                new Handler(Looper.getMainLooper()).post(() -> showJsonDialog(result, context));
            } catch (IOException e) {
                e.printStackTrace();
                new Handler(Looper.getMainLooper()).post(() -> Toast.makeText(context, "Failed to get last redemption", Toast.LENGTH_SHORT).show());
            }
        }).start();
    }

    public static EarnerGlobalData getEarnerGlobalData(boolean retry) throws IOException {
        double uptime = 0.0;
        List<EarnerData> earnerList = new ArrayList<>();

        Request getEarnerGlobalDataRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/get_global_status")
                .header("X-API-KEY", API_KEY)
                .build();
        try (Response getEarnerGlobalDataResponse = httpClient.newCall(getEarnerGlobalDataRequest).execute()) {
            if (!getEarnerGlobalDataResponse.isSuccessful()) {
                if (getEarnerGlobalDataResponse.code() == 503 && retry) {
                    return getEarnerGlobalData(false);
                }
                throw new IOException("Unexpected code " + getEarnerGlobalDataResponse);
            }
            String getEarnerGlobalDataResponseBody = getEarnerGlobalDataResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(getEarnerGlobalDataResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            if (jsonObject.has("Error")) {
                System.err.println("The parsed JSON response contains Error");
                return null;
            }

            for (String key : jsonObject.keySet()) {
                if (key.equals("uptime")) {
                    uptime = jsonObject.get(key).getAsDouble();
                } else {
                    JsonObject jsonEarner = jsonObject.get(key).getAsJsonObject();
                    earnerList.add(new EarnerData(
                            key,
                            jsonEarner.get("trading_balance").getAsDouble(),
                            jsonEarner.get("earning_balance").getAsDouble(),
                            jsonEarner.get("is_paused").getAsBoolean(),
                            jsonEarner.get("step_size").getAsDouble(),
                            jsonEarner.get("percentage").getAsDouble(),
                            jsonEarner.get("minimum_amount_in_trading_account").getAsDouble(),
                            jsonEarner.get("time_between_subscriptions").getAsDouble(),
                            jsonEarner.get("time_between_redemptions").getAsDouble(),
                            jsonEarner.get("last_subscription").getAsJsonObject(),
                            jsonEarner.get("last_redemption").getAsJsonObject()
                    ));
                }
            }
        }
        return new EarnerGlobalData(uptime, earnerList);
    }

    public static JsonObject togglePause(String exchange, boolean retry) throws IOException {
        Gson gson = new Gson();
        JsonObject jsonPayload = new JsonObject();
        jsonPayload.addProperty("broker", exchange);
        String jsonPayloadString = gson.toJson(jsonPayload);

        RequestBody requestBody = RequestBody.create(jsonPayloadString, MediaType.get("application/json; charset=utf-8"));
        Request togglePauseRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/toggle_pause")
                .header("X-API-KEY", API_KEY)
                .post(requestBody)
                .build();

        try (Response togglePauseResponse = httpClient.newCall(togglePauseRequest).execute()) {
            if (!togglePauseResponse.isSuccessful()) {
                if (togglePauseResponse.code() == 503 && retry) {
                    return togglePause(exchange, false);
                }
                throw new IOException("Unexpected code " + togglePauseResponse);
            }
            String togglePauseResponseBody = togglePauseResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(togglePauseResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            if (jsonObject.has("Error")) {
                System.err.println("The parsed JSON response contains Error");
                return jsonObject;
            }

            //If no error, the response is {"Status": true|false }
            return jsonObject;
        }
    }

    public static JsonObject getStepSize(String exchange, boolean retry) throws IOException {
        Request getStepSizeRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/get_step_size?broker=" + exchange)
                .header("X-API-KEY", API_KEY)
                .build();
        try (Response getStepSizeResponse = httpClient.newCall(getStepSizeRequest).execute()) {
            if (!getStepSizeResponse.isSuccessful()) {
                if (getStepSizeResponse.code() == 503 && retry) {
                    return getStepSize(exchange,false);
                }
                throw new IOException("Unexpected code " + getStepSizeResponse);
            }
            String getStepSizeResponseBody = getStepSizeResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(getStepSizeResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            return jsonElement.getAsJsonObject();
        }
    }

    public static JsonObject setStepSize(String exchange, double stepSize, boolean retry) throws IOException {
        Gson gson = new Gson();
        JsonObject jsonPayload = new JsonObject();
        jsonPayload.addProperty("broker", exchange);
        jsonPayload.addProperty("new_step_size", stepSize);
        String jsonPayloadString = gson.toJson(jsonPayload);

        RequestBody requestBody = RequestBody.create(jsonPayloadString, MediaType.get("application/json; charset=utf-8"));
        Request setStepSizeRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/set_step_size")
                .header("X-API-KEY", API_KEY)
                .post(requestBody)
                .build();

        try (Response setStepSizeResponse = httpClient.newCall(setStepSizeRequest).execute()) {
            if (!setStepSizeResponse.isSuccessful()) {
                if (setStepSizeResponse.code() == 503 && retry) {
                    return setStepSize(exchange, stepSize, false);
                }
                throw new IOException("Unexpected code " + setStepSizeResponse);
            }
            String setStepSizeResponseBody = setStepSizeResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(setStepSizeResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            if (jsonObject.has("Error")) {
                System.err.println("The parsed JSON response contains Error");
                return jsonObject;
            }

            //If no error, the response is {"step_size": stepSize }
            return jsonObject;
        }
    }

    public static JsonObject getPercentage(String exchange, boolean retry) throws IOException {
        Request getPercentageRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/get_percentage?broker=" + exchange)
                .header("X-API-KEY", API_KEY)
                .build();
        try (Response getPercentageResponse = httpClient.newCall(getPercentageRequest).execute()) {
            if (!getPercentageResponse.isSuccessful()) {
                if (getPercentageResponse.code() == 503 && retry) {
                    return getPercentage(exchange,false);
                }
                throw new IOException("Unexpected code " + getPercentageResponse);
            }
            String getPercentageResponseBody = getPercentageResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(getPercentageResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            return jsonElement.getAsJsonObject();
        }
    }

    public static JsonObject setPercentage(String exchange, double newPercentage, boolean retry) throws IOException {
        Gson gson = new Gson();
        JsonObject jsonPayload = new JsonObject();
        jsonPayload.addProperty("broker", exchange);
        jsonPayload.addProperty("new_percentage", newPercentage);
        String jsonPayloadString = gson.toJson(jsonPayload);

        RequestBody requestBody = RequestBody.create(jsonPayloadString, MediaType.get("application/json; charset=utf-8"));
        Request setPercentageRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/set_percentage")
                .header("X-API-KEY", API_KEY)
                .post(requestBody)
                .build();

        try (Response setPercentageResponse = httpClient.newCall(setPercentageRequest).execute()) {
            if (!setPercentageResponse.isSuccessful()) {
                if (setPercentageResponse.code() == 503 && retry) {
                    return setPercentage(exchange, newPercentage, false);
                }
                throw new IOException("Unexpected code " + setPercentageResponse);
            }
            String setPercentageResponseBody = setPercentageResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(setPercentageResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            if (jsonObject.has("Error")) {
                System.err.println("The parsed JSON response contains Error");
                return jsonObject;
            }

            //If no error, the response is {"percentage": newPercentage }
            return jsonObject;
        }
    }

    public static JsonObject getTimeBetweenSubscriptions(String exchange, boolean retry) throws IOException {
        Request getTimeBetweenSubscriptionsRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/get_time_between_subscriptions?broker=" + exchange)
                .header("X-API-KEY", API_KEY)
                .build();
        try (Response getTimeBetweenSubscriptionsResponse = httpClient.newCall(getTimeBetweenSubscriptionsRequest).execute()) {
            if (!getTimeBetweenSubscriptionsResponse.isSuccessful()) {
                if (getTimeBetweenSubscriptionsResponse.code() == 503 && retry) {
                    return getTimeBetweenSubscriptions(exchange,false);
                }
                throw new IOException("Unexpected code " + getTimeBetweenSubscriptionsResponse);
            }
            String getTimeBetweenSubscriptionsResponseBody = getTimeBetweenSubscriptionsResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(getTimeBetweenSubscriptionsResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            return jsonElement.getAsJsonObject();
        }
    }

    public static JsonObject setTimeBetweenSubscriptions(String exchange, double newTime, boolean retry) throws IOException {
        Gson gson = new Gson();
        JsonObject jsonPayload = new JsonObject();
        jsonPayload.addProperty("broker", exchange);
        jsonPayload.addProperty("new_time_between_subscriptions", newTime);
        String jsonPayloadString = gson.toJson(jsonPayload);

        RequestBody requestBody = RequestBody.create(jsonPayloadString, MediaType.get("application/json; charset=utf-8"));
        Request setTimeBetweenSubscriptionsRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/set_time_between_subscriptions")
                .header("X-API-KEY", API_KEY)
                .post(requestBody)
                .build();

        try (Response setTimeBetweenSubscriptionsResponse = httpClient.newCall(setTimeBetweenSubscriptionsRequest).execute()) {
            if (!setTimeBetweenSubscriptionsResponse.isSuccessful()) {
                if (setTimeBetweenSubscriptionsResponse.code() == 503 && retry) {
                    return setTimeBetweenSubscriptions(exchange, newTime, false);
                }
                throw new IOException("Unexpected code " + setTimeBetweenSubscriptionsResponse);
            }
            String setTimeBetweenSubscriptionsResponseBody = setTimeBetweenSubscriptionsResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(setTimeBetweenSubscriptionsResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            if (jsonObject.has("Error")) {
                System.err.println("The parsed JSON response contains Error");
                return jsonObject;
            }

            //If no error, the response is {"time_between_subscriptions": newTime }
            return jsonObject;
        }
    }

    public static JsonObject getTimeBetweenRedemptions(String exchange, boolean retry) throws IOException {
        Request getTimeBetweenRedemptionsRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/get_time_between_redemptions?broker=" + exchange)
                .header("X-API-KEY", API_KEY)
                .build();
        try (Response getTimeBetweenRedemptionsResponse = httpClient.newCall(getTimeBetweenRedemptionsRequest).execute()) {
            if (!getTimeBetweenRedemptionsResponse.isSuccessful()) {
                if (getTimeBetweenRedemptionsResponse.code() == 503 && retry) {
                    return getTimeBetweenRedemptions(exchange,false);
                }
                throw new IOException("Unexpected code " + getTimeBetweenRedemptionsResponse);
            }
            String getTimeBetweenRedemptionsResponseBody = getTimeBetweenRedemptionsResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(getTimeBetweenRedemptionsResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            return jsonElement.getAsJsonObject();
        }
    }

    public static JsonObject setTimeBetweenRedemptions(String exchange, double newTime, boolean retry) throws IOException {
        Gson gson = new Gson();
        JsonObject jsonPayload = new JsonObject();
        jsonPayload.addProperty("broker", exchange);
        jsonPayload.addProperty("new_time_between_redemptions", newTime);
        String jsonPayloadString = gson.toJson(jsonPayload);

        RequestBody requestBody = RequestBody.create(jsonPayloadString, MediaType.get("application/json; charset=utf-8"));
        Request setTimeBetweenRedemptionsRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/set_time_between_redemptions")
                .header("X-API-KEY", API_KEY)
                .post(requestBody)
                .build();

        try (Response setTimeBetweenRedemptionsResponse = httpClient.newCall(setTimeBetweenRedemptionsRequest).execute()) {
            if (!setTimeBetweenRedemptionsResponse.isSuccessful()) {
                if (setTimeBetweenRedemptionsResponse.code() == 503 && retry) {
                    return setTimeBetweenRedemptions(exchange, newTime, false);
                }
                throw new IOException("Unexpected code " + setTimeBetweenRedemptionsResponse);
            }
            String setTimeBetweenRedemptionsResponseBody = setTimeBetweenRedemptionsResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(setTimeBetweenRedemptionsResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            if (jsonObject.has("Error")) {
                System.err.println("The parsed JSON response contains Error");
                return jsonObject;
            }

            //If no error, the response is {"time_between_redemptions": newTime }
            return jsonObject;
        }
    }

    public static JsonObject getMinimumAmountInTradingAccount(String exchange, boolean retry) throws IOException {
        Request getMinimumAmountInTradingAccountRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/get_minimum_amount_in_trading_account?broker=" + exchange)
                .header("X-API-KEY", API_KEY)
                .build();
        try (Response getMinimumAmountInTradingAccountResponse = httpClient.newCall(getMinimumAmountInTradingAccountRequest).execute()) {
            if (!getMinimumAmountInTradingAccountResponse.isSuccessful()) {
                if (getMinimumAmountInTradingAccountResponse.code() == 503 && retry) {
                    return getMinimumAmountInTradingAccount(exchange,false);
                }
                throw new IOException("Unexpected code " + getMinimumAmountInTradingAccountResponse);
            }
            String getMinimumAmountInTradingAccountResponseBody = getMinimumAmountInTradingAccountResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(getMinimumAmountInTradingAccountResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            return jsonElement.getAsJsonObject();
        }
    }

    public static JsonObject setMinimumAmountInTradingAccount(String exchange, double minAmount, boolean retry) throws IOException {
        Gson gson = new Gson();
        JsonObject jsonPayload = new JsonObject();
        jsonPayload.addProperty("broker", exchange);
        jsonPayload.addProperty("new_minimum_amount_in_trading_account", minAmount);
        String jsonPayloadString = gson.toJson(jsonPayload);

        RequestBody requestBody = RequestBody.create(jsonPayloadString, MediaType.get("application/json; charset=utf-8"));
        Request setMinimumAmountInTradingAccountRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/set_minimum_amount_in_trading_account")
                .header("X-API-KEY", API_KEY)
                .post(requestBody)
                .build();

        try (Response setMinimumAmountInTradingAccountResponse = httpClient.newCall(setMinimumAmountInTradingAccountRequest).execute()) {
            if (!setMinimumAmountInTradingAccountResponse.isSuccessful()) {
                if (setMinimumAmountInTradingAccountResponse.code() == 503 && retry) {
                    return setMinimumAmountInTradingAccount(exchange, minAmount, false);
                }
                throw new IOException("Unexpected code " + setMinimumAmountInTradingAccountResponse);
            }
            String setMinimumAmountInTradingAccountResponseBody = setMinimumAmountInTradingAccountResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(setMinimumAmountInTradingAccountResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            if (jsonObject.has("Error")) {
                System.err.println("The parsed JSON response contains Error");
                return jsonObject;
            }

            //If no error, the response is {"minimum_amount_in_trading_account": minAmount}
            return jsonObject;
        }
    }

    public static JsonObject getLastSubscription(String exchange, boolean retry) throws IOException {
        Request getLastSubscriptionRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/get_last_subscription?broker=" + exchange)
                .header("X-API-KEY", API_KEY)
                .build();
        try (Response getLastSubscriptionResponse = httpClient.newCall(getLastSubscriptionRequest).execute()) {
            if (!getLastSubscriptionResponse.isSuccessful()) {
                if (getLastSubscriptionResponse.code() == 503 && retry) {
                    return getLastSubscription(exchange,false);
                }
                throw new IOException("Unexpected code " + getLastSubscriptionResponse);
            }
            String getLastSubscriptionResponseBody = getLastSubscriptionResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(getLastSubscriptionResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            if (jsonObject.has("Error")) {
                System.err.println("The parsed JSON response contains Error");
                return jsonObject;
            }

            return jsonObject;
        }
    }

    public static JsonObject getLastRedemption(String exchange, boolean retry) throws IOException {
        Request getLastRedemptionRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/get_last_redemption?broker=" + exchange)
                .header("X-API-KEY", API_KEY)
                .build();
        try (Response getLastRedemptionResponse = httpClient.newCall(getLastRedemptionRequest).execute()) {
            if (!getLastRedemptionResponse.isSuccessful()) {
                if (getLastRedemptionResponse.code() == 503 && retry) {
                    return getLastRedemption(exchange,false);
                }
                throw new IOException("Unexpected code " + getLastRedemptionResponse);
            }
            String getLastRedemptionResponseBody = getLastRedemptionResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(getLastRedemptionResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            if (jsonObject.has("Error")) {
                System.err.println("The parsed JSON response contains Error");
                return jsonObject;
            }

            return jsonObject;
        }
    }

    public static JsonObject getTotalBalance(String exchange, boolean retry) throws IOException {
        Request getTotalBalanceRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/get_total_balance?broker=" + exchange)
                .header("X-API-KEY", API_KEY)
                .build();
        try (Response getTotalBalanceResponse = httpClient.newCall(getTotalBalanceRequest).execute()) {
            if (!getTotalBalanceResponse.isSuccessful()) {
                if (getTotalBalanceResponse.code() == 503 && retry) {
                    return getTotalBalance(exchange,false);
                }
                throw new IOException("Unexpected code " + getTotalBalanceResponse);
            }
            String getTotalBalanceResponseBody = getTotalBalanceResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(getTotalBalanceResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            return jsonElement.getAsJsonObject();
        }
    }

    public static JsonObject subscribeFunds(String exchange, double amount, boolean retry) throws IOException {
        Gson gson = new Gson();
        JsonObject jsonPayload = new JsonObject();
        jsonPayload.addProperty("broker", exchange);
        jsonPayload.addProperty("amount", amount);
        String jsonPayloadString = gson.toJson(jsonPayload);

        RequestBody requestBody = RequestBody.create(jsonPayloadString, MediaType.get("application/json; charset=utf-8"));
        Request subscribeFundsRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/subscribe")
                .header("X-API-KEY", API_KEY)
                .post(requestBody)
                .build();

        try (Response subscribeFundsResponse = httpClient.newCall(subscribeFundsRequest).execute()) {
            if (!subscribeFundsResponse.isSuccessful()) {
                if (subscribeFundsResponse.code() == 503 && retry) {
                    return subscribeFunds(exchange, amount, false);
                }
                throw new IOException("Unexpected code " + subscribeFundsResponse);
            }
            String subscribeFundsResponseBody = subscribeFundsResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(subscribeFundsResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            if (jsonObject.has("Error")) {
                System.err.println("The parsed JSON response contains Error");
                return jsonObject;
            }

            //If no errors in the request, the response is {"Success": 0 (success) | 1 (earner error)}
            return jsonObject;
        }
    }

    public static JsonObject redeemFunds(String exchange, double amount, boolean retry) throws IOException {
        Gson gson = new Gson();
        JsonObject jsonPayload = new JsonObject();
        jsonPayload.addProperty("broker", exchange);
        jsonPayload.addProperty("amount", amount);
        String jsonPayloadString = gson.toJson(jsonPayload);

        RequestBody requestBody = RequestBody.create(jsonPayloadString, MediaType.get("application/json; charset=utf-8"));
        Request redeemFundsRequest = new Request.Builder()
                .url(API_BASE_URL + "/earn/redeem")
                .header("X-API-KEY", API_KEY)
                .post(requestBody)
                .build();

        try (Response redeemFundsResponse = httpClient.newCall(redeemFundsRequest).execute()) {
            if (!redeemFundsResponse.isSuccessful()) {
                if (redeemFundsResponse.code() == 503 && retry) {
                    return redeemFunds(exchange, amount, false);
                }
                throw new IOException("Unexpected code " + redeemFundsResponse);
            }
            String redeemFundsResponseBody = redeemFundsResponse.body().string();
            JsonElement jsonElement = JsonParser.parseString(redeemFundsResponseBody);
            if (!jsonElement.isJsonObject()) {
                System.err.println("The parsed JSON response is not a JsonObject.");
                return null;
            }
            JsonObject jsonObject = jsonElement.getAsJsonObject();
            if (jsonObject.has("Error")) {
                System.err.println("The parsed JSON response contains Error");
                return jsonObject;
            }

            //If no errors in the request, the response is {"Success": 0 (success) | 1 (earner error)}
            return jsonObject;
        }
    }


    public static void showSimpleDialog(String title, String message, Context context) {
        AlertDialog.Builder builder = new AlertDialog.Builder(context);

        builder.setTitle(title);
        builder.setMessage(message);
        builder.setPositiveButton("OK", null);
        builder.show();
    }

    public static void showJsonDialog(JsonObject result, Context context) {
        AlertDialog.Builder builder = new AlertDialog.Builder(context);

        for (String key: result.keySet()) {
            builder.setTitle(key);
            builder.setMessage(result.get(key).getAsString());
        }
        builder.setPositiveButton("OK", null);
        builder.show();
    }

    public static class EarnerGlobalData {
        private final double uptime;
        private final List<EarnerData> earnerList;

        public EarnerGlobalData(double uptime, List<EarnerData> earnerList) {
            this.uptime = uptime;
            this.earnerList = earnerList;
        }

        public double getUptime() {
            return uptime;
        }

        public List<EarnerData> getEarnerList() {
            return earnerList;
        }
    }
}