/*

         Copyright 2007 Alexey Akhunov

    Licensed 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 diy.middleware.client;

 import java.util.concurrent.BlockingQueue;

 import java.util.concurrent.CountDownLatch;

 import java.util.concurrent.TimeUnit;

 import diy.middleware.Frame;

 public class Session {

         private String sessionId;

         private BlockingQueue<Frame> inQueue;

         private BlockingQueue<Frame> outQueue;

         private volatile CountDownLatch latch;

         Session(String sessionId, BlockingQueue<Frame> inQueue, CountDownLatch initialLatch) {

                 this.sessionId = sessionId;

                 this.inQueue = inQueue;

                 this.latch = initialLatch;

         }

         public BlockingQueue<Frame> getInQueue() {

                 return inQueue;

         }

         public String getSessionId() {

                 return sessionId;

         }

         public void send(String message) throws InterruptedException {

                 outQueue.put(new Frame(sessionId, "M" + message));

         }

         /**

          * Subscribe to messages from the server that match

          * given pattern. This method is synchronized because

          * only one subscription per session is allowed

          * at this stage.

          * @param pattern Regular expression, defining the subscription

          * pattern. Messages matching this pattern will be delivered

          * to this session's inQueue.

          * @param timeout Amount of time to wait for the subscription

          * to complete. Successful subscription involves received

          * acknowledgment message from the server. If this ack

          * message does not come within specified timeout,

          * this method will return.

          * @param unit Time units of timeout parameter.

          * @return <code>true</code> if subscription was confirmed

          * by the server within given timeout, <code>false</code>

          * otherwise.

          * @throws InterruptedException 

          */

         public synchronized boolean receive(String pattern, long timeout, TimeUnit unit) throws InterruptedException {

                 // Create a new latch

                 latch = new CountDownLatch(1);

                 outQueue.put(new Frame(sessionId, "REC" + pattern));

                 return latch.await(timeout, unit);

         }

         public synchronized boolean stop(long timeout, TimeUnit unit) throws InterruptedException {

                 // Create a new latch

                 latch = new CountDownLatch(1);

                 outQueue.put(new Frame(sessionId, "STOP"));

                 return latch.await(timeout, unit);

         }

         void setOutQueue(BlockingQueue<Frame> outQueue) {

                 this.outQueue = outQueue;

         }

         CountDownLatch getLatch() {

                 return latch;

         }

 }