/**
 * 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 org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.Session;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.resource.ResourceException;
import javax.resource.spi.ConnectionEvent;

import static org.junit.Assert.*;

public class ManagedConnectionTest {

    private static final String DEFAULT_HOST = "vm://localhost?broker.persistent=false";

    private ConnectionManagerAdapter connectionManager = new ConnectionManagerAdapter();
    private ActiveMQManagedConnectionFactory managedConnectionFactory;
    private ConnectionFactory connectionFactory;
    private ManagedConnectionProxy connection;
    private ActiveMQManagedConnection managedConnection;

    @Before
    public void setUp() throws Exception {

        managedConnectionFactory = new ActiveMQManagedConnectionFactory();
        managedConnectionFactory.setServerUrl(DEFAULT_HOST);
        managedConnectionFactory.setUserName(ActiveMQConnectionFactory.DEFAULT_USER);
        managedConnectionFactory.setPassword(ActiveMQConnectionFactory.DEFAULT_PASSWORD);

        connectionFactory = (ConnectionFactory)managedConnectionFactory.createConnectionFactory(connectionManager);
        connection = (ManagedConnectionProxy)connectionFactory.createConnection();
        managedConnection = connection.getManagedConnection();

    }

    @After
    public void destroyManagedConnection() throws Exception {
        if (managedConnection != null) {
            managedConnection.destroy();
        }
    }

    @Test(timeout = 60000)
    public void testConnectionCloseEvent() throws ResourceException, JMSException {

        final boolean test[] = new boolean[] {
            false
        };
        connectionManager.addConnectionEventListener(new ConnectionEventListenerAdapter() {
            @Override
            public void connectionClosed(ConnectionEvent arg0) {
                test[0] = true;
            }
        });
        connection.close();
        assertTrue(test[0]);
    }

    @Test(timeout = 60000)
    public void testLocalTransactionCommittedEvent() throws ResourceException, JMSException {

        final boolean test[] = new boolean[] {
            false
        };
        connectionManager.addConnectionEventListener(new ConnectionEventListenerAdapter() {
            @Override
            public void localTransactionCommitted(ConnectionEvent arg0) {
                test[0] = true;
            }
        });

        managedConnection.getLocalTransaction().begin();
        Session session = connection.createSession(true, 0);

        doWork(session);
        session.commit();

        assertTrue(test[0]);

    }

    @Test(timeout = 60000)
    public void testLocalTransactionRollbackEvent() throws ResourceException, JMSException {

        final boolean test[] = new boolean[] {
            false
        };
        connectionManager.addConnectionEventListener(new ConnectionEventListenerAdapter() {
            @Override
            public void localTransactionRolledback(ConnectionEvent arg0) {
                test[0] = true;
            }
        });
        managedConnection.getLocalTransaction().begin();
        Session session = connection.createSession(true, 0);
        doWork(session);
        session.rollback();

        assertTrue(test[0]);
    }

    @Test(timeout = 60000)
    public void testLocalTransactionStartedEvent() throws ResourceException, JMSException {

        final boolean test[] = new boolean[] {
            false
        };
        connectionManager.addConnectionEventListener(new ConnectionEventListenerAdapter() {
            @Override
            public void localTransactionStarted(ConnectionEvent arg0) {
                test[0] = true;
            }
        });

        // Begin the transaction... that should kick off the event.
        managedConnection.getLocalTransaction().begin();
        Session session = connection.createSession(true, 0);
        doWork(session);

        assertTrue(test[0]);
    }

    /**
     * A managed connection that has been clean up should throw exceptions when
     * it used.
     */
    @Test(timeout = 60000)
    public void testCleanup() throws ResourceException, JMSException {

        // Do some work and close it...
        Session session = connection.createSession(true, 0);
        doWork(session);
        connection.close();
        try {
            // This should throw exception
            doWork(session);
            fail("Using a session after the connection is closed should throw exception.");
        } catch (JMSException e) {
        }
    }

    public void testSetClientIdAfterCleanup() throws Exception {

        connection.setClientID("test");
        try {
            connection.setClientID("test");
            fail("Should have received JMSException");
        } catch (JMSException e) {
        }

        ActiveMQConnection physicalConnection = (ActiveMQConnection) managedConnection.getPhysicalConnection();
        try {
            physicalConnection.setClientID("testTwo");
            fail("Should have received JMSException");
        } catch (JMSException e) {
        }

        // close the proxy
        connection.close();

        // can set the id on the physical connection again after cleanup
        physicalConnection.setClientID("test3");

        try {
            physicalConnection.setClientID("test4");
            fail("Should have received JMSException");
        } catch (JMSException e) {
        }
    }

    @Test(timeout = 60000)
    public void testSessionCloseIndependance() throws ResourceException, JMSException {

        Session session1 = connection.createSession(true, 0);
        Session session2 = connection.createSession(true, 0);
        assertTrue(session1 != session2);

        doWork(session1);
        session1.close();
        try {
            // This should throw exception
            doWork(session1);
            fail("Using a session after the connection is closed should throw exception.");
        } catch (JMSException e) {
        }

        // Make sure that closing session 1 does not close session 2
        doWork(session2);
        session2.close();
        try {
            // This should throw exception
            doWork(session2);
            fail("Using a session after the connection is closed should throw exception.");
        } catch (JMSException e) {
        }
    }

    /**
     * Does some work so that we can test commit/rollback etc.
     *
     * @throws JMSException
     */
    public void doWork(Session session) throws JMSException {
        Queue t = session.createQueue("TEST");
        MessageProducer producer = session.createProducer(t);
        producer.send(session.createTextMessage("test message."));
    }

    @Test(timeout = 60000)
    public void testImplementsQueueAndTopicConnection() throws Exception {
        QueueConnection qc = ((QueueConnectionFactory)connectionFactory).createQueueConnection();
        assertNotNull(qc);
        TopicConnection tc = ((TopicConnectionFactory)connectionFactory).createTopicConnection();
        assertNotNull(tc);
    }

    @Test(timeout = 60000)
    public void testSelfEquality() {
        assertEquality(managedConnection, managedConnection);
    }

    @Test(timeout = 60000)
    public void testSamePropertiesButNotEqual() throws Exception {
        ManagedConnectionProxy newConnection = (ManagedConnectionProxy)connectionFactory.createConnection();
        assertNonEquality(managedConnection, newConnection.getManagedConnection());
    }

    private void assertEquality(ActiveMQManagedConnection leftCon, ActiveMQManagedConnection rightCon) {
        assertTrue("ActiveMQManagedConnection are not equal", leftCon.equals(rightCon));
        assertTrue("ActiveMQManagedConnection are not equal", rightCon.equals(leftCon));
        assertTrue("HashCodes are not equal", leftCon.hashCode() == rightCon.hashCode());
    }

    private void assertNonEquality(ActiveMQManagedConnection leftCon, ActiveMQManagedConnection rightCon) {
        assertFalse("ActiveMQManagedConnection are equal", leftCon.equals(rightCon));
        assertFalse("ActiveMQManagedConnection are equal", rightCon.equals(leftCon));
        assertFalse("HashCodes are equal", leftCon.hashCode() == rightCon.hashCode());
    }
}
