/*
 * Copyright (c) 2015, 2024, Oracle and/or its affiliates.
 *
 * This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License, version 2.0, as published by
 * the Free Software Foundation.
 *
 * This program is designed to work with certain software that is licensed under separate terms, as designated in a particular file or component or in
 * included license documentation. The authors of MySQL hereby grant you an additional permission to link the program and your derivative works with the
 * separately licensed software that they have either included with the program or referenced in the documentation.
 *
 * Without limiting anything contained in the foregoing, this file, which is part of MySQL Connector/J, is also subject to the Universal FOSS Exception,
 * version 1.0, a copy of which can be found at http://oss.oracle.com/licenses/universal-foss-exception.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, for more details.
 *
 * You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

package com.mysql.cj.jdbc.ha;

import static com.mysql.cj.util.StringUtils.isNullOrEmpty;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.Executor;

import com.mysql.cj.Messages;
import com.mysql.cj.PingTarget;
import com.mysql.cj.conf.ConnectionUrl;
import com.mysql.cj.conf.HostInfo;
import com.mysql.cj.conf.HostsListView;
import com.mysql.cj.conf.PropertyKey;
import com.mysql.cj.conf.url.LoadBalanceConnectionUrl;
import com.mysql.cj.conf.url.ReplicationConnectionUrl;
import com.mysql.cj.exceptions.MysqlErrorNumbers;
import com.mysql.cj.jdbc.JdbcConnection;
import com.mysql.cj.jdbc.JdbcStatement;
import com.mysql.cj.jdbc.exceptions.SQLError;

/**
 * Connection that opens two connections, one two a replication source, and another to one or more replicas, and decides to use source when the connection is
 * not
 * read-only, and use replica(s) when the connection is read-only.
 */
public class ReplicationConnectionProxy extends MultiHostConnectionProxy implements PingTarget {

    private ReplicationConnection thisAsReplicationConnection;

    protected boolean enableJMX = false;
    protected boolean allowSourceDownConnections = false;
    protected boolean allowReplicaDownConnections = false;
    protected boolean readFromSourceWhenNoReplicas = false;
    protected boolean readFromSourceWhenNoReplicasOriginal = false;
    protected boolean readOnly = false;

    ReplicationConnectionGroup connectionGroup;
    private long connectionGroupID = -1;

    private List<HostInfo> sourceHosts;
    protected LoadBalancedConnection sourceConnection;

    private List<HostInfo> replicaHosts;
    protected LoadBalancedConnection replicasConnection;

    /**
     * Static factory to create {@link ReplicationConnection} instances.
     *
     * @param connectionUrl
     *            The connection URL containing the hosts in a replication setup.
     * @return A {@link ReplicationConnection} proxy.
     * @throws SQLException
     *             if an error occurs
     */
    public static ReplicationConnection createProxyInstance(ConnectionUrl connectionUrl) throws SQLException {
        ReplicationConnectionProxy connProxy = new ReplicationConnectionProxy(connectionUrl);
        return (ReplicationConnection) java.lang.reflect.Proxy.newProxyInstance(ReplicationConnection.class.getClassLoader(),
                new Class<?>[] { ReplicationConnection.class, JdbcConnection.class }, connProxy);
    }

    /**
     * Creates a proxy for java.sql.Connection that routes requests to a load-balanced connection of source servers or a load-balanced connection of replica
     * servers. Each sub-connection is created with its own set of independent properties.
     *
     * @param connectionUrl
     *            The connection URL containing the hosts in a replication setup.
     * @throws SQLException
     *             if an error occurs
     */
    private ReplicationConnectionProxy(ConnectionUrl connectionUrl) throws SQLException {
        super();

        Properties props = connectionUrl.getConnectionArgumentsAsProperties();

        this.thisAsReplicationConnection = (ReplicationConnection) this.thisAsConnection;

        this.connectionUrl = connectionUrl;

        String enableJMXAsString = props.getProperty(PropertyKey.ha_enableJMX.getKeyName(), "false");
        try {
            this.enableJMX = Boolean.parseBoolean(enableJMXAsString);
        } catch (Exception e) {
            throw SQLError.createSQLException(Messages.getString("MultihostConnection.badValueForHaEnableJMX", new Object[] { enableJMXAsString }),
                    MysqlErrorNumbers.SQLSTATE_CONNJ_ILLEGAL_ARGUMENT, null);
        }

        String allowSourceDownConnectionsAsString = props.getProperty(PropertyKey.allowSourceDownConnections.getKeyName(), "false");
        try {
            this.allowSourceDownConnections = Boolean.parseBoolean(allowSourceDownConnectionsAsString);
        } catch (Exception e) {
            throw SQLError.createSQLException(
                    Messages.getString("ReplicationConnectionProxy.badValueForAllowSourceDownConnections", new Object[] { enableJMXAsString }),
                    MysqlErrorNumbers.SQLSTATE_CONNJ_ILLEGAL_ARGUMENT, null);
        }

        String allowReplicaDownConnectionsAsString = props.getProperty(PropertyKey.allowReplicaDownConnections.getKeyName(), "false");
        try {
            this.allowReplicaDownConnections = Boolean.parseBoolean(allowReplicaDownConnectionsAsString);
        } catch (Exception e) {
            throw SQLError.createSQLException(Messages.getString("ReplicationConnectionProxy.badValueForAllowReplicaDownConnections",
                    new Object[] { allowReplicaDownConnectionsAsString }), MysqlErrorNumbers.SQLSTATE_CONNJ_ILLEGAL_ARGUMENT, null);
        }

        String readFromSourceWhenNoReplicasAsString = props.getProperty(PropertyKey.readFromSourceWhenNoReplicas.getKeyName());
        try {
            this.readFromSourceWhenNoReplicasOriginal = Boolean.parseBoolean(readFromSourceWhenNoReplicasAsString);

        } catch (Exception e) {
            throw SQLError.createSQLException(Messages.getString("ReplicationConnectionProxy.badValueForReadFromSourceWhenNoReplicas",
                    new Object[] { readFromSourceWhenNoReplicasAsString }), MysqlErrorNumbers.SQLSTATE_CONNJ_ILLEGAL_ARGUMENT, null);
        }

        String group = props.getProperty(PropertyKey.replicationConnectionGroup.getKeyName(), null);
        if (!isNullOrEmpty(group) && ReplicationConnectionUrl.class.isAssignableFrom(connectionUrl.getClass())) {
            this.connectionGroup = ReplicationConnectionGroupManager.getConnectionGroupInstance(group);
            if (this.enableJMX) {
                ReplicationConnectionGroupManager.registerJmx();
            }
            this.connectionGroupID = this.connectionGroup.registerReplicationConnection(this.thisAsReplicationConnection,
                    ((ReplicationConnectionUrl) connectionUrl).getSourcesListAsHostPortPairs(),
                    ((ReplicationConnectionUrl) connectionUrl).getReplicasListAsHostPortPairs());

            this.sourceHosts = ((ReplicationConnectionUrl) connectionUrl).getSourceHostsListFromHostPortPairs(this.connectionGroup.getSourceHosts());
            this.replicaHosts = ((ReplicationConnectionUrl) connectionUrl).getReplicaHostsListFromHostPortPairs(this.connectionGroup.getReplicaHosts());
        } else {
            this.sourceHosts = new ArrayList<>(connectionUrl.getHostsList(HostsListView.SOURCES));
            this.replicaHosts = new ArrayList<>(connectionUrl.getHostsList(HostsListView.REPLICAS));
        }

        resetReadFromSourceWhenNoReplicas();

        // Initialize replicas connection first so that it is ready to be used in case the sources connection fails and 'allowSourceDownConnections=true'.
        try {
            initializeReplicasConnection();
        } catch (SQLException e) {
            if (!this.allowReplicaDownConnections) {
                if (this.connectionGroup != null) {
                    this.connectionGroup.handleCloseConnection(this.thisAsReplicationConnection);
                }
                throw e;
            } // Else swallow this exception.
        }

        SQLException exCaught = null;
        try {
            this.currentConnection = initializeSourceConnection();
        } catch (SQLException e) {
            exCaught = e;
        }

        if (this.currentConnection == null) {
            if (this.allowSourceDownConnections && this.replicasConnection != null) {
                // Set read-only and fail over to the replicas connection.
                this.readOnly = true;
                this.currentConnection = this.replicasConnection;
            } else {
                if (this.connectionGroup != null) {
                    this.connectionGroup.handleCloseConnection(this.thisAsReplicationConnection);
                }
                if (exCaught != null) {
                    throw exCaught;
                }
                throw SQLError.createSQLException(Messages.getString("ReplicationConnectionProxy.initializationWithEmptyHostsLists"),
                        MysqlErrorNumbers.SQLSTATE_CONNJ_ILLEGAL_ARGUMENT, null);
            }
        }
    }

    /**
     * Wraps this object with a new replication Connection instance.
     *
     * @return
     *         The connection object instance that wraps 'this'.
     */
    @Override
    JdbcConnection getNewWrapperForThisAsConnection() throws SQLException {
        return new ReplicationMySQLConnection(this);
    }

    /**
     * Propagates the connection proxy down through all live connections.
     *
     * @param proxyConn
     *            The top level connection in the multi-host connections chain.
     */
    @Override
    protected void propagateProxyDown(JdbcConnection proxyConn) {
        if (this.sourceConnection != null) {
            this.sourceConnection.setProxy(proxyConn);
        }
        if (this.replicasConnection != null) {
            this.replicasConnection.setProxy(proxyConn);
        }
    }

    /**
     * Has no use in replication connections. Always return <code>false</code>.
     *
     * @param t
     *            The Exception instance to check.
     */
    @Override
    boolean shouldExceptionTriggerConnectionSwitch(Throwable t) {
        return false;
    }

    /**
     * Checks if current connection is the sources l/b connection.
     */
    @Override
    public boolean isSourceConnection() {
        return this.currentConnection != null && this.currentConnection == this.sourceConnection;
    }

    /**
     * Checks if current connection is the replicas l/b connection.
     *
     * @return true if current connection is the replicas l/b connection
     */
    public boolean isReplicasConnection() {
        return this.currentConnection != null && this.currentConnection == this.replicasConnection;
    }

    @Override
    void pickNewConnection() throws SQLException {
        // no-op
    }

    @Override
    void syncSessionState(JdbcConnection source, JdbcConnection target, boolean readonly) throws SQLException {
        try {
            super.syncSessionState(source, target, readonly);
        } catch (SQLException e1) {
            try {
                // Try again. It may happen that the connection had recovered in the meantime but the right syncing wasn't done yet.
                super.syncSessionState(source, target, readonly);
            } catch (SQLException e2) {
            }
            // Swallow both exceptions. Replication connections must continue to "work" after swapping between sources and replicas.
        }
    }

    @Override
    void doClose() throws SQLException {
        if (this.sourceConnection != null) {
            this.sourceConnection.close();
        }
        if (this.replicasConnection != null) {
            this.replicasConnection.close();
        }

        if (this.connectionGroup != null) {
            this.connectionGroup.handleCloseConnection(this.thisAsReplicationConnection);
        }
    }

    @Override
    void doAbortInternal() throws SQLException {
        this.sourceConnection.abortInternal();
        this.replicasConnection.abortInternal();
        if (this.connectionGroup != null) {
            this.connectionGroup.handleCloseConnection(this.thisAsReplicationConnection);
        }
    }

    @Override
    void doAbort(Executor executor) throws SQLException {
        this.sourceConnection.abort(executor);
        this.replicasConnection.abort(executor);
        if (this.connectionGroup != null) {
            this.connectionGroup.handleCloseConnection(this.thisAsReplicationConnection);
        }
    }

    /**
     * Proxies method invocation on the java.sql.Connection interface.
     * This is the continuation of MultiHostConnectionProxy#invoke(Object, Method, Object[]).
     */
    @Override
    Object invokeMore(Object proxy, Method method, Object[] args) throws Throwable {
        checkConnectionCapabilityForMethod(method);

        boolean invokeAgain = false;
        while (true) {
            try {
                Object result = method.invoke(this.thisAsConnection, args);
                if (result != null && result instanceof JdbcStatement) {
                    ((JdbcStatement) result).setPingTarget(this);
                }
                return result;
            } catch (InvocationTargetException e) {
                if (invokeAgain) {
                    invokeAgain = false;
                } else if (e.getCause() != null && e.getCause() instanceof SQLException
                        && ((SQLException) e.getCause()).getSQLState() == MysqlErrorNumbers.SQLSTATE_INVALID_TRANSACTION_STATE_NO_SUBCLASS
                        && ((SQLException) e.getCause()).getErrorCode() == MysqlErrorNumbers.ERROR_CODE_NULL_LOAD_BALANCED_CONNECTION) {
                    try {
                        // Try to re-establish the connection with the last known read-only state.
                        setReadOnly(this.readOnly);
                        invokeAgain = true;
                    } catch (SQLException sqlEx) {
                        // Still not good. Swallow this exception.
                    }
                }
                if (!invokeAgain) {
                    throw e;
                }
            }
        }
    }

    /**
     * Checks if this connection is in a state capable to invoke the provided method. If the connection is in an inconsistent state, i.e. it has no hosts for
     * both sub-connections, then throw an invalid transaction state exception. Nevertheless, the methods defined in the ReplicationConnection interface will be
     * allowed as they are the only way to leave from an empty hosts lists situation.
     *
     * @param method
     *            method
     * @throws Throwable
     *             if an error occurs
     */
    private void checkConnectionCapabilityForMethod(Method method) throws Throwable {
        if (this.sourceHosts.isEmpty() && this.replicaHosts.isEmpty() && !ReplicationConnection.class.isAssignableFrom(method.getDeclaringClass())) {
            throw SQLError.createSQLException(Messages.getString("ReplicationConnectionProxy.noHostsInconsistentState"),
                    MysqlErrorNumbers.SQLSTATE_INVALID_TRANSACTION_STATE_NO_SUBCLASS, MysqlErrorNumbers.ERROR_CODE_REPLICATION_CONNECTION_WITH_NO_HOSTS, true,
                    null);
        }
    }

    /**
     * Pings both l/b connections. Switch to another connection in case of failure.
     */
    @Override
    public void doPing() throws SQLException {
        boolean isSourceConn = isSourceConnection();

        SQLException sourcesPingException = null;
        SQLException replicasPingException = null;

        if (this.sourceConnection != null) {
            try {
                this.sourceConnection.ping();
            } catch (SQLException e) {
                sourcesPingException = e;
            }
        } else {
            initializeSourceConnection();
        }

        if (this.replicasConnection != null) {
            try {
                this.replicasConnection.ping();
            } catch (SQLException e) {
                replicasPingException = e;
            }
        } else {
            try {
                initializeReplicasConnection();
                if (switchToReplicasConnectionIfNecessary()) {
                    isSourceConn = false;
                }
            } catch (SQLException e) {
                if (this.sourceConnection == null || !this.readFromSourceWhenNoReplicas) {
                    throw e;
                } // Else swallow this exception.
            }
        }

        if (isSourceConn && sourcesPingException != null) {
            // Switch to replicas connection.
            if (this.replicasConnection != null && replicasPingException == null) {
                this.sourceConnection = null;
                this.currentConnection = this.replicasConnection;
                this.readOnly = true;
            }
            throw sourcesPingException;

        } else if (!isSourceConn && (replicasPingException != null || this.replicasConnection == null)) {
            // Switch to sources connection, setting read-only state, if 'readFromSourceWhenNoReplicas=true'.
            if (this.sourceConnection != null && this.readFromSourceWhenNoReplicas && sourcesPingException == null) {
                this.replicasConnection = null;
                this.currentConnection = this.sourceConnection;
                this.readOnly = true;
                this.currentConnection.setReadOnly(true);
            }
            if (replicasPingException != null) {
                throw replicasPingException;
            }
        }
    }

    private JdbcConnection initializeSourceConnection() throws SQLException {
        this.sourceConnection = null;

        if (this.sourceHosts.size() == 0) {
            return null;
        }

        LoadBalancedConnection newSourceConn = LoadBalancedConnectionProxy
                .createProxyInstance(new LoadBalanceConnectionUrl(this.sourceHosts, this.connectionUrl.getOriginalProperties()));
        newSourceConn.setProxy(getProxy());

        this.sourceConnection = newSourceConn;
        return this.sourceConnection;
    }

    private JdbcConnection initializeReplicasConnection() throws SQLException {
        this.replicasConnection = null;

        if (this.replicaHosts.size() == 0) {
            return null;
        }

        LoadBalancedConnection newReplicasConn = LoadBalancedConnectionProxy
                .createProxyInstance(new LoadBalanceConnectionUrl(this.replicaHosts, this.connectionUrl.getOriginalProperties()));
        newReplicasConn.setProxy(getProxy());
        newReplicasConn.setReadOnly(true);

        this.replicasConnection = newReplicasConn;
        return this.replicasConnection;
    }

    private boolean switchToSourceConnection() throws SQLException {
        getLock().lock();
        try {
            if (this.sourceConnection == null || this.sourceConnection.isClosed()) {
                try {
                    if (initializeSourceConnection() == null) {
                        return false;
                    }
                } catch (SQLException e) {
                    this.currentConnection = null;
                    throw e;
                }
            }
            if (!isSourceConnection() && this.sourceConnection != null) {
                syncSessionState(this.currentConnection, this.sourceConnection, false);
                this.currentConnection = this.sourceConnection;
            }
            return true;
        } finally {
            getLock().unlock();
        }
    }

    private boolean switchToReplicasConnection() throws SQLException {
        getLock().lock();
        try {
            if (this.replicasConnection == null || this.replicasConnection.isClosed()) {
                try {
                    if (initializeReplicasConnection() == null) {
                        return false;
                    }
                } catch (SQLException e) {
                    this.currentConnection = null;
                    throw e;
                }
            }
            if (!isReplicasConnection() && this.replicasConnection != null) {
                syncSessionState(this.currentConnection, this.replicasConnection, true);
                this.currentConnection = this.replicasConnection;
            }
            return true;
        } finally {
            getLock().unlock();
        }
    }

    private boolean switchToReplicasConnectionIfNecessary() throws SQLException {
        // Switch to replicas connection:
        // - If the current connection is null. Or,
        // - If we're currently on the source and in read-only mode - we didn't have any replicas to use until now. Or,
        // - If we're currently on a closed source connection and there are no sources to connect to. Or,
        // - If we're currently not on a source connection that is closed - means that we were on a closed replicas connection before it was re-initialized.
        if (this.currentConnection == null || isSourceConnection() && (this.readOnly || this.sourceHosts.isEmpty() && this.currentConnection.isClosed())
                || !isSourceConnection() && this.currentConnection.isClosed()) {
            return switchToReplicasConnection();
        }
        return false;
    }

    public JdbcConnection getCurrentConnection() {
        getLock().lock();
        try {
            return this.currentConnection == null ? LoadBalancedConnectionProxy.getNullLoadBalancedConnectionInstance() : this.currentConnection;
        } finally {
            getLock().unlock();
        }
    }

    public long getConnectionGroupId() {
        return this.connectionGroupID;
    }

    public JdbcConnection getSourceConnection() {
        getLock().lock();
        try {
            return this.sourceConnection;
        } finally {
            getLock().unlock();
        }
    }

    public void promoteReplicaToSource(String hostPortPair) throws SQLException {
        getLock().lock();
        try {
            HostInfo host = getReplicaHost(hostPortPair);
            if (host == null) {
                return;
            }
            this.sourceHosts.add(host);
            removeReplica(hostPortPair);
            if (this.sourceConnection != null) {
                this.sourceConnection.addHost(hostPortPair);
            }

            // Switch back to the sources connection if this connection was running in fail-safe mode.
            if (!this.readOnly && !isSourceConnection()) {
                switchToSourceConnection();
            }
        } finally {
            getLock().unlock();
        }
    }

    public void removeSourceHost(String hostPortPair) throws SQLException {
        getLock().lock();
        try {
            this.removeSourceHost(hostPortPair, true);
        } finally {
            getLock().unlock();
        }
    }

    public void removeSourceHost(String hostPortPair, boolean waitUntilNotInUse) throws SQLException {
        getLock().lock();
        try {
            this.removeSourceHost(hostPortPair, waitUntilNotInUse, false);
        } finally {
            getLock().unlock();
        }
    }

    public void removeSourceHost(String hostPortPair, boolean waitUntilNotInUse, boolean isNowReplica) throws SQLException {
        getLock().lock();
        try {
            HostInfo host = getSourceHost(hostPortPair);
            if (host == null) {
                return;
            }
            if (isNowReplica) {
                this.replicaHosts.add(host);
                resetReadFromSourceWhenNoReplicas();
            }
            this.sourceHosts.remove(host);

            // The source connection may have been implicitly closed by a previous op., don't let it stop us.
            if (this.sourceConnection == null || this.sourceConnection.isClosed()) {
                this.sourceConnection = null;
                return;
            }

            if (waitUntilNotInUse) {
                this.sourceConnection.removeHostWhenNotInUse(hostPortPair);
            } else {
                this.sourceConnection.removeHost(hostPortPair);
            }

            // Close the connection if that was the last source.
            if (this.sourceHosts.isEmpty()) {
                this.sourceConnection.close();
                this.sourceConnection = null;

                // Default behavior, no need to check this.readFromSourceWhenNoReplicas.
                switchToReplicasConnectionIfNecessary();
            }
        } finally {
            getLock().unlock();
        }
    }

    public boolean isHostSource(String hostPortPair) {
        if (hostPortPair == null) {
            return false;
        }
        return this.sourceHosts.stream().anyMatch(hi -> hostPortPair.equalsIgnoreCase(hi.getHostPortPair()));
    }

    public JdbcConnection getReplicasConnection() {
        getLock().lock();
        try {
            return this.replicasConnection;
        } finally {
            getLock().unlock();
        }
    }

    public void addReplicaHost(String hostPortPair) throws SQLException {
        getLock().lock();
        try {
            if (isHostReplica(hostPortPair)) {
                return;
            }
            this.replicaHosts.add(getConnectionUrl().getReplicaHostOrSpawnIsolated(hostPortPair));
            resetReadFromSourceWhenNoReplicas();
            if (this.replicasConnection == null) {
                initializeReplicasConnection();
                switchToReplicasConnectionIfNecessary();
            } else {
                this.replicasConnection.addHost(hostPortPair);
            }
        } finally {
            getLock().unlock();
        }
    }

    public void removeReplica(String hostPortPair) throws SQLException {
        getLock().lock();
        try {
            removeReplica(hostPortPair, true);
        } finally {
            getLock().unlock();
        }
    }

    public void removeReplica(String hostPortPair, boolean closeGently) throws SQLException {
        getLock().lock();
        try {
            HostInfo host = getReplicaHost(hostPortPair);
            if (host == null) {
                return;
            }
            this.replicaHosts.remove(host);
            resetReadFromSourceWhenNoReplicas();

            if (this.replicasConnection == null || this.replicasConnection.isClosed()) {
                this.replicasConnection = null;
                return;
            }

            if (closeGently) {
                this.replicasConnection.removeHostWhenNotInUse(hostPortPair);
            } else {
                this.replicasConnection.removeHost(hostPortPair);
            }

            // Close the connection if that was the last replica.
            if (this.replicaHosts.isEmpty()) {
                this.replicasConnection.close();
                this.replicasConnection = null;

                // Default behavior, no need to check this.readFromSourceWhenNoReplicas.
                switchToSourceConnection();
                if (isSourceConnection()) {
                    this.currentConnection.setReadOnly(this.readOnly); // Maintain.
                }
            }
        } finally {
            getLock().unlock();
        }
    }

    public boolean isHostReplica(String hostPortPair) {
        if (hostPortPair == null) {
            return false;
        }
        return this.replicaHosts.stream().anyMatch(hi -> hostPortPair.equalsIgnoreCase(hi.getHostPortPair()));
    }

    public void setReadOnly(boolean readOnly) throws SQLException {
        getLock().lock();
        try {
            if (readOnly) {
                if (!isReplicasConnection() || this.currentConnection.isClosed()) {
                    boolean switched = true;
                    SQLException exceptionCaught = null;
                    try {
                        switched = switchToReplicasConnection();
                    } catch (SQLException e) {
                        switched = false;
                        exceptionCaught = e;
                    }
                    if (!switched && this.readFromSourceWhenNoReplicas && switchToSourceConnection()) {
                        exceptionCaught = null; // The connection is OK. Cancel the exception, if any.
                    }
                    if (exceptionCaught != null) {
                        throw exceptionCaught;
                    }
                }
            } else {
                if (!isSourceConnection() || this.currentConnection.isClosed()) {
                    boolean switched = true;
                    SQLException exceptionCaught = null;
                    try {
                        switched = switchToSourceConnection();
                    } catch (SQLException e) {
                        switched = false;
                        exceptionCaught = e;
                    }
                    if (!switched && switchToReplicasConnectionIfNecessary()) {
                        exceptionCaught = null; // The connection is OK. Cancel the exception, if any.
                    }
                    if (exceptionCaught != null) {
                        throw exceptionCaught;
                    }
                }
            }
            this.readOnly = readOnly;

            /*
             * Reset sources connection read-only state if 'readFromSourceWhenNoReplicas=true'. If there are no replicas then the sources connection will be
             * used
             * with read-only state in its place. Even if not, it must be reset from a possible previous read-only state.
             */
            if (this.readFromSourceWhenNoReplicas && isSourceConnection()) {
                this.currentConnection.setReadOnly(this.readOnly);
            }
        } finally {
            getLock().unlock();
        }
    }

    public boolean isReadOnly() throws SQLException {
        return !isSourceConnection() || this.readOnly;
    }

    private void resetReadFromSourceWhenNoReplicas() {
        this.readFromSourceWhenNoReplicas = this.replicaHosts.isEmpty() || this.readFromSourceWhenNoReplicasOriginal;
    }

    private HostInfo getSourceHost(String hostPortPair) {
        return this.sourceHosts.stream().filter(hi -> hostPortPair.equalsIgnoreCase(hi.getHostPortPair())).findFirst().orElse(null);
    }

    private HostInfo getReplicaHost(String hostPortPair) {
        return this.replicaHosts.stream().filter(hi -> hostPortPair.equalsIgnoreCase(hi.getHostPortPair())).findFirst().orElse(null);
    }

    private ReplicationConnectionUrl getConnectionUrl() {
        return (ReplicationConnectionUrl) this.connectionUrl;
    }

}
