/*

  *   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 org.sonews.util.Log;

 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;

 /**

  * A Thread task that processes OP_WRITE events for SocketChannels.

  * @author Christian Lins

  * @since sonews/0.5.0

  */

 class ChannelWriter extends AbstractDaemon

 {

 	private static ChannelWriter instance = new ChannelWriter();

 	/**

 	 * @return Returns the active ChannelWriter instance.

 	 */

 	public static ChannelWriter getInstance()

 	{

 		return instance;

 	}

 	private Selector selector = null;

 	protected ChannelWriter()

 	{

 	}

 	/**

 	 * @return Selector associated with this instance.

 	 */

 	public Selector getSelector()

 	{

 		return this.selector;

 	}

 	/**

 	 * Sets the selector that is used by this ChannelWriter.

 	 * @param selector

 	 */

 	public void setSelector(final Selector selector)

 	{

 		this.selector = selector;

 	}

 	/**

 	 * Run loop.

 	 */

 	@Override

 	public void run()

 	{

 		assert selector != null;

 		while (isRunning()) {

 			try {

 				SelectionKey selKey = null;

 				SocketChannel socketChannel = null;

 				NNTPConnection connection = null;

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

 				// processing. There is no need to synchronize the selector as we

 				// have only one thread per selector.

 				selector.select(); // The return value of select can be ignored

 				// Get list of selection keys with pending OP_WRITE events.

 				// The keySET is not thread-safe whereas the keys itself are.

 				Iterator it = selector.selectedKeys().iterator();

 				while (it.hasNext()) {

 					// We remove the first event from the set and store it for

 					// later processing.

 					selKey = (SelectionKey) it.next();

 					socketChannel = (SocketChannel) selKey.channel();

 					connection = Connections.getInstance().get(socketChannel);

 					it.remove();

 					if (connection != null) {

 						break;

 					} else {

 						selKey = null;

 					}

 				}

 				if (selKey != null) {

 					try {

 						// Process the selected key.

 						// As there is only one OP_WRITE key for a given channel, we need

 						// not to synchronize this processing to retain the order.

 						processSelectionKey(connection, socketChannel, selKey);

 					} catch (IOException ex) {

 						Log.get().warning("Error writing to channel: " + ex);

 						// Cancel write events for this channel

 						selKey.cancel();

 						connection.shutdownInput();

 						connection.shutdownOutput();

 					}

 				}

 				// Eventually wait for a register operation

 				synchronized (NNTPDaemon.RegisterGate) { /* do nothing */ }

 			} catch (CancelledKeyException ex) {

 				Log.get().info("ChannelWriter.run(): " + ex);

 			} catch (Exception ex) {

 				ex.printStackTrace();

 			}

 		} // while(isRunning())

 	}

 	private void processSelectionKey(final NNTPConnection connection,

 		final SocketChannel socketChannel, final SelectionKey selKey)

 		throws InterruptedException, IOException

 	{

 		assert connection != null;

 		assert socketChannel != null;

 		assert selKey != null;

 		assert selKey.isWritable();

 		// SocketChannel is ready for writing

 		if (selKey.isValid()) {

 			// Lock the socket channel

 			synchronized (socketChannel) {

 				// Get next output buffer

 				ByteBuffer buf = connection.getOutputBuffer();

 				if (buf == null) {

 					// Currently we have nothing to write, so we stop the writeable

 					// events until we have something to write to the socket channel

 					//selKey.cancel();

 					selKey.interestOps(0);

 					// Update activity timestamp to prevent too early disconnects

 					// on slow client connections

 					connection.setLastActivity(System.currentTimeMillis());

 					return;

 				}

 				while (buf != null) // There is data to be send

 				{

 					// Write buffer to socket channel; this method does not block

 					if (socketChannel.write(buf) <= 0) {

 						// Perhaps there is data to be written, but the SocketChannel's

 						// buffer is full, so we stop writing to until the next event.

 						break;

 					} else {

 						// Retrieve next buffer if available; method may return the same

 						// buffer instance if it still have some bytes remaining

 						buf = connection.getOutputBuffer();

 					}

 				}

 			}

 		} else {

 			Log.get().warning("Invalid OP_WRITE key: " + selKey);

 			if (socketChannel.socket().isClosed()) {

 				connection.shutdownInput();

 				connection.shutdownOutput();

 				socketChannel.close();

 				Log.get().info("Connection closed.");

 			}

 		}

 	}

 }