/* extension.js
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 */

/* Based on https://stackoverflow.com/questions/33001192/how-to-send-a-string-to-a-gnome-shell-extension */

const St = imports.gi.St;
const Gio = imports.gi.Gio;
const Main = imports.ui.main;

class MonitorWidget {
    constructor(name, group, text, style, icon, iconStyle) {
        this.name = name;
        this.group = group;
        this._createIcon(icon, iconStyle);
        this._createText(text, style);
    }

    _createText(text, style) {
        this.style = style;
        if (text === '') {
            this.widget = null;
        } else {
            this.widget = new St.Button({ label: text });
            this.widget.set_style(this.style);
        }
    }

    _createIcon(icon, style) {
        this.iconStyle = style;
        if (icon === '') {
            this.icon = null;
        } else {
            let gicon = Gio.icon_new_for_string(icon);
            this.icon = new St.Icon({ gicon });
            this.icon.set_style(this.iconStyle);
        }
    }

    update(text, style, icon, iconStyle) {
        if (!this.widget) {
            this._createText(text, style);
        } else {
            if (text !== '')
                this.widget.label = text;
            this.style = style;
            this.widget.set_style(this.style);
        }

        if (icon !== '')
            this._createIcon(icon, iconStyle);

        if (icon === '' && iconStyle !== '' && this.icon) {
            this.iconStyle = style;
            this.icon.set_style(this.iconStyle);
        }
    }
}

// From https://github.com/ubuntu/gnome-shell-extension-appindicator/blob/master/interfaces.js
// loads a xml file into an in-memory string
function loadInterfaceXml(filename) {
    let extension = imports.misc.extensionUtils.getCurrentExtension();

    let interfacesDir = extension.dir.get_child('.');

    let file = interfacesDir.get_child(filename);

    let [result, contents] = imports.gi.GLib.file_get_contents(file.get_path());

    if (result) {
        // HACK: The "" + trick is important as hell because file_get_contents returns
        // an object (WTF?) but Gio.makeProxyWrapper requires `typeof() == "string"`
        // Otherwise, it will try to check `instanceof XML` and fail miserably because there
        // is no `XML` on very recent SpiderMonkey releases (or, if SpiderMonkey is old enough,
        // will spit out a TypeError soon).
        if (contents instanceof Uint8Array)
            contents = imports.byteArray.toString(contents);
        let res = `<node>${contents}</node>`;
        return res;
    } else {
        throw new Error(`Generic monitor: Could not load file: ${filename}`);
    }
}

class GenericMonitorDBUS {
    constructor() {
        this.monitor_groups = {};
        this.box = Main.panel._centerBox;
        this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(loadInterfaceXml('dbus.xml'), this);
        this._dbusImpl.export(Gio.DBus.session, '/com/soutade/GenericMonitor');
    }

    _checkParmeters(parameters) {
        if (!parameters.hasOwnProperty('group'))
            throw new Error('No group defined');

        if (!parameters.hasOwnProperty('items'))
            throw new Error('No items defined');

        for (let itemIndex in parameters['items']) {
            let item = parameters['items'][itemIndex];
            if (!item.hasOwnProperty('name'))
                throw new Error('No name defined for item');
            if (!item.hasOwnProperty('text') && !item.hasOwnProperty('icon'))
                throw new Error('No text not icon defined for item');
        }
    }

    _getItemFromGroup(group, name) {
        for (let groupItemIndex in group) {
            let groupItem = group[groupItemIndex];
            if (groupItem.name === name)
                return groupItem;
        }

        return null;
    }

    notify(str) {
        let parameters = JSON.parse(str);
        this._checkParmeters(parameters);

        let groupName = parameters['group'];
        let group;
        if (!this.monitor_groups.hasOwnProperty(groupName)) {
            group = [];
            this.monitor_groups[groupName] = group;
        } else {
            group = this.monitor_groups[groupName];
        }

        for (let itemIndex in parameters['items']) {
            let item = parameters['items'][itemIndex];
            let style = '';
            if (item.hasOwnProperty('style'))
                style = item['style'];
            let text = '';
            if (item.hasOwnProperty('text'))
                text = item['text'];
            let icon = '';
            if (item.hasOwnProperty('icon'))
                icon = item['icon'];
            let iconStyle = '';
            if (item.hasOwnProperty('icon-style'))
                iconStyle = item['icon-style'];

            let monitorWidget = this._getItemFromGroup(group, item['name']);
            let lastWidget = null;

            // New widget
            if (monitorWidget === null) {
                monitorWidget = new MonitorWidget(item['name'], groupName, text, style, icon, iconStyle);
                if (group.length)
                    lastWidget = group[group.length - 1].widget;
                group.push(monitorWidget);
                // lastWidget => NULL, insert at the end
                if (monitorWidget.icon) {
                    this.box.insert_child_above(monitorWidget.icon, lastWidget);
                    lastWidget = monitorWidget.icon;
                }
                if (monitorWidget.widget)
                    this.box.insert_child_above(monitorWidget.widget, lastWidget);
            } else {
                let prevWidget = monitorWidget.widget;
                let prevIcon = monitorWidget.icon;

                monitorWidget.update(text, style, icon, iconStyle);

                if (monitorWidget.icon) {
                    if (prevIcon)
                        this.box.remove_child(prevIcon);
                    this.box.insert_child_above(monitorWidget.icon, lastWidget);
                    lastWidget = monitorWidget.icon;
                }

                if (!prevWidget && monitorWidget.widget)
                    this.box.insert_child_above(monitorWidget.widget, lastWidget);
            }
        }
    }

    _removeItemFromBox(item) {
        if (item.widget)
            this.box.remove_child(item.widget);
        if (item.icon)
            this.box.remove_child(item.icon);
    }

    deleteItems(str) {
        let parameters = JSON.parse(str);

        if (!parameters.hasOwnProperty('items'))
            throw new Error('No items defined');

        for (let itemIndex in parameters['items']) {
            let itemName = parameters['items'][itemIndex];
            let fullName = itemName.split('@');
            if (fullName.length !== 2)
                throw new Error(`Invalid name ${itemName}`);
            itemName = fullName[0];
            let groupName = fullName[1];
            if (!this.monitor_groups.hasOwnProperty(groupName))
                continue;
            let group = this.monitor_groups[groupName];
            let item = this._getItemFromGroup(group, itemName);
            if (item !== null) {
                this._removeItemFromBox(item);
                delete group[item['name']];
                if (group.length === 0)
                    delete this.monitor_groups[groupName];
            }
        }
    }

    deleteGroups(str) {
        let parameters = JSON.parse(str);

        if (!parameters.hasOwnProperty('groups'))
            throw new Error('No groups defined');

        let groupsToDelete = [];
        for (let groupIndex in parameters['groups']) {
            let groupName = parameters['groups'][groupIndex];
            if (!this.monitor_groups.hasOwnProperty(groupName))
                continue;
            let group = this.monitor_groups[groupName];
            for (let itemIndex in group)
                this._removeItemFromBox(group[itemIndex]);
            groupsToDelete.push(groupName);
        }
        for (let groupDeleteIndex in groupsToDelete) {
            let groupName = groupsToDelete[groupDeleteIndex];
            delete this.monitor_groups[groupName];
        }
    }

    destructor() {
        for (let groupIndex in this.monitor_groups) {
            let group = this.monitor_groups[groupIndex];
            for (let itemIndex in group)
                this._removeItemFromBox(group[itemIndex]);
        }
        this.monitor_groups = {};
        this._dbusImpl.unexport();
    }
}

class Extension {
    enable() {
        this.textDBusService = new GenericMonitorDBUS();
    }

    disable() {
        this.textDBusService.destructor();
        delete this.textDBusService;
    }
}

let extension = new Extension();

function init() {
}

function enable() {
    extension.enable();
}

function disable() {
    extension.disable();
}