/*

 *   SONEWS News Server

 *   see AUTHORS for the list of contributors

 *

 *   This program is free software: you can redistribute it and/or modify

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation, either version 3 of the License, or

 *   (at your option) any later version.

 *

 *   This program 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 General Public License for more details.

 *

 *   You should have received a copy of the GNU General Public License

 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

package org.sonews.daemon;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.channels.CancelledKeyException;

import java.nio.channels.SelectionKey;

import java.nio.channels.Selector;

import java.nio.channels.SocketChannel;

import java.util.Iterator;

import java.util.Set;

import java.util.logging.Level;

import org.sonews.util.Log;

/**

 * A Thread task listening for OP_READ events from SocketChannels.

 * @author Christian Lins

 * @since sonews/0.5.0

 */

class ChannelReader extends AbstractDaemon

{

	private static ChannelReader instance = new ChannelReader();

	/**

	 * @return Active ChannelReader instance.

	 */

	public static ChannelReader getInstance()

	{

		return instance;

	}

	private Selector selector = null;

	protected ChannelReader()

	{

	}

	/**

	 * Sets the selector which is used by this reader to determine the channel

	 * to read from.

	 * @param selector

	 */

	public void setSelector(final Selector selector)

	{

		this.selector = selector;

	}

	/**

	 * Run loop. Blocks until some data is available in a channel.

	 */

	@Override

	public void run()

	{

		assert selector != null;

		while (isRunning()) {

			try {

				// select() blocks until some SelectableChannels are ready for

				// processing. There is no need to lock the selector as we have only

				// one thread per selector.

				selector.select();

				// Get list of selection keys with pending events.

				// Note: the selected key set is not thread-safe

				SocketChannel channel = null;

				NNTPConnection conn = null;

				final Set<SelectionKey> selKeys = selector.selectedKeys();

				SelectionKey selKey = null;

				synchronized (selKeys) {

					Iterator it = selKeys.iterator();

					// Process the first pending event

					while (it.hasNext()) {

						selKey = (SelectionKey) it.next();

						channel = (SocketChannel) selKey.channel();

						conn = Connections.getInstance().get(channel);

						// Because we cannot lock the selKey as that would cause a deadlock

						// we lock the connection. To preserve the order of the received

						// byte blocks a selection key for a connection that has pending

						// read events is skipped.

						if (conn == null || conn.tryReadLock()) {

							// Remove from set to indicate that it's being processed

							it.remove();

							if (conn != null) {

								break; // End while loop

							}

						} else {

							selKey = null;

							channel = null;

							conn = null;

						}

					}

				}

				// Do not lock the selKeys while processing because this causes

				// a deadlock in sun.nio.ch.SelectorImpl.lockAndDoSelect()

				if (selKey != null && channel != null && conn != null) {

					processSelectionKey(conn, channel, selKey);

					conn.unlockReadLock();

				}

			} catch (CancelledKeyException ex) {

				Log.get().warning("ChannelReader.run(): " + ex);

				Log.get().log(Level.INFO, "", ex);

			} catch (Exception ex) {

				ex.printStackTrace();

			}

			// Eventually wait for a register operation

			synchronized (NNTPDaemon.RegisterGate) {

				// Do nothing; FindBugs may warn about an empty synchronized

				// statement, but we cannot use a wait()/notify() mechanism here.

				// If we used something like RegisterGate.wait() we block here

				// until the NNTPDaemon calls notify(). But the daemon only

				// calls notify() if itself is NOT blocked in the listening socket.

			}

		} // while(isRunning())

	}

	private void processSelectionKey(final NNTPConnection connection,

		final SocketChannel socketChannel, final SelectionKey selKey)

		throws InterruptedException, IOException

	{

		assert selKey != null;

		assert selKey.isReadable();

		// Some bytes are available for reading

		if (selKey.isValid()) {

			// Lock the channel

			//synchronized(socketChannel)

			{

				// Read the data into the appropriate buffer

				ByteBuffer buf = connection.getInputBuffer();

				int read = -1;

				try {

					read = socketChannel.read(buf);

				} catch (IOException ex) {

					// The connection was probably closed by the remote host

					// in a non-clean fashion

					Log.get().info("ChannelReader.processSelectionKey(): " + ex);

				} catch (Exception ex) {

					Log.get().warning("ChannelReader.processSelectionKey(): " + ex);

				}

				if (read == -1) // End of stream

				{

					selKey.cancel();

				} else if (read > 0) // If some data was read

				{

					ConnectionWorker.addChannel(socketChannel);

				}

			}

		} else {

			// Should not happen

			Log.get().severe("Should not happen: " + selKey.toString());

		}

	}

}