public class RequestRetryingHelper implements InternetConnectionListener, RetryableRequest.OnRetryCalledListener {
    private boolean receiverPaused;
    private NetworkConnectionBroadcastReceiver networkConnectionBroadcastReceiver;
    private final ArrayList<RetryableRequest> retryables = new ArrayList<>();
    private MessageCallback messageCallback;

    public void onResume(@Nullable Context context) {
        if (networkConnectionBroadcastReceiver != null) {
            registerNetworkReceiver(context);
        }
    }

    public void onNewRetryable(@Nullable Context context, RetryableRequest request) {
        request.addOnRetryCalledListener(this);
        retryables.add(request);
        if (retryables.size() > 1) { //not first one
            return;
        }
        if (context == null) {
            return;
        }

        if (!NetworkConnectionBroadcastReceiver.isOnline(context)) {
            registerNetworkReceiver(context);
            showOfflineSnackbar();
        } else {
            showRetrySnackbar();
        }
    }

    public void onPause(@Nullable Context context) {
        pauseReceiver(context);
    }

    private void registerNetworkReceiver(@Nullable Context context) {
        if (context == null) {
            return;
        }
        networkConnectionBroadcastReceiver = new NetworkConnectionBroadcastReceiver(this);
        receiverPaused = false;
        context.registerReceiver(networkConnectionBroadcastReceiver,
                new IntentFilter(NetworkConnectionBroadcastReceiver.ACTION));
    }

    private void pauseReceiver(@Nullable Context context) {
        if (context == null || networkConnectionBroadcastReceiver == null) {
            return;
        }
        context.unregisterReceiver(networkConnectionBroadcastReceiver);
        receiverPaused = true;
    }

    private void unregisterNetworkReceiver(@Nullable Context context) {
        pauseReceiver(context);
        receiverPaused = false;
        networkConnectionBroadcastReceiver = null;
    }

    private void showOfflineSnackbar() {
        if (messageCallback == null) {
            return;
        }
        messageCallback.hideMessage();
        messageCallback.showMessage(R.string.network_connection_error);
    }

    private void showRetrySnackbar() {
        if (messageCallback == null) {
            return;
        }
        messageCallback.hideMessage();
        messageCallback.showMessage(R.string.retry_request_message, R.string.retry_request_action, this::invokeRetries);
    }

    private void hideMessage() {
        if (messageCallback != null) {
            messageCallback.hideMessage();
        }
    }

    @Override
    public void onInternetConnected() {
        invokeRetries();
    }

    @Override
    public void onInternetDisconnected() {

    }

    private void invokeRetries() {
        List<RetryableRequest> localInstance = new ArrayList<>(retryables); //concurrent modification exception
        for (RetryableRequest request : localInstance) {
            request.retry();
        }
    }

    @Override
    public void onRetryCalled(RetryableRequest request) {
        retryables.remove(request);
        if (retryables.size() == 0) {
            hideMessage();
            //todo unregister receiver
        }
    }

    public void clearRetryables(@Nullable Context context) {
        retryables.clear();
        if (receiverPaused) {
            networkConnectionBroadcastReceiver = null;
        } else {
            unregisterNetworkReceiver(context);
        }
        hideMessage();
    }

    public void setMessageCallback(MessageCallback messageCallback) {
        this.messageCallback = messageCallback;
    }

    public interface MessageCallback {
        void showMessage(@StringRes int messageId);
        void showMessage(@StringRes int messageId, @StringRes int actionTextId, Runnable action);
        void hideMessage();
    }
}