/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.activemq.ra;

import javax.jms.JMSException;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.ActiveMQSslConnectionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Abstract base class providing support for creating physical connections to an
 * ActiveMQ instance.
 *
 *
 */
public class ActiveMQConnectionSupport {

    private ActiveMQConnectionRequestInfo info = new ActiveMQConnectionRequestInfo();
    protected Logger log = LoggerFactory.getLogger(getClass());

    /**
     * Creates a factory for obtaining physical connections to an Active MQ
     * broker. The factory is configured with the given configuration
     * information.
     *
     * @param connectionRequestInfo
     *        the configuration request information
     * @param activationSpec
     * @return the connection factory
     * @throws java.lang.IllegalArgumentException
     *         if the server URL given in the configuration information is not a
     *         valid URL
     */
    protected ActiveMQConnectionFactory createConnectionFactory(ActiveMQConnectionRequestInfo connectionRequestInfo, MessageActivationSpec activationSpec) {
        // ActiveMQSslConnectionFactory defaults to TCP anyway
        ActiveMQConnectionFactory factory = new ActiveMQSslConnectionFactory();
        connectionRequestInfo.configure(factory, activationSpec);
        return factory;
    }

    /**
     * Creates a new physical connection to an Active MQ broker identified by
     * given connection request information.
     *
     * @param connectionRequestInfo
     *        the connection request information identifying the broker and any
     *        required connection parameters, e.g. username/password
     * @return the physical connection
     * @throws JMSException
     *         if the connection could not be established
     */
    public ActiveMQConnection makeConnection(ActiveMQConnectionRequestInfo connectionRequestInfo) throws JMSException {
        return makeConnection(connectionRequestInfo, createConnectionFactory(connectionRequestInfo, null));
    }

    /**
     * Creates a new physical connection to an Active MQ broker using a given
     * connection factory and credentials supplied in connection request
     * information.
     *
     * @param connectionRequestInfo
     *        the connection request information containing the credentials to
     *        use for the connection request
     * @return the physical connection
     * @throws JMSException
     *         if the connection could not be established
     */
    public ActiveMQConnection makeConnection(ActiveMQConnectionRequestInfo connectionRequestInfo, ActiveMQConnectionFactory connectionFactory)
        throws JMSException {
        String userName = connectionRequestInfo.getUserName();
        String password = connectionRequestInfo.getPassword();
        ActiveMQConnection physicalConnection = (ActiveMQConnection) connectionFactory.createConnection(userName, password);

        String clientId = connectionRequestInfo.getClientid();
        if (clientId != null && clientId.length() > 0) {
            physicalConnection.setClientID(clientId);
        }
        return physicalConnection;
    }

    /**
     * Gets the connection request information.
     *
     * @return the connection request information
     */
    public ActiveMQConnectionRequestInfo getInfo() {
        return info;
    }

    /**
     * Sets the connection request information as a whole.
     *
     * @param connectionRequestInfo
     *        the connection request information
     */
    protected void setInfo(ActiveMQConnectionRequestInfo connectionRequestInfo) {
        info = connectionRequestInfo;
        if (log.isDebugEnabled()) {
            log.debug(this + ", setting [info] to: " + info);
        }
    }

    protected boolean notEqual(Object o1, Object o2) {
        return (o1 == null ^ o2 == null) || (o1 != null && !o1.equals(o2));
    }

    protected String emptyToNull(String value) {
        if (value == null || value.length() == 0) {
            return null;
        } else {
            return value;
        }
    }

    protected String defaultValue(String value, String defaultValue) {
        if (value != null) {
            return value;
        }
        return defaultValue;
    }

    // ///////////////////////////////////////////////////////////////////////
    //
    // Java Bean getters and setters for this ResourceAdapter class.
    //
    // ///////////////////////////////////////////////////////////////////////

    /**
     * @return client id
     */
    public String getClientid() {
        return emptyToNull(info.getClientid());
    }

    /**
     * @param clientid
     */
    public void setClientid(String clientid) {
        if (log.isDebugEnabled()) {
            log.debug(this + ", setting [clientid] to: " + clientid);
        }
        info.setClientid(clientid);
    }

    /**
     * @return password
     */
    public String getPassword() {
        return emptyToNull(info.getPassword());
    }

    /**
     * @param password
     */
    public void setPassword(String password) {
        if (log.isDebugEnabled()) {
            log.debug(this + ", setting [password] property");
        }
        info.setPassword(password);
    }

    /**
     * @return server URL
     */
    public String getServerUrl() {
        return info.getServerUrl();
    }

    /**
     * @param url
     */
    public void setServerUrl(String url) {
        if (log.isDebugEnabled()) {
            log.debug(this + ", setting [serverUrl] to: " + url);
        }
        info.setServerUrl(url);
    }

    public void setTrustStore(String trustStore) {
        if (log.isDebugEnabled()) {
            log.debug(this + ", setting [trustStore] to: " + trustStore);
        }
        info.setTrustStore(trustStore);
    }

    public void setTrustStorePassword(String trustStorePassword) {
        if (log.isDebugEnabled()) {
            log.debug(this + ", setting [trustStorePassword] to: " + trustStorePassword);
        }
        info.setTrustStorePassword(trustStorePassword);
    }

    public void setKeyStore(String keyStore) {
        if (log.isDebugEnabled()) {
            log.debug(this + ", setting [keyStore] to: " + keyStore);
        }
        info.setKeyStore(keyStore);
    }

    public void setKeyStorePassword(String keyStorePassword) {
        if (log.isDebugEnabled()) {
            log.debug(this + ", setting [keyStorePassword] to: " + keyStorePassword);
        }
        info.setKeyStorePassword(keyStorePassword);
    }

    public void setKeyStoreKeyPassword(String keyStoreKeyPassword) {
        if (log.isDebugEnabled()) {
            log.debug(this + ", setting [keyStoreKeyPassword] to: " + keyStoreKeyPassword);
        }
        info.setKeyStoreKeyPassword(keyStoreKeyPassword);
    }

    /**
     * @return user name
     */
    public String getUserName() {
        return emptyToNull(info.getUserName());
    }

    /**
     * @param userid
     */
    public void setUserName(String userid) {
        if (log.isDebugEnabled()) {
            log.debug("setting [userName] to: " + userid);
        }
        info.setUserName(userid);
    }

    /**
     * @return durable topic prefetch
     */
    public Integer getDurableTopicPrefetch() {
        return info.getDurableTopicPrefetch();
    }

    /**
     * @param optimizeDurableTopicPrefetch
     */
    public void setOptimizeDurableTopicPrefetch(Integer optimizeDurableTopicPrefetch) {
        if (log.isDebugEnabled()) {
            log.debug("setting [optimizeDurableTopicPrefetch] to: " + optimizeDurableTopicPrefetch);
        }
        info.setOptimizeDurableTopicPrefetch(optimizeDurableTopicPrefetch);
    }

    /**
     * @return durable topic prefetch
     */
    public Integer getOptimizeDurableTopicPrefetch() {
        return info.getOptimizeDurableTopicPrefetch();
    }

    /**
     * @param durableTopicPrefetch
     */
    public void setDurableTopicPrefetch(Integer durableTopicPrefetch) {
        if (log.isDebugEnabled()) {
            log.debug("setting [durableTopicPrefetch] to: " + durableTopicPrefetch);
        }
        info.setDurableTopicPrefetch(durableTopicPrefetch);
    }

    /**
     * @return initial redelivery delay
     */
    public Long getInitialRedeliveryDelay() {
        return info.getInitialRedeliveryDelay();
    }

    /**
     * @param value
     */
    public void setInitialRedeliveryDelay(Long value) {
        if (log.isDebugEnabled()) {
            log.debug("setting [initialRedeliveryDelay] to: " + value);
        }
        info.setInitialRedeliveryDelay(value);
    }

    /**
     * @return initial redelivery delay
     */
    public Long getMaximumRedeliveryDelay() {
        return info.getMaximumRedeliveryDelay();
    }

    /**
     * @param value
     */
    public void setMaximumRedeliveryDelay(Long value) {
        if (log.isDebugEnabled()) {
            log.debug("setting [maximumRedeliveryDelay] to: " + value);
        }
        info.setMaximumRedeliveryDelay(value);
    }

    /**
     * @return input stream prefetch
     */
    @Deprecated
    public Integer getInputStreamPrefetch() {
        return 0;
    }

    /**
     * @return maximum redeliveries
     */
    public Integer getMaximumRedeliveries() {
        return info.getMaximumRedeliveries();
    }

    /**
     * @param value
     */
    public void setMaximumRedeliveries(Integer value) {
        if (log.isDebugEnabled()) {
            log.debug("setting [maximumRedeliveries] to: " + value);
        }
        info.setMaximumRedeliveries(value);
    }

    /**
     * @return queue browser prefetch
     */
    public Integer getQueueBrowserPrefetch() {
        return info.getQueueBrowserPrefetch();
    }

    /**
     * @param queueBrowserPrefetch
     */
    public void setQueueBrowserPrefetch(Integer queueBrowserPrefetch) {
        if (log.isDebugEnabled()) {
            log.debug("setting [queueBrowserPrefetch] to: " + queueBrowserPrefetch);
        }
        info.setQueueBrowserPrefetch(queueBrowserPrefetch);
    }

    /**
     * @return queue prefetch
     */
    public Integer getQueuePrefetch() {
        return info.getQueuePrefetch();
    }

    /**
     * @param queuePrefetch
     */
    public void setQueuePrefetch(Integer queuePrefetch) {
        if (log.isDebugEnabled()) {
            log.debug("setting [queuePrefetch] to: " + queuePrefetch);
        }
        info.setQueuePrefetch(queuePrefetch);
    }

    /**
     * @return redelivery backoff multiplier
     */
    public Double getRedeliveryBackOffMultiplier() {
        return info.getRedeliveryBackOffMultiplier();
    }

    /**
     * @param value
     */
    public void setRedeliveryBackOffMultiplier(Double value) {
        if (log.isDebugEnabled()) {
            log.debug("setting [redeliveryBackOffMultiplier] to: " + value);
        }
        info.setRedeliveryBackOffMultiplier(value);
    }

    /**
     * @return redelivery use exponential backoff
     */
    public Boolean getRedeliveryUseExponentialBackOff() {
        return info.getRedeliveryUseExponentialBackOff();
    }

    /**
     * @param value
     */
    public void setRedeliveryUseExponentialBackOff(Boolean value) {
        if (log.isDebugEnabled()) {
            log.debug("setting [redeliveryUseExponentialBackOff] to: " + value);
        }
        info.setRedeliveryUseExponentialBackOff(value);
    }

    /**
     * @return topic prefetch
     */
    public Integer getTopicPrefetch() {
        return info.getTopicPrefetch();
    }

    /**
     * @param topicPrefetch
     */
    public void setTopicPrefetch(Integer topicPrefetch) {
        if (log.isDebugEnabled()) {
            log.debug("setting [topicPrefetch] to: " + topicPrefetch);
        }
        info.setTopicPrefetch(topicPrefetch);
    }

    /**
     * @param i
     */
    public void setAllPrefetchValues(Integer i) {
        info.setAllPrefetchValues(i);
    }

    /**
     * @return use inbound session enabled
     */
    public boolean isUseInboundSessionEnabled() {
        return info.isUseInboundSessionEnabled();
    }

    /**
     * @return use inbound session
     */
    public Boolean getUseInboundSession() {
        return info.getUseInboundSession();
    }

    /**
     * @param useInboundSession
     */
    public void setUseInboundSession(Boolean useInboundSession) {
        if (log.isDebugEnabled()) {
            log.debug("setting [useInboundSession] to: " + useInboundSession);
        }
        info.setUseInboundSession(useInboundSession);
    }

    public boolean isUseSessionArgs() {
        return info.isUseSessionArgs();
    }

    public Boolean getUseSessionArgs() {
        return info.getUseSessionArgs();
    }

    /**
     * if true, calls to managed connection factory.connection.createSession
     * will respect the passed in args. When false (default) the args are
     * ignored b/c the container will do transaction demarcation via xa or local
     * transaction rar contracts. This option is useful when a managed
     * connection is used in plain jms mode and a jms transacted session session
     * is required.
     *
     * @param useSessionArgs
     */
    public void setUseSessionArgs(Boolean useSessionArgs) {
        if (log.isDebugEnabled()) {
            log.debug(this + ", setting [useSessionArgs] to: " + useSessionArgs);
        }
        info.setUseSessionArgs(useSessionArgs);
    }
}
