/*
   Copyright (C) 2007 Dirk Huenniger
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
   */
  package org.indi.reactor;
  
  import java.io.IOException;
  import java.nio.channels.ClosedChannelException;
  import java.nio.channels.SelectionKey;
  import java.nio.channels.Selector;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  import java.util.PriorityQueue;
  import java.util.Queue;
  import java.util.Set;
  
  /**
   * A simple implementation of the reactor pattern (similar to eventloop /event
   * driven system / event demultiplexer) around the java newIO system. Just
   * register event handlers with the reactor and call handle events frequntly.
   * The callbackmethods of the event handlers will be called as soon as the
   * corresponding events have been detected. See
   * {@link http://www.cs.wustl.edu/~schmidt/PDF/reactor-siemens.pdf} for a basic
   * introduction to the concept.
   * 
   * @author Dirk Hünniger
   */
  public class Reactor {
      /**
       * The Selector used by the Reactor to listen for IO events
       */
      protected Selector selector;
      /**
       * List of handlers for 1ueue events
       */
      private final List<QueueHandler> queueHandlers;
      /**
       * Priority queue of handlers for timer events
       */
      private final Queue<TimerHandler> timerQueue;
  
      /**
       * Class constructor
       * 
       * @throws IOException
       */
      public Reactor() throws IOException {
  	this.selector = Selector.open();
  	this.queueHandlers = new ArrayList<QueueHandler>();
  	this.timerQueue = new PriorityQueue<TimerHandler>();
      }
  
      /**
       * Registers a new IO-EventHandler with the reactor
       * 
       * @param h
       *                EventHandler to be installed
       * @param ops
       *                Bitmask describing the IO Events to listen to.
       */
      public void register(EventHandler h, int ops) {
  	try {
  	    h.channel().register(this.selector, ops, h);
  	} catch (ClosedChannelException e) {
  	    unregister(h);
  	} catch (java.nio.channels.CancelledKeyException e) {
  	    unregister(h);
  	}
      }
  
      /**
       * Register a new Queue-EventHandler with the reactor
       * 
       * @param h
       *                QueueHandler to be regsitered
       */
      public void register(QueueHandler h) {
  	this.queueHandlers.add(h);
      }
  
      /**
       * Register a new Timer-EventHanlder with the reactor
       * 
       * @param h
      *                the TimeHandler to be registered
      */
     public void register(TimerHandler h) {
 	this.timerQueue.add(h);
     }
 
     /**
      * Unregister a IO-EventHandler
      * 
      * @param h
      */
     public void unregister(EventHandler h) {
 	Set keys = this.selector.keys();
 	Iterator it = keys.iterator();
 	while (it.hasNext()) {
 	    SelectionKey k = (SelectionKey) (it.next());
 	    if (k.attachment() == h) {
 		k.cancel();
 	    }
 	}
 	h.onClose();
     }
 
     /**
      * Call the methods frequently. In this methods all events are detected
      * and dispached to the approriate EventHandlers
      * 
      * @param timeout
      *                the maximum time to wait for events in miliseconds
      * @return Number of IO events handled
      * @throws IOException
      */
     public int handleEvents(long timeout) throws IOException {
 	long selectTimeout = timeout;
 	long now = new Date().getTime();
 	TimerHandler nextTimer = this.timerQueue.peek();
 	if (!(nextTimer == null)) {
 	    long next = nextTimer.getExpirationDate().getTime();
 	    if ((next - now) < selectTimeout) {
 		selectTimeout = next - now;
 		if (selectTimeout <= 0) {
 		    selectTimeout = 1;
 		}
 	    }
 	}
 	this.selector.select(selectTimeout);
 
 	now = new Date().getTime();
 	while (null != (nextTimer = this.timerQueue.peek())) {
 	    long next = nextTimer.getExpirationDate().getTime();
 	    if ((next - now) < 0) {
 		nextTimer = this.timerQueue.poll();
 		nextTimer.onTimer();
 	    } else {
 		break;
 	    }
 	}
 	Set selected = this.selector.selectedKeys();
 	Iterator it = selected.iterator();
 	int count = 0;
 	while (it.hasNext()) {
 	    SelectionKey k = (SelectionKey) (it.next());
 	    EventHandler h = (EventHandler) k.attachment();
 	    int ops = k.readyOps();
 	    if ((ops & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE) {
 		h.onWrite();
 		count++;
 	    }
 	    if ((ops & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
 		h.onRead();
 		count++;
 	    }
 	    if ((ops & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
 		h.onAccept();
 		count++;
 	    }
 	    if ((ops & SelectionKey.OP_CONNECT) == SelectionKey.OP_CONNECT) {
 		h.onConnect();
 		count++;
 	    }
 	}
 	for (QueueHandler h : this.queueHandlers) {
 	    Queue<Object> q = h.getQueue();
 	    Object o = q.poll();
 	    if (o != null) {
 		h.onRead(o);
 	    }
 	}
 	selected.clear();
 	return count;
     }
 
     void close() {
     };
 }