/***********************************************************************************************************************
 * Copyright (C) 2010-2014 by the Stratosphere project (http://stratosphere.eu)
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 **********************************************************************************************************************/

package eu.stratosphere.runtime.io.network.netty;

import eu.stratosphere.runtime.io.network.Envelope;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.util.ArrayDeque;
import java.util.concurrent.atomic.AtomicInteger;

public class OutboundConnectionQueue extends ChannelInboundHandlerAdapter implements ChannelFutureListener {

	private static final Log LOG = LogFactory.getLog(OutboundConnectionQueue.class);

	private final Channel channel;

	private final ArrayDeque<Envelope> queuedEnvelopes = new ArrayDeque<Envelope>();

	private final AtomicInteger numQueued = new AtomicInteger(0);

	public OutboundConnectionQueue(Channel channel) {
		this.channel = channel;

		channel.pipeline().addFirst(this);
	}

	/**
	 * Enqueues an envelope so be sent later.
	 * <p/>
	 * This method is always invoked by the task thread that wants the envelope sent.
	 *
	 * @param env The envelope to be sent.
	 */
	public void enqueue(Envelope env) {
		// the user event trigger ensure thread-safe hand-over of the envelope
		this.channel.pipeline().fireUserEventTriggered(env);
	}

	@Override
	public void userEventTriggered(ChannelHandlerContext ctx, Object envelopeToEnqueue) throws Exception {
		boolean triggerWrite = this.queuedEnvelopes.isEmpty();

		this.queuedEnvelopes.addLast((Envelope) envelopeToEnqueue);
		this.numQueued.incrementAndGet();

		if (triggerWrite) {
			writeAndFlushNextEnvelopeIfPossible();
		}
	}

	@Override
	public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
		writeAndFlushNextEnvelopeIfPossible();
	}

	@Override
	public void operationComplete(ChannelFuture future) throws Exception {
		if (future.isSuccess()) {
			writeAndFlushNextEnvelopeIfPossible();
		}
		else if (future.cause() != null) {
			exceptionOccurred(future.cause());
		}
		else {
			exceptionOccurred(new Exception("Envelope send aborted."));
		}
	}

	public int getNumQueuedEnvelopes() {
		return this.numQueued.intValue();
	}

	public Channel getChannel() {
		return this.channel;
	}

	private void writeAndFlushNextEnvelopeIfPossible() {
		if (this.channel.isWritable() && !this.queuedEnvelopes.isEmpty()) {
			Envelope nextEnvelope = this.queuedEnvelopes.pollFirst();
			this.numQueued.decrementAndGet();

			this.channel.writeAndFlush(nextEnvelope).addListener(this);
		}
	}

	private void exceptionOccurred(Throwable t) throws Exception {
		LOG.error(String.format("An exception occurred in Channel %s: %s", this.channel, t.getMessage()));
		throw new Exception(t);
	}
}