var __spreadArray = (this && this.__spreadArray) || function (to, from) {
    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
        to[j] = from[i];
    return to;
};
exports.__esModule = true;
exports.SocketServer = void 0;
var Logger_1 = require("./Logger");
var SocketServer = /** @class */ (function () {
    function SocketServer() {
    }
    SocketServer.prototype.start = function (server, callback) {
        Logger_1.Log('info', 'Preparing SocketServer');
        this.io = require('socket.io')(server);
        this.listeners();
        var port = Config.ports.http;
        server.listen(port, function () {
            Logger_1.Log('info', "WebServer & SocketServer running at port " + port);
            callback();
        });
    };
    SocketServer.prototype.listeners = function () {
        this.io.on('connection', function (socket) {
            Logger_1.Log('info', 'Client connected');
            socket.on('init', function (page) {
                if ([
                    'home'
                ].includes(page)) {
                    socket.join(page);
                    switch (page) {
                        case 'home':
                            socket.emit('quality', Undecked.quality);
                            socket.emit('pagelist', Undecked.Pages.getNames());
                            break;
                    }
                }
            });
            socket.on('page', function (query) {
                var args = [];
                for (var _i = 1; _i < arguments.length; _i++) {
                    args[_i - 1] = arguments[_i];
                }
                switch (query) {
                    case 'request':
                        var pageID = args[0];
                        var callback = args[1];
                        if (Undecked.Pages.exists(pageID)) {
                            var page = Undecked.Pages.get(pageID);
                            callback(null, page["export"]());
                        }
                        else
                            callback('Page does not exist.');
                        break;
                    case 'setname':
                        var pageID = args[0];
                        var newName = args[1];
                        if (Undecked.Pages.exists(pageID)) {
                            var page = Undecked.Pages.get(pageID);
                            page.setName(newName);
                        }
                        break;
                    case 'setkey':
                        var pageID = args[0];
                        var x = args[1];
                        var y = args[2];
                        var key = args[3];
                        var responseToken = args[4];
                        if (Undecked.Pages.exists(pageID)) {
                            var page = Undecked.Pages.get(pageID);
                            page.updateKey(x, y, key, responseToken);
                        }
                        break;
                    case 'getkey':
                        var pageID = args[0];
                        var x = args[1];
                        var y = args[2];
                        var getkey_callback = args[3];
                        if (Undecked.Pages.exists(pageID)) {
                            var page = Undecked.Pages.get(pageID);
                            if (page.hasKey(x, y))
                                getkey_callback(page.requestKey(x, y));
                        }
                        break;
                    case 'executekey':
                        var pageID = args[0];
                        var x = args[1];
                        var y = args[2];
                        if (Undecked.Pages.exists(pageID)) {
                            var page = Undecked.Pages.get(pageID);
                            if (page.hasKey(x, y)) {
                                if (page.getKey(x, y).actions != undefined &&
                                    page.getKey(x, y).actions.up != undefined) {
                                    Undecked.Integrations.executeActions(page.getKey(x, y).actions.up, null);
                                }
                            }
                        }
                        break;
                    case 'create':
                        var pageName = args[0];
                        Undecked.Pages.create(pageName, function () {
                            return Undecked.SocketServer.broadcastTo('home', 'pagelist', Undecked.Pages.getNames());
                        });
                        break;
                    case 'setorder':
                        var order = args[0];
                        if (typeof order.includes == 'function')
                            Undecked.Pages.setOrder(order);
                        break;
                    case 'operation':
                        var operation = args[0];
                        var originPageID = args[1];
                        var originX = args[2];
                        var originY = args[3];
                        var destinationPageID = args[4];
                        var destinationX = args[5];
                        var destinationY = args[6];
                        Undecked.Pages.handleOperation(operation, originPageID, originX, originY, destinationPageID, destinationX, destinationY);
                        break;
                }
            });
            socket.on('actioneditor', function (query) {
                var args = [];
                for (var _i = 1; _i < arguments.length; _i++) {
                    args[_i - 1] = arguments[_i];
                }
                switch (query) {
                    case 'start':
                        var settings = args[0];
                        var callback = args[1];
                        var pageID = settings.pageID;
                        var keyX = settings.keyX;
                        var keyY = settings.keyY;
                        var start = function () {
                            var response = Undecked.Integrations.startEditor(settings);
                            callback(response.error, response.actionEditorID);
                        };
                        var page = Undecked.Pages.get(pageID);
                        if (page && page.hasKey(keyX, keyY)) {
                            var key = page.getKey(keyX, keyY);
                            if (key.state != undefined && key.state.type == 'ghost') {
                                if (key.state.masterID != undefined) {
                                    var masterLocation = Undecked.Pages.KeyManager.getLocation(key.state.masterID);
                                    var masterPage = Undecked.Pages.get(masterLocation.pageID);
                                    if (masterPage) {
                                        var masterKey = masterPage.getKey(masterLocation.x, masterLocation.y);
                                        if (masterKey.state != undefined &&
                                            masterKey.state.ghostIDs != undefined &&
                                            masterKey.state.ghostIDs.includes(key.id)) {
                                            settings.pageID = masterLocation.pageID;
                                            settings.keyX = masterLocation.x;
                                            settings.keyY = masterLocation.y;
                                            start();
                                        }
                                    }
                                }
                            }
                            else
                                start();
                        }
                        break;
                    case 'remove':
                        var pageID = args[0];
                        var x = args[1];
                        var y = args[2];
                        var actionInstanceID = args[3];
                        var type = args[4];
                        var remove = function (key) {
                            if (key.actions != undefined && key.actions[type] != undefined) {
                                if (key.actions[type][actionInstanceID] != undefined) {
                                    delete key.actions[type][actionInstanceID];
                                    page.save();
                                }
                            }
                        };
                        if (Undecked.Pages.exists(pageID)) {
                            var page = Undecked.Pages.get(pageID);
                            if (page.hasKey(x, y)) {
                                var key = page.getKey(x, y);
                                if (key.state != undefined && key.state.type == 'ghost') {
                                    if (key.state.masterID != undefined) {
                                        var masterLocation = Undecked.Pages.KeyManager.getLocation(key.state.masterID);
                                        var masterPage = Undecked.Pages.get(masterLocation.pageID);
                                        if (masterPage) {
                                            var masterKey = masterPage.getKey(masterLocation.x, masterLocation.y);
                                            if (masterKey.state != undefined &&
                                                masterKey.state.ghostIDs != undefined &&
                                                masterKey.state.ghostIDs.includes(key.id))
                                                remove(masterKey);
                                        }
                                    }
                                }
                                else
                                    remove(key);
                            }
                        }
                        break;
                    case 'create':
                        var pageID = args[0];
                        var x = args[1];
                        var y = args[2];
                        var createtype = args[3];
                        var integrationID = args[4];
                        var actionID = args[5];
                        var createCallback = args[6];
                        var create = function (key) {
                            if (key.actions == undefined)
                                key.actions = { up: {}, down: {}, latch: {}, unlatch: {} };
                            if (key.actions[createtype] == undefined)
                                key.actions[createtype] = {};
                            var newActionInstanceID = Undecked.generateRandom(8, function (checkValid) {
                                return key.actions[createtype][checkValid] == undefined;
                            });
                            key.actions[createtype][newActionInstanceID] = {
                                integrationID: integrationID,
                                actionID: actionID,
                                actionInstanceID: newActionInstanceID,
                                properties: {},
                                logs: []
                            };
                            createCallback(key.actions[createtype][newActionInstanceID]);
                        };
                        if (Undecked.Integrations.exists(integrationID)) {
                            var integration = Undecked.Integrations.get(integrationID);
                            if (integration.api.hasAction(actionID)) {
                                if (Undecked.Pages.exists(pageID)) {
                                    var page = Undecked.Pages.get(pageID);
                                    if (page.hasKey(x, y)) {
                                        var key = page.getKey(x, y);
                                        if (key.state != undefined && key.state.type == 'ghost') {
                                            if (key.state.masterID != undefined) {
                                                var masterLocation = Undecked.Pages.KeyManager.getLocation(key.state.masterID);
                                                var masterPage = Undecked.Pages.get(masterLocation.pageID);
                                                if (masterPage) {
                                                    var masterKey = masterPage.getKey(masterLocation.x, masterLocation.y);
                                                    if (masterKey.state != undefined &&
                                                        masterKey.state.ghostIDs != undefined &&
                                                        masterKey.state.ghostIDs.includes(key.id))
                                                        create(masterKey);
                                                }
                                            }
                                        }
                                        else
                                            create(key);
                                    }
                                }
                            }
                        }
                        break;
                    case 'instance':
                        var actionEditorID = args[0];
                        var instanceQuery = args[1];
                        if (Undecked.Integrations.editorExists(actionEditorID)) {
                            var EditorWrapper = Undecked.Integrations.getEditor(actionEditorID);
                            switch (instanceQuery) {
                                case 'ready':
                                    EditorWrapper.ready();
                                    break;
                                case 'fields':
                                    var fields = args[2];
                                    if (typeof EditorWrapper.editor._change == 'function')
                                        EditorWrapper.editor._change(fields);
                                    break;
                                case 'close':
                                    EditorWrapper.destroy();
                                    break;
                            }
                        }
                        break;
                }
            });
            socket.on('connections', function (query) {
                var args = [];
                for (var _i = 1; _i < arguments.length; _i++) {
                    args[_i - 1] = arguments[_i];
                }
                switch (query) {
                    case 'request':
                        var integrationID = args[0];
                        var connectionType = args[1];
                        var requestCallback = args[2];
                        var fields = Undecked.Connections.getConnectionRequestData(integrationID, connectionType);
                        requestCallback(fields);
                        break;
                    case 'create':
                        var integrationID = args[0];
                        var connectionType = args[1];
                        var properties = args[2];
                        var createCallback = args[3];
                        Undecked.Connections.create(integrationID, connectionType, properties, createCallback);
                        break;
                    default:
                        break;
                }
            });
        });
    };
    SocketServer.prototype.broadcastTo = function (group, header) {
        var _a;
        var args = [];
        for (var _i = 2; _i < arguments.length; _i++) {
            args[_i - 2] = arguments[_i];
        }
        if (this.io)
            (_a = this.io.to(group)).emit.apply(_a, __spreadArray([header], args));
    };
    SocketServer.prototype.broadcast = function (header) {
        var _a;
        var args = [];
        for (var _i = 1; _i < arguments.length; _i++) {
            args[_i - 1] = arguments[_i];
        }
        if (this.io)
            (_a = this.io).emit.apply(_a, __spreadArray([header], args));
    };
    return SocketServer;
}());
exports.SocketServer = SocketServer;
// export interface SocketServer {
// 	start: (server: Server, callback: () => void) => void;
// 	broadcastTo: (group: string, header: string, ...args: any[]) => void;
// 	broadcast: (header: string, ...args: any[]) => void;
// }
//# sourceMappingURL=SocketServer.js.map