/*
 *
 * 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.qpid.test.unit.client.temporaryqueue;

import javax.jms.Connection;
import javax.jms.ExceptionListener;
import javax.jms.JMSException;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TemporaryQueue;
import javax.jms.TextMessage;
import junit.framework.Assert;

import org.apache.qpid.test.utils.QpidBrokerTestCase;
import org.apache.qpid.client.AMQQueue;
import org.apache.qpid.jms.ConnectionListener;

import java.util.ArrayList;
import java.util.List;
import java.util.LinkedList;

public class TemporaryQueueTest extends QpidBrokerTestCase implements ExceptionListener
{
    private List<Exception> _exceptions = new ArrayList<Exception>();

    protected void setUp() throws Exception
    {
        super.setUp();
    }

    protected void tearDown() throws Exception
    {
       super.tearDown();
    }

    protected Connection createConnection() throws Exception
    {
        return  getConnection("guest", "guest");
    }

    public void testTemporaryQueue() throws Exception
    {
        Connection conn = createConnection();
        Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
        TemporaryQueue queue = session.createTemporaryQueue();
        assertNotNull(queue);
        MessageProducer producer = session.createProducer(queue);
        MessageConsumer consumer = session.createConsumer(queue);
        conn.start();
        producer.send(session.createTextMessage("hello"));
        TextMessage tm = (TextMessage) consumer.receive(2000);
        assertNotNull(tm);
        assertEquals("hello", tm.getText());

        try
        {
            queue.delete();
            fail("Expected JMSException : should not be able to delete while there are active consumers");
        }
        catch (JMSException je)
        {
            ; //pass
        }

        consumer.close();

        try
        {
            queue.delete();
        }
        catch (JMSException je)
        {
            fail("Unexpected Exception: " + je.getMessage());
        }

        conn.close();
    }

    public void tUniqueness() throws Exception
    {
        int numProcs = Runtime.getRuntime().availableProcessors();
        final int threadsProc = 5;

        runUniqueness(1, 10);
        runUniqueness(numProcs * threadsProc, 10);
        runUniqueness(numProcs * threadsProc, 100);
        runUniqueness(numProcs * threadsProc, 500);
    }

    void runUniqueness(int makers, int queues) throws Exception
    {
        Connection connection = createConnection();

        Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);

        List<TempQueueMaker> tqList = new LinkedList<TempQueueMaker>();

        //Create Makers
        for (int m = 0; m < makers; m++)
        {
            tqList.add(new TempQueueMaker(session, queues));
        }


        List<Thread> threadList = new LinkedList<Thread>();

        //Create Makers
        for (TempQueueMaker maker : tqList)
        {
            threadList.add(new Thread(maker));
        }

        //Start threads
        for (Thread thread : threadList)
        {
            thread.start();
        }

        // Join Threads
        for (Thread thread : threadList)
        {
            try
            {
                thread.join();
            }
            catch (InterruptedException e)
            {
                fail("Couldn't correctly join threads");
            }
        }


        List<AMQQueue> list = new LinkedList<AMQQueue>();

        // Test values
        for (TempQueueMaker maker : tqList)
        {
            check(maker, list);
        }

        Assert.assertEquals("Not enough queues made.", makers * queues, list.size());

        connection.close();
    }

    private void check(TempQueueMaker tq, List<AMQQueue> list)
    {
        for (AMQQueue q : tq.getList())
        {
            if (list.contains(q))
            {
                fail(q + " already exists.");
            }
            else
            {
                list.add(q);
            }
        }
    }


    class TempQueueMaker implements Runnable
    {
        List<AMQQueue> _queues;
        Session _session;
        private int _count;


        TempQueueMaker(Session session, int queues) throws JMSException
        {
            _queues = new LinkedList<AMQQueue>();

            _count = queues;

            _session = session;
        }

        public void run()
        {
            int i = 0;
            try
            {
                for (; i < _count; i++)
                {
                    _queues.add((AMQQueue) _session.createTemporaryQueue());
                }
            }
            catch (JMSException jmse)
            {
                //stop
            }
        }

        List<AMQQueue> getList()
        {
            return _queues;
        }
    }

    public void testQPID1217() throws Exception
    {
        Connection conA = getConnection();
        conA.setExceptionListener(this);
        Session sessA = conA.createSession(false, Session.AUTO_ACKNOWLEDGE);
        TemporaryQueue temp = sessA.createTemporaryQueue();
        
        MessageProducer prod = sessA.createProducer(temp);
        prod.send(sessA.createTextMessage("hi"));

        Thread.sleep(500);
        assertTrue("Exception received", _exceptions.isEmpty());
        
        Connection conB = getConnection();
        Session sessB = conB.createSession(false, Session.AUTO_ACKNOWLEDGE);
        
        JMSException ex = null;
        try
        {
            MessageConsumer consB = sessB.createConsumer(temp);
        } 
        catch (JMSException e)
        {
            ex = e; 
        }
        assertNotNull(ex);
    }
    
    public static junit.framework.Test suite()
    {
        return new junit.framework.TestSuite(TemporaryQueueTest.class);
    }

    public void onException(JMSException arg0)
    {
        _exceptions.add(arg0);
    }

}