serverGroup.js

"use strict";

import Gtk from "gi://Gtk";
import Adw from "gi://Adw";
import { ServerSetting } from "./serverSetting.js";

/**
 * A new group is displayed when _Add_ is clicked in the preferences dialog.
 * It displays controls for the settings of a server.
 */
export class ServerGroup {
    /**
     * Constructor.
     *
     * @param {ServerStatusPreferences} preferences
     * @param {ServerSetting} settings, may be null in which case the fields remain empty, expander is automatically opened and name field focused.
     */
    constructor(preferences, settings) {
        this.id = this.createUID();
        this.preferences = preferences;
        this.serverSettingGroup = new Adw.PreferencesGroup({});

        // expander
        this.expander = this.getExpanderRow(settings);

        // move up/down row
        const moveRow = new Adw.ActionRow({
            title: "Move Up/Down",
        });
        this.moveUpButton = Gtk.Button.new_from_icon_name("go-up-symbolic");
        this.moveUpHandlerId = this.moveUpButton.connect("clicked", () => {
            // does a move actually happen?
            if (this.moveUp(preferences.serverGroups)) {
                preferences.reorder();
                preferences.save();
            }
        });
        this.moveDownButton =
            Gtk.Button.new_from_icon_name("go-down-symbolic");
        this.moveDownHandlerId = this.moveDownButton.connect("clicked", () => {
            // does a move actually happen?
            if (this.moveDown(preferences.serverGroups)) {
                preferences.reorder();
                preferences.save();
            }
        });
        const moveButtonBox = new Gtk.Box({
            orientation: Gtk.Orientation.HORIZONTAL,
            spacing: 10,
        });
        moveButtonBox.append(this.moveUpButton);
        moveButtonBox.append(this.moveDownButton);
        moveRow.add_suffix(moveButtonBox);
        this.serverSettingGroup.add(moveRow);

        // visibility row - show/hide server without deleting
        this.visible = settings?.visible ?? true;
        const visibilityRow = new Adw.ActionRow({
            title: "Show in menu",
            subtitle: "Hidden servers are not displayed and not checked",
        });
        const visibilityIcon = this.visible ? "view-reveal-symbolic" : "view-conceal-symbolic";
        this.visibilityButton = Gtk.Button.new_from_icon_name(visibilityIcon);
        this.visibilityHandlerId = this.visibilityButton.connect("clicked", () => {
            this.visible = !this.visible;
            const newIcon = this.visible ? "view-reveal-symbolic" : "view-conceal-symbolic";
            this.visibilityButton.set_icon_name(newIcon);
            this.update();
        });
        visibilityRow.add_suffix(this.visibilityButton);
        this.serverSettingGroup.add(visibilityRow);

        // delete button
        const deleteRow = new Adw.ActionRow({
            title: "Delete this server",
        });
        this.deleteButton = Gtk.Button.new_from_icon_name(
            "edit-delete-symbolic",
        );
        this.deleteButton.set_css_classes(["destructive-action"]);
        deleteRow.add_suffix(this.deleteButton);
        this.serverSettingGroup.add(deleteRow);
        this.deleteHandlerId = this.deleteButton.connect("clicked", () => {
            const messageDialog = new Adw.MessageDialog({
                transient_for: preferences.window,
                destroy_with_parent: true,
                modal: true,
                heading: "Confirm Delete",
                body: "Are you sure you want to delete this server?",
            });
            messageDialog.add_response("cancel", "_Cancel");
            messageDialog.add_response("delete", "_Delete");
            messageDialog.set_response_appearance(
                "delete",
                Adw.ResponseAppearance.ADW_RESPONSE_DESTRUCTIVE,
            );
            messageDialog.set_default_response("cancel");
            messageDialog.set_close_response("cancel");
            messageDialog.connect("response", (_, response) => {
                if (response === "delete") {
                    this.createServerSettings();
                    this.removeGroup(this.id, preferences.serverGroups);
                    preferences.page.remove(this.serverSettingGroup);
                    preferences.save();
                    this.destroy();
                }
                messageDialog.destroy();
            });
            messageDialog.present();
        });

        this.createServerSettings();

        if (settings === null) {
            this.expander.set_expanded(true);
            this.nameRow.grab_focus();
        }
    }

    getExpanderRow(settings) {
        this.expander = new Adw.ExpanderRow();
        // disable pango as it fails on & in url query strings
        this.expander.set_use_markup(false);
        const title = settings?.name ?? "";
        this.expander.set_title(title);
        const subtitle = settings
            ? `${settings.isGet ? "GET" : "HEAD"} ${settings.url} @ ${settings.frequency}s with ${settings.timeout}s timeout ${settings.notifies ? "🔔" : ""}`
            : "";
        this.expander.set_subtitle(subtitle);
        this.serverSettingGroup.add(this.expander);

        // name text field
        this.nameRow = new Adw.EntryRow({
            title: "Name",
            text: settings?.name ?? "",
            show_apply_button: true,
        });
        this.nameHandlerId = this.nameRow.connect("apply", () => {
            this.update();
        });
        this.expander.add_row(this.nameRow);

        // url text field
        this.urlRow = new Adw.EntryRow({
            title: "URL",
            text: settings?.url ?? "",
            show_apply_button: true,
        });
        this.urlHandlerId = this.urlRow.connect("apply", () => {
            this.update();
        });
        this.expander.add_row(this.urlRow);

        // frequency spinner
        this.frequencyRow = Adw.SpinRow.new_with_range(10, 300, 10);
        this.frequencyRow.set_value(settings?.frequency ?? 120);
        this.frequencyRow.set_title("Frequency (secs.)");
        this.frequencyHandlerId = this.frequencyRow.connect("notify::value", () => {
            this.update();
        });
        this.expander.add_row(this.frequencyRow);

        // timeout spinner
        this.timeoutRow = Adw.SpinRow.new_with_range(1, 300, 1);
        this.timeoutRow.set_value(settings?.timeout ?? 10);
        this.timeoutRow.set_title("Timeout (secs.)");
        this.timeoutHandlerId = this.timeoutRow.connect("notify::value", () => {
            this.update();
        });
        this.expander.add_row(this.timeoutRow);

        // 'use GET' switch
        this.useGetSwitchRow = new Adw.SwitchRow({
            title: "Use GET rather than HEAD",
        });
        const isGet = settings?.isGet ?? false;
        this.useGetSwitchRow.set_active(isGet);
        this.useGetHandlerId = this.useGetSwitchRow.connect("notify::active", () => {
            this.update();
        });
        this.expander.add_row(this.useGetSwitchRow);

        // 'use notifications' switch
        this.useNotificationsSwitchRow = new Adw.SwitchRow({
            title: "Notify when down",
        });
        const notifies = settings?.notifies ?? false;
        this.useNotificationsSwitchRow.set_active(notifies);
        this.useNotificationsHandlerId = this.useNotificationsSwitchRow.connect("notify::active", () => {
            this.update();
        });
        this.expander.add_row(this.useNotificationsSwitchRow);
        return this.expander;
    }

    /**
     * Renew #serverSettings, save them and update UI.
     */
    update() {
        this.createServerSettings();
        this.preferences.save();
        this.updateExpander();
    }

    /**
     * Get the title based on user input.
     *
     * @returns {String}
     */
    getTitle() {
        return this.nameRow.text;
    }

    /**
     * Get the subtitle based on user input.
     *
     * @returns {String}
     */
    getSubtitle() {
        const url = this.urlRow.text;
        const freq = this.frequencyRow.text;
        const timeout = this.timeoutRow.text;
        const httpMethod = this.useGetSwitchRow.active ? "GET" : "HEAD";
        return `${httpMethod} ${url} @ ${freq}s with ${timeout}s timeout ${this.useNotificationsSwitchRow.active ? "🔔" : ""}`;
    }

    /**
     * Update the expander title & subtitle.
     */
    updateExpander() {
        this.expander.set_title(this.getTitle());
        this.expander.set_subtitle(this.getSubtitle());
    }

    /**
     * Move this `Adw.PreferenceGroup` down by one in the list.
     *
     * @param {ServerGroup} array of `ServerGroup`s
     * @returns true if a move occurred.
     */
    moveDown(serverGroups) {
        const index = this.getPosition(serverGroups);
        if (index !== -1 && index < serverGroups.length - 1) {
            this.move(index, index + 1, serverGroups);
            return true;
        }
        return false; // no move was made
    }

    /**
     * Move this `Adw.PreferenceGroup` up by one in the list.
     *
     * @param {ServerGroup} array of `ServerGroup`s
     * @returns true if a move occurred.
     */
    moveUp(serverGroups) {
        const index = this.getPosition(serverGroups);
        if (index > 0) {
            this.move(index, index - 1, serverGroups);
            return true;
        }
        return false; // no move was made
    }

    /**
     * Find the index of `this` in the provided array.
     *
     * @param {ServerGroup} array of `ServerGroup`s
     * @returns int index of `this` in provided array, -1 if not found
     */
    getPosition(serverGroups) {
        for (let i = 0; i < serverGroups.length; i++) {
            const serverGroup = serverGroups[i];
            if (serverGroup.id === this.id) {
                return i;
            }
        }
        return -1;
    }

    /**
     * Move `this` in provided array using provided 'from' index and 'to' index.
     *
     * @param {int} fromIndex the position being moved from
     * @param {int} toIndex the move destination
     * @param {ServerGroup} array of `ServerGroup`s
     */
    move(fromIndex, toIndex, serverGroups) {
        const serverGroup = serverGroups[fromIndex];
        serverGroups.splice(fromIndex, 1);
        serverGroups.splice(toIndex, 0, serverGroup);
    }

    /**
     * Return this group's server settings, creating it if null.
     *
     * @returns {ServerSetting}
     */
    getSettings() {
        if (!this.settings) {
            this.createServerSettings();
        }
        return this.settings;
    }

    /**
     * Return this preference group.
     *
     * @returns {Adw.PreferencesGroup}
     */
    getGroup() {
        return this.serverSettingGroup;
    }

    /**
     * Returns the _Name_ `EntryRow`.
     *
     * @returns {Adw.EntryRow}
     */
    getNameInput() {
        return this.nameRow;
    }

    /**
     * Create a `ServerSetting` based on control values.
     */
    createServerSettings() {
        this.settings = new ServerSetting(
            this.nameRow.text,
            this.urlRow.text,
            this.frequencyRow.text,
            this.timeoutRow.text,
            this.useGetSwitchRow.active,
            this.useNotificationsSwitchRow.active,
            this.visible,
        );
    }

    /**
     * Create a unique ID for this group.
     *
     * @returns {String}
     */
    createUID() {
        const buffer = [];
        const chars =
            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        const charlen = chars.length;
        for (let i = 0; i < 32; i++) {
            buffer[i] = chars.charAt(Math.floor(Math.random() * charlen));
        }
        return buffer.join("");
    }

    /**
     * Remove the group with supplied id from the provided set of groups.
     *
     * @param {String} id the id of the group to remove
     * @param {ServerGroup} array of `ServerGroup`s without group with supplied id
     */
    removeGroup(id, serverGroups) {
        for (let i = 0; i < serverGroups.length; i++) {
            const candidate = serverGroups[i];
            if (candidate.id === id) {
                serverGroups.splice(i, 1);
                break;
            }
        }
    }

    /**
     * Disconnect listeners.
     */
    destroy() {
        if (this.moveUpButton && this.moveUpHandlerId) {
            this.moveUpButton.disconnect(this.moveUpHandlerId);
            this.moveUpHandlerId = null;
            this.moveUpButton = null;
        }
        if (this.moveDownButton && this.moveDownHandlerId) {
            this.moveDownButton.disconnect(this.moveDownHandlerId);
            this.moveDownHandlerId = null;
            this.moveDownButton = null;
        }
        if (this.visibilityButton && this.visibilityHandlerId) {
            this.visibilityButton.disconnect(this.visibilityHandlerId);
            this.visibilityHandlerId = null;
            this.visibilityButton = null;
        }
        if (this.deleteButton && this.deleteHandlerId) {
            this.deleteButton.disconnect(this.deleteHandlerId);
            this.deleteHandlerId = null;
            this.deleteButton = null;
        }
        if (this.nameRow && this.nameHandlerId) {
            this.nameRow.disconnect(this.nameHandlerId);
            this.nameHandlerId = null;
            this.nameRow = null;
        }
        if (this.urlRow && this.urlHandlerId) {
            this.urlRow.disconnect(this.urlHandlerId);
            this.urlHandlerId = null;
            this.urlRow = null;
        }
        if (this.frequencyHandlerId) {
            this.frequencyRow.disconnect(this.frequencyHandlerId);
            this.frequencyHandlerId = null;
            this.frequencyRow = null;
        }
        if (this.useGetHandlerId) {
            this.useGetSwitchRow.disconnect(this.useGetHandlerId);
            this.useGetHandlerId = null;
            this.useGetSwitchRow = null;
        }
        if (this.useNotificationsHandlerId) {
            this.useNotificationsSwitchRow.disconnect(this.useNotificationsHandlerId);
            this.useNotificationsHandlerId = null;
            this.useNotificationsSwitchRow = null;
        }
        if (this.timeoutHandlerId) {
            this.timeoutRow.disconnect(this.timeoutHandlerId);
            this.timeoutHandlerId = null;
            this.timeoutRow = null;
        }
    }
}