package glue.net.adapters;
import glue.net.Adapter; // interface-like class with overriden methods and packet() for callbacks.
import glue.type.*; // houses typedefs
import sys.net.Address;
import sys.net.Host;
import sys.net.UdpSocket;

/**
 * Implementation using Haxe's sys.net.* UDP sockets.
 * URL and Port are typedefs for String and Int accordingly. Socket is a typedef for Any.
 * @author YellowAfterlife
 */
class AdpStd extends Adapter {
	
	/** Resolved URLs */
	var found:Map<URL, Address> = new Map();
	
	/** URLs that failed to resolve (thus no sense in retrying) */
	var notFound:Map<URL, Bool> = new Map();
	
	/** IPv4 -> URL map */
	var urls:Map<Int, URL> = new Map();
	
	/** Active sockets (that should be read from) */
	var sockets:Array<sys.net.Socket> = [];
	
	/**
	 * Reused for storing received data.
	 * Buffer is an extension of haxe.io.Bytes
	 */
	var buffer:Buffer = new Buffer(16384);
	
	public function new() {
		//
	}
	
	/** Called once per game frame to poll the sockets and run callbacks. */
	public function update():Void {
		var ready = null;
		try {
			ready = sys.net.Socket.select(sockets, [], [], 0.);
		} catch (_:Dynamic) {
			return;
		}
		for (skt in ready.read) {
			var skt:AdpStdSocket = cast skt;
			var addr = skt.address;
			var step = 0;
			while (++step < 1000000) try {
				var len = skt.readFrom(buffer, 0, buffer.length, addr);
				var port = addr.port, host = addr.host, url:URL;
				// resolve URL from IPv4:
				if (urls.exists(host)) {
					url = urls[host];
				} else {
					url = addr.getHost().toString();
					urls[host] = url;
				}
				// store for later reference if not done already:
				if (!found.exists(url)) found[url] = addr.clone();
				// pass the buffer and parameters to callback function:
				packet(url, port, skt, buffer, len);
			} catch (_:Dynamic) { // error or out of data
				break;
			}
		}
	}
	
	/** Creates a server socket at the given port. */
	public function host(port:Port, capacity:Int = 32):Dynamic {
		try {
			var skt = new AdpStdSocket();
			skt.bind(new Host("0.0.0.0"), port); // `0.0.0.0` is needed to auto-select IP
			skt.setBlocking(false);
			sockets.push(skt);
			return skt;
		} catch (_:Dynamic) {
			return null;
		}
	}
	
	/** Creates a client socket for joining the given URL+Port. */
	public function join(url:URL, port:Port):Dynamic {
		try {
			var skt = new AdpStdSocket();
			skt.setBlocking(false);
			sockets.push(skt);
			return skt;
		} catch (_:Dynamic) {
			return null;
		}
	}
	
	/** Sends data with the given Socket to the given URL+Port. */
	public function send(skt:Socket, url:URL, port:Port, buffer:Buffer, size:Int):Bool {
		if (notFound[url]) return false;
		var skt:AdpStdSocket = skt;
		var adr:Address = found[url];
		if (adr == null) {
			try {
				var host = new Host(url);
				adr = new Address();
				adr.host = host.ip;
				urls[host.ip] = url;
				found[url] = adr;
			} catch (_:Dynamic) {
				notFound[url] = true;
			}
		}
		adr.port = port;
		try {
			skt.sendTo(buffer, 0, size, adr);
			return true;
		} catch (_:Dynamic) {
			return false;
		}
	}
	
	private inline function destroy(skt:AdpStdSocket):Void {
		var skt:AdpStdSocket = skt;
		sockets.remove(skt);
		skt.close();
	}
	
	public function destroyServer(skt:Dynamic):Void destroy(skt);
	
	public function destroySocket(skt:Dynamic):Void destroy(skt);
	
}

class AdpStdSocket extends UdpSocket {
	public var address:Address = new Address();
	public function new() {
		super();
	}
}