package com.bsb.btm;


import org.apache.log4j.Logger;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.jms.support.destination.DestinationResolver;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.JMSException;
import javax.jms.Session;

/**
 * @author Stephane Nicoll
 */
@Component
class MessageSenderImpl implements MessageSender, InitializingBean {

    private final Logger logger = Logger.getLogger(MessageSender.class);

    private JmsTemplate jmsTemplateTopic;
    private JmsTemplate jmsTemplateQueue;
    private int deliveryMode = DeliveryMode.PERSISTENT;


    @Transactional
    public void sendMessage(final String msg, String destination, boolean pubsub) {
        if (logger.isDebugEnabled()) {
            logger.debug("Sending message [" + msg + "] to [" + destination + "]");
        }
        if (pubsub) {
            jmsTemplateTopic.send(destination, new MessageCreator() {
                public javax.jms.Message createMessage(Session session) throws JMSException {
                    final javax.jms.TextMessage jmsMessage = session.createTextMessage(msg);

                    // QoS capabilities of the template not need other than this one
                    jmsMessage.setJMSDeliveryMode(deliveryMode);
                    return jmsMessage;
                }
            });

        } else {
        }
        jmsTemplateQueue.send(destination, new MessageCreator() {
            public javax.jms.Message createMessage(Session session) throws JMSException {
                final javax.jms.TextMessage jmsMessage = session.createTextMessage(msg);

                // QoS capabilities of the template not need other than this one
                jmsMessage.setJMSDeliveryMode(deliveryMode);
                return jmsMessage;
            }
        });
    }


    private ConnectionFactory connectionFactory;
    private DestinationResolver destinationResolver;

    /**
     * Sets the connection factory used to create a JMS template. The connection
     * factory is used only if no JMS template has been set (for queues and topics).
     *
     * @param connectionFactory the JMS connection factory
     */
    @Autowired
    public void setConnectionFactory(ConnectionFactory connectionFactory) {
        this.connectionFactory = connectionFactory;
    }

    /**
     * Sets the destination resolver used to resolve JMS destination. The resolver
     * is used only if no JMS template has been set (for queues and topics).
     *
     * @param destinationResolver the destination resolver
     */
    @Autowired
    public void setDestinationResolver(DestinationResolver destinationResolver) {
        this.destinationResolver = destinationResolver;
    }

    /**
     * Set whether message delivery should be persistent or non-persistent,
     * specified as boolean value ("true" or "false"). This will set the delivery
     * mode accordingly, to either "PERSISTENT" (1) or "NON_PERSISTENT" (2).
     * <p>Default it "true" aka delivery mode "PERSISTENT".
     *
     * @param deliveryPersistent <tt>true</tt> for a persistent delivery
     * @see javax.jms.DeliveryMode#PERSISTENT
     * @see javax.jms.DeliveryMode#NON_PERSISTENT
     */
    public void setDeliveryPersistent(boolean deliveryPersistent) {
        this.deliveryMode = (deliveryPersistent ? DeliveryMode.PERSISTENT : DeliveryMode.NON_PERSISTENT);
    }


    public void afterPropertiesSet() throws Exception {
        Assert.notNull(connectionFactory, "The connection factory is mandatory");
        Assert.notNull(destinationResolver, "The destination resolver is mandatory");

        this.jmsTemplateQueue = new JmsTemplate(connectionFactory);
        this.jmsTemplateQueue.setDestinationResolver(destinationResolver);
        this.jmsTemplateQueue.setPubSubDomain(false);

        this.jmsTemplateTopic = new JmsTemplate(connectionFactory);
        this.jmsTemplateTopic.setDestinationResolver(destinationResolver);
        this.jmsTemplateTopic.setPubSubDomain(true);
    }
}