cc-haxe/src/kernel/net/Net.hx

package kernel.net;

using tink.CoreApi;

import kernel.net.Package.NetworkID;
import kernel.peripherals.Peripherals.Peripheral;
import kernel.Log;
import kernel.Timer;
import cc.OS;

using Lambda;
using util.Extender.LambdaExtender;

/**
	Class responsible for everything network related.
	Used to send and recceive packages.
**/
class Net {
	/**
		Depends on: KernelEvents
	**/
	public static var instance:Net;
	public static inline final BRODCAST_PORT:Int = 65533;
	public static inline final MESSAGE_TIMEOUT:Int = 3;

	public final networkID:NetworkID = OS.getComputerID();
	private final responseBus:Map<Int, Callback<Package>> = new Map();
	private final protoHandlers:Map<String, Callback<Package>> = new Map();
	private var interfaces:Array<INetworkInterface>;

	@:allow(kernel.Init)
	private function new() {
		this.interfaces = [for (e in Peripheral.instance.getModems()) e ]; // TODO: is this the way to do it?
		this.interfaces.push(Loopback.instance);

		for (interf in interfaces){
			setupInterf(interf);
		}
	}

	private function setupInterf(interf: INetworkInterface) {
		interf.onMessage.handle(pack -> handle(pack,interf));
		interf.listen(networkID);
		interf.listen(BRODCAST_PORT);
	}

	/**
		Called when a new package comes in.
	**/
	private function handle(pack:Package,interf: INetworkInterface) {
		switch pack.type {
			case Data(_) | DataNoResponse(_):
				// Let a local proccess handle it
				routeToProto(pack);
			case Response:
				// Got a response to a send message. Invoke the callback
				if (responseBus.exists(pack.msgID)) {
					responseBus[pack.msgID].invoke(pack);
				}
			case RouteDiscover(_) | RouteDiscoverResponse(_):
				// Delegate to Routing
				Routing.instance.handleRoutePackage(pack,interf);
		}
	}

	private function generateMessageID():Int {
		return Std.random(2147483647); // TODO: better uniqe number
	}

	/**
		Send a message. Dont care if its reaches its destination nor it has a response.
	**/
	public function sendAndForget(dest:Int, proto:String, data:Dynamic) {
		var pack:Package = {
			toID: dest,
			fromID: networkID,
			msgID: generateMessageID(),
			type: DataNoResponse(proto),
			data: data
		}

		sendRaw(pack);
	}

	public function respondTo(pack:Package, data:Dynamic) {
		if (pack.type.match(DataNoResponse(_))) {
			Log.warn("Responed to a no response package. Ignoring");
			return;
		}

		var response = pack.createResponse(data);

		sendRaw(response);
	}

	/**
		Send to package to the localy register handler based on the proto
	**/
	private function routeToProto(pack:Package) {
		var proto:String = switch pack.type {
			case Data(proto):
				proto;
			case DataNoResponse(proto):
				proto;
			case _:
				return;
		}

		if (!protoHandlers.exists(proto) && protoHandlers[proto] != null) {
			return;
		}

		protoHandlers[proto].invoke(pack);
	}

	/**
		Just send the package to the right modem.
	**/
	private function sendRaw(pack:Package) {

		Routing.instance.getIterfaceToId(pack.toID).send(pack.toID,pack.fromID,pack);
	}

	/**
		Send a message and wait for a response.
	**/
	public function sendAndAwait(dest:NetworkID, proto:String, data:Dynamic):Promise<Package> {

		return new Promise<Package>((resolve, reject) -> {
			var pack:Package = {
				toID: dest,
				fromID: networkID,
				msgID: generateMessageID(),
				type: Data(proto),
				data: data
			}

			var timeout:Timer = null;

			responseBus[pack.msgID] = ((reponse:Package) -> {
				resolve(reponse);
				if (timeout != null) {
					timeout.cancle();
				}
			});

			timeout = new Timer(MESSAGE_TIMEOUT, () -> {
				responseBus.remove(pack.msgID);
				reject(new Error(InternalError,"Message timeout"));
			});

			sendRaw(pack);

			// No callback link for you
			return null;
		});
	}

	public function registerProto(proto:String, callback:Callback<Package>) {
		if (protoHandlers.exists(proto)) {
			// Failed. Handler already exist.
			// TODO: return error
			return;
		}

		protoHandlers[proto] = callback;
	}

	public function removeProto(proto:String) {
		protoHandlers.remove(proto);
	}
}