package kernel.peripherals;

import cc.Peripheral;
import kernel.log.Log;
import kernel.net.Package;
import kernel.net.INetworkInterface;

using tink.CoreApi;

class Modem implements INetworkInterface implements IPeripheral {
	public static inline final TYPE_NAME:String = "modem";

	public final addr:String;
	public var onMessage(default, null):Signal<{pack:GenericPackage, dist:Null<Float>}>;

	private final onMessageTrigger:SignalTrigger<{pack:GenericPackage, dist:Null<Float>}> = Signal.trigger();
	private final native:cc.periphs.Modem.Modem;

	@:allow(kernel.peripherals)
	private function new(addr:String) {
		this.onMessage = onMessageTrigger.asSignal();
		this.native = Peripheral.wrap(addr);
		this.addr = addr;

		KernelEvents.onModemMessage.handle(params -> {
			try {
				if (params.addr == this.addr) {
					var pack:GenericPackage = {
						fromID: params.message.fromID,
						toID: params.message.toID,
						msgID: params.message.msgID,
						type: params.message.type,
						data: params.message.data,
						ttl: params.message.ttl,
					};

					this.onMessageTrigger.trigger({pack: pack, dist: params.distance});
				}
			} catch (e:Dynamic) {
				Log.error("Error while parsing modem message");
			}
		});
	}

	public function isWireless():Bool {
		return native.isWireless();
	}

	public function listen(chan:Int) {
		native.open(chan);
	}

	public function isListening(chan:Int):Bool {
		return native.isOpen(chan);
	}

	public function closeAll() {
		native.closeAll();
	}

	public function send(chan:Int, replyChan:Int, payload:Any) {
		native.transmit(chan, replyChan, payload);
	}

	public function name():String {
		return addr;
	}

	public function close(chan:Int) {
		native.close(chan);
	}

	public function getAddr():String {
		return this.addr;
	}

	public function getType():String {
		return TYPE_NAME;
	}

	public function getBaseRoutingCost():Int {
		if (this.native.isWireless()) {
			return 2; // Prefere messages over cable
		} else {
			return 1;
		}
	}
}