/***********************************************************************************************************************
 * 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.gates;

import eu.stratosphere.core.io.IOReadableWritable;
import eu.stratosphere.nephele.deployment.ChannelDeploymentDescriptor;
import eu.stratosphere.nephele.deployment.GateDeploymentDescriptor;
import eu.stratosphere.nephele.event.task.AbstractEvent;
import eu.stratosphere.runtime.io.Buffer;
import eu.stratosphere.runtime.io.channels.ChannelID;
import eu.stratosphere.runtime.io.channels.OutputChannel;
import eu.stratosphere.nephele.jobgraph.JobID;

import java.io.IOException;

public class OutputGate extends Gate<IOReadableWritable> {

	private OutputChannel[] channels;

	private boolean closed;
	
	/**
	 * Constructs a new output gate.
	 *
	 * @param jobId the ID of the job this input gate belongs to
	 * @param gateId the ID of the gate
	 * @param index the index assigned to this output gate at the Environment object
	 */
	public OutputGate(JobID jobId, GateID gateId, int index) {
		super(jobId, gateId, index);
	}

	// -----------------------------------------------------------------------------------------------------------------
	//                                             Data processing
	// -----------------------------------------------------------------------------------------------------------------

	public void sendBuffer(Buffer buffer, int targetChannel) throws IOException, InterruptedException {
		this.channels[targetChannel].sendBuffer(buffer);
	}

	public void sendEvent(AbstractEvent event, int targetChannel) throws IOException, InterruptedException {
		this.channels[targetChannel].sendEvent(event);
	}

	public void sendBufferAndEvent(Buffer buffer, AbstractEvent event, int targetChannel) throws IOException, InterruptedException {
		this.channels[targetChannel].sendBufferAndEvent(buffer, event);
	}

	public void broadcastBuffer(Buffer buffer) throws IOException, InterruptedException {
		for (int i = 1; i < this.channels.length; i++) {
			channels[i].sendBuffer(buffer.duplicate());
		}
		channels[0].sendBuffer(buffer);
	}

	public void broadcastEvent(AbstractEvent event) throws IOException, InterruptedException {
		for (OutputChannel channel : this.channels) {
			channel.sendEvent(event);
		}
	}

	// -----------------------------------------------------------------------------------------------------------------
	//                                              Channels
	// -----------------------------------------------------------------------------------------------------------------

	public void initializeChannels(GateDeploymentDescriptor descriptor) {
		int numChannels = descriptor.getNumberOfChannelDescriptors();
		this.channels = new OutputChannel[numChannels];

		setChannelType(descriptor.getChannelType());

		for (int i = 0; i < numChannels; i++) {
			ChannelDeploymentDescriptor channelDescriptor = descriptor.getChannelDescriptor(i);

			ChannelID id = channelDescriptor.getOutputChannelID();
			ChannelID connectedId = channelDescriptor.getInputChannelID();

			this.channels[i] = new OutputChannel(this, i, id, connectedId, getChannelType());
		}
	}

	public OutputChannel[] channels() {
		return this.channels;
	}

	public OutputChannel getChannel(int index) {
		return (index < this.channels.length) ? this.channels[index] : null;
	}

	public int getNumChannels() {
		return this.channels.length;
	}

	// -----------------------------------------------------------------------------------------------------------------
	//                                              Shutdown
	// -----------------------------------------------------------------------------------------------------------------

	public void requestClose() throws IOException, InterruptedException {
		for (OutputChannel channel : this.channels) {
			channel.requestClose();
		}
	}

	@Override
	public boolean isClosed() {
		if (this.closed) {
			return true;
		}
		
		for (OutputChannel channel : this.channels) {
			if (!channel.isClosed()) {
				return false;
			}
		}
		
		this.closed = true;
		return true;
	}
	
	public void waitForGateToBeClosed() throws InterruptedException {
		if (this.closed) {
			return;
		}
		
		for (OutputChannel channel : this.channels) {
			channel.waitForChannelToBeClosed();
		}
		
		this.closed = true;
	}

	// -----------------------------------------------------------------------------------------------------------------

	@Override
	public boolean isInputGate() {
		return false;
	}

	@Override
	public String toString() {
		return "Output " + super.toString();
	}

	@Override
	public void publishEvent(AbstractEvent event) throws IOException, InterruptedException {
		// replaced by broadcastEvent(AbstractEvent) => TODO will be removed with changes to input side
	}

	@Override
	public void releaseAllChannelResources() {
		// nothing to do for buffer oriented runtime => TODO will be removed with changes to input side
	}
}