package ru.m.connect;

import haxework.signal.Signal;
import haxe.io.Bytes;
import promhx.Deferred;
import promhx.Promise;
import protohx.Message;
import ru.m.connect.IConnection;


class BaseConnection<O:Message, I:Message> implements IConnection<O, I> {
    public var handler(default, null):Signal<ConnectionEvent>;
    public var sendHandler(default, null):Signal<O>;
    public var receiveHandler(default, null):Signal<I>;
    public var connected(default, null):Bool;
    public var queue(default, null):PacketQueue<I>;

    private var connectDeferred:Deferred<IConnection<O, I>>;

    public function new(i:Class<I>) {
        queue = new PacketQueue<I>(i);
        handler = new Signal<ConnectionEvent>();
        sendHandler = new Signal<O>();
        receiveHandler = new Signal<I>();
        connectDeferred = new Deferred();
    }

    public function connect():Promise<IConnection<O, I>> {
        throw "Not implemented";
    }

    public function disconnect():Void {
        throw "Not implemented";
    }

    public function pushData(bytes:Bytes):Void {
        #if proto_debug L.d('Proto', 'pushData: ${bytes.length}'); #end
        queue.addBytes(bytes);
        while (queue.hasMsg()) {
            var packet:I = queue.popMsg();
            receive(packet);
        }
    }

    public function send(packet:O):Void {
        #if proto_debug L.d('Proto', 'send: ${packet}'); #end
        sendHandler.emit(packet);
    }

    public function receive(packet:I):Void {
        #if proto_debug L.d('Proto', 'receive: ${packet}'); #end
        receiveHandler.emit(packet);
    }
}