/*

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

      }

    }

  }

}