/*

 *   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.");

			}

		}

	}

}