package wifibroadcast;

import java.net.NetworkInterface;
import java.io.IOException;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.InterfaceAddress;
import java.net.SocketException;
import java.net.StandardSocketOptions;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.spi.SelectorProvider;
import java.util.Enumeration;
import java.util.Iterator;

public class WifiBroadcast implements WifiReceiver {

	private DatagramChannel channel;
	private Selector selector;
	private DatagramSocket s;

	public WifiBroadcast(int port, SocketType sender) throws IOException {
		selector = SelectorProvider.provider().openSelector();		
		channel = SelectorProvider.provider().openDatagramChannel();
		s = channel.socket();
		channel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
		channel.configureBlocking(false);
		if (sender == SocketType.Sender) {
			s.setBroadcast(true);
			try {
				InetAddress address0 = getBroadcast();
				System.out.println("Found broadcast "+address0);
				InetSocketAddress address = new InetSocketAddress(address0, port);
				channel.connect(address);
			} catch (SocketException e) {
				// for some bad IPv6 implementation
				channel.connect(new InetSocketAddress(port));
			}
		} else {
			try {
				InetSocketAddress address = new InetSocketAddress("::", port);
				channel.connect(address);
			} catch (SocketException e) {
				// for some bad IPv6 implementation
				channel.connect(new InetSocketAddress(port));
			}
		}
		channel.register(selector, SelectionKey.OP_READ);
	}

	public void recieve(ByteBuffer testData, long timeout) throws IOException {
		if (selector.select(timeout)>0) {
			for (Iterator<SelectionKey> it = selector.selectedKeys().iterator();it.hasNext(); ) {
				SelectionKey s = it.next();
				it.remove();
				DatagramChannel ch = (DatagramChannel)s.channel();
				ch.read(testData);
				testData.flip();
				return; // one at a time
			}
		} else {
			System.out.println("receiver time out");
			testData.position(0); testData.limit(0);
		}
	}
	
	public InetAddress getBroadcast() throws SocketException {
		Enumeration<NetworkInterface> interfaces =
				NetworkInterface.getNetworkInterfaces();
		while (interfaces.hasMoreElements()) {
			NetworkInterface networkInterface = interfaces.nextElement();
			if (networkInterface.isLoopback())
				continue;    // Don't want to broadcast to the loopback interface
			for (InterfaceAddress interfaceAddress :
				networkInterface.getInterfaceAddresses()) {
				InetAddress broadcast = interfaceAddress.getBroadcast();
				if (broadcast == null)
					continue;
				// Use the address
				return broadcast;
			}
		}
		throw new SocketException();
	}


	public void send(ByteBuffer testData) throws IOException {
		int out = channel.write(testData);
		System.out.println("send "+out+" bytes.");
	}
}