package ru.m.connect.js;

import promhx.Promise;
import protohx.Message;
import ru.m.Base64;
import ru.m.connect.IConnection.ConnectionEvent;


typedef WebSocket = {
    var onopen:Dynamic -> Void;
    var onclose:Dynamic -> Void;
    var onmessage:Dynamic -> Void;
    var onerror:Dynamic -> Void;
    function send(message:String):Void;
    function emit(a:String, b:String):Void;
    function close():Void;
}

class JsConnection<O:Message, I:Message> extends BaseConnection<O, I> {

    private var host:String;
    private var port:Int;
    private var socket:WebSocket;

    public function new(host:String, port:Int, i:Class<I>) {
        super(i);
        this.host = host;
        this.port = port;
        connected = false;
    }

    private function buildSocket(host:String, port:Int):WebSocket {
        return untyped __js__('new WebSocket("ws://${host}:${port}");');
    }

    override public function connect():Promise<IConnection<O, I>>  {
        var self = this;
        var decodeBytes = Base64.decodeBase64;
        socket = buildSocket(host, port);
        socket.onopen = this.onConnect;
        socket.onclose = this.onClose;
        socket.onerror = this.onError;
        socket.onmessage = this.onSocketData;
        return connectDeferred.promise();
    }

    override public function disconnect():Void {
        socket.close();
        connected = false;
    }

    private function onError(event:Dynamic):Void {
        socket.close();
        connected = false;
        handler.emit(ConnectionEvent.ERROR(event));
    }

    private function onConnect(_):Void {
        connected = true;
        handler.emit(ConnectionEvent.CONNECTED);
        connectDeferred.resolve(this);
    }

    private function onClose(_):Void {
        socket.close();
        connected = false;
        handler.emit(ConnectionEvent.DISCONNECTED);
    }

    private function onSocketData(event:Dynamic):Void {
        try {
            var data:String = event.data;
            var packet:I = WebSocketTools.string2packet(data, queue.packetClass);
            receive(packet);
        } catch (error:Dynamic) {
            handler.emit(ConnectionEvent.ERROR(event));
        }
    }

    override public function send(packet:O):Void {
        super.send(packet);
        socket.send(WebSocketTools.packet2string(packet));
    }
}