package wifibroadcast;

import java.net.NetworkInterface;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.InterfaceAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.util.Enumeration;

public class WifiBroadcast implements WifiReceiver {

	private DatagramSocket s;
	private int port;
	private InetAddress mAddr;

	public WifiBroadcast(int id,int port, SocketType sender) throws IOException {
		this.port = port;

		if (sender == SocketType.Sender) {
			try {
				InetAddress address0 = getBroadcast();
				System.out.println("Found broadcast "+address0);
				mAddr = address0;
				s = new DatagramSocket();
//				s.bind(new InetSocketAddress(address0,port+1+id));
//				s.setBroadcast(true);
			} catch (SocketException e) {
			}
		} else {
			// InetAddress address0 = getBroadcast();
			s = new DatagramSocket(port);
			// s.bind(new InetSocketAddress(address0,port));
			s.setReuseAddress(true);
			s.setBroadcast(true);
		}
	}

	public void recieve(ByteBuffer testData, long timeout) throws IOException {
		DatagramPacket packet = new DatagramPacket(testData.array(),testData.capacity());
		s.receive(packet);
		testData.limit(packet.getLength());
		testData.position(0);
		System.out.println("recv "+packet.getLength()+" bytes from "+packet.getAddress());
		return; // one at a time
	}


	public void send(ByteBuffer testData) throws IOException {
		if(testData.limit() < 1500) {
			DatagramPacket sendPacket = new DatagramPacket(testData.array(), testData.limit(),mAddr, port);
			s.send(sendPacket);		
			testData.position(testData.limit());
		} else {
			int temp = 1000;
			for(int i = 0 ; i < testData.limit();) {
				DatagramPacket sendPacket = new DatagramPacket(testData.array(),i, temp, mAddr, port);
				s.send(sendPacket);		
				testData.position(i);
				i += 1000;
				if(testData.limit() - i > 1000) {
					temp = 1000;
				} else {
					temp = testData.limit() - i;
				}
			}
		}
		System.out.println("send");
	}
	
	public InetAddress getBroadcast0() throws UnknownHostException {
		return InetAddress.getByName("192.168.100.66");
	}

	public static 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
				System.out.println("MTU="+networkInterface.getMTU());
				return broadcast;
			}
		}
		throw new SocketException();
	}

    @Override
    public void selectMode(boolean mode) {
    }


}