'use strict';

const Gdk = imports.gi.Gdk;
const GdkPixbuf = imports.gi.GdkPixbuf;
const Gio = imports.gi.Gio;
const GLib = imports.gi.GLib;
const GObject = imports.gi.GObject;
const Gtk = imports.gi.Gtk;

const Device = imports.preferences.device;
const Remote = imports.utils.remote;

/*
 * Header for support logs
 */
const LOG_HEADER = new GLib.Bytes(`
GSConnect Version: ${gsconnect.metadata.version}
GSConnect Install: ${(gsconnect.is_local) ? 'user' : 'system'}
GJS: ${imports.system.version}
XDG_SESSION_TYPE: ${GLib.getenv('XDG_SESSION_TYPE')}
GDMSESSION: ${GLib.getenv('GDMSESSION')}
--------------------------------------------------------------------------------
`);


/**
 * Generate a support log
 */
async function generateSupportLog(time) {
    try {
        let file = Gio.File.new_tmp('gsconnect.XXXXXX')[0];

        let logFile = await new Promise((resolve, reject) => {
            file.replace_async(null, false, 2, 0, null, (file, res) => {
                try {
                    resolve(file.replace_finish(res));
                } catch (e) {
                    reject(e);
                }
            });
        });

        await new Promise((resolve, reject) => {
            logFile.write_bytes_async(LOG_HEADER, 0, null, (file, res) => {
                try {
                    resolve(file.write_bytes_finish(res));
                } catch (e) {
                    reject(e);
                }
            });
        });

        // FIXME: BSD???
        let proc = new Gio.Subprocess({
            flags: Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE,
            argv: ['journalctl', '--no-host', '--since', time]
        });
        proc.init(null);

        logFile.splice_async(
            proc.get_stdout_pipe(),
            Gio.OutputStreamSpliceFlags.CLOSE_TARGET,
            GLib.PRIORITY_DEFAULT,
            null,
            (source, res) => {
                try {
                    source.splice_finish(res);
                } catch (e) {
                    logError(e);
                }
            }
        );

        await new Promise((resolve, reject) => {
            proc.wait_check_async(null, (proc, res) => {
                try {
                    resolve(proc.wait_finish(res));
                } catch (e) {
                    reject(e);
                }
            });
        });

        let uri = file.get_uri();
        Gio.AppInfo.launch_default_for_uri_async(uri, null, null, null);
    } catch (e) {
        logError(e);
    }
}


/**
 * "Connect to..." Dialog
 */
var ConnectDialog = GObject.registerClass({
    GTypeName: 'GSConnectConnectDialog',
    Template: 'resource:///org/gnome/Shell/Extensions/GSConnect/ui/connect.ui',
    Children: [
        'cancel-button', 'connect-button',
        'lan-grid', 'lan-ip', 'lan-port'
    ]
}, class ConnectDialog extends Gtk.Dialog {

    _init(params = {}) {
        super._init(Object.assign({
            use_header_bar: true
        }, params));
    }

    vfunc_response(response_id) {
        if (response_id === Gtk.ResponseType.OK) {
            try {
                let address;

                // Lan host/port entered
                if (this.lan_ip.text) {
                    let host = this.lan_ip.text;
                    let port = this.lan_port.value;
                    address = GLib.Variant.new_string('lan://' + host + ':' + port);
                } else {
                    return false;
                }

                this.application.activate_action('connect', address);
            } catch (e) {
                logError(e);
            }
        }

        if (this._devicesId) {
            this.application.bluetooth.disconnect(this._devicesId);
        }

        this.destroy();
        return false;
    }
});


function rowSeparators(row, before) {
    let header = row.get_header();

    if (before === null) {
        if (header !== null) {
            header.destroy();
        }

        return;
    }

    if (header === null) {
        header = new Gtk.Separator({visible: true});
        row.set_header(header);
    }
}


var Window = GObject.registerClass({
    GTypeName: 'GSConnectPreferencesWindow',
    Properties: {
        'display-mode': GObject.ParamSpec.string(
            'display-mode',
            'Display Mode',
            'Display devices in either the Panel or User Menu',
            GObject.ParamFlags.READWRITE,
            null
        )
    },
    Template: 'resource:///org/gnome/Shell/Extensions/GSConnect/ui/preferences-window.ui',
    Children: [
        // HeaderBar
        'headerbar', 'infobar', 'stack',
        'service-menu', 'service-edit', 'service-refresh',
        'device-menu', 'prev-button',

        // Popover
        'rename-popover', 'rename', 'rename-label', 'rename-entry', 'rename-submit',

        // Focus Box
        'service-window', 'service-box',

        // Device List
        'device-list', 'device-list-spinner', 'device-list-placeholder'
    ]
}, class PreferencesWindow extends Gtk.ApplicationWindow {

    _init(params) {
        super._init(params);

        // Service Settings
        this.settings = new Gio.Settings({
            settings_schema: gsconnect.gschema.lookup(
                'org.gnome.Shell.Extensions.GSConnect',
                true
            )
        });

        // Service Proxy
        this.service = new Remote.Service();

        this._deviceAddedId = this.service.connect(
            'device-added',
            this._onDeviceAdded.bind(this)
        );

        this._deviceRemovedId = this.service.connect(
            'device-removed',
            this._onDeviceRemoved.bind(this)
        );

        this._serviceChangedId = this.service.connect(
            'notify::active',
            this._onServiceChanged.bind(this)
        );

        // HeaderBar (Service Name)
        this.headerbar.title = this.settings.get_string('name');
        this.rename_entry.text = this.headerbar.title;

        // Scroll with keyboard focus
        this.service_box.set_focus_vadjustment(this.service_window.vadjustment);

        // Device List
        this.device_list.set_header_func(rowSeparators);

        // Discoverable InfoBar
        this.settings.bind(
            'discoverable',
            this.infobar,
            'reveal-child',
            Gio.SettingsBindFlags.INVERT_BOOLEAN
        );
        this.add_action(this.settings.create_action('discoverable'));

        // Application Menu
        this._initMenu();

        // Broadcast automatically every 5 seconds if there are no devices yet
        this._refreshSource = GLib.timeout_add_seconds(
            GLib.PRIORITY_DEFAULT,
            5,
            this._refresh.bind(this)
        );

        // Restore window size/maximized/position
        this._restoreGeometry();

        // Prime the service
        this._initService();
    }

    get display_mode() {
        if (this.settings.get_boolean('show-indicators')) {
            return 'panel';
        } else {
            return 'user-menu';
        }
    }

    set display_mode(mode) {
        this.settings.set_boolean('show-indicators', (mode === 'panel'));
    }

    vfunc_delete_event(event) {
        if (this.service) {
            this.service.disconnect(this._deviceAddedId);
            this.service.disconnect(this._deviceRemovedId);
            this.service.disconnect(this._serviceChangedId);
            this.service.destroy();
            this.service = null;
        }

        this._saveGeometry();
        GLib.source_remove(this._refreshSource);

        // FIXME: this wouldn't be necessary if we were disposing devices right
        this.application.quit();
        return false;
    }

    async _initService() {
        try {
            this._onServiceChanged(this.service, null);
            await this.service.reload();
        } catch (e) {
            logError(e, 'GSConnect');
        }
    }

    _initMenu() {
        // Panel/User Menu mode
        let displayMode = new Gio.PropertyAction({
            name: 'display-mode',
            property_name: 'display-mode',
            object: this
        });
        this.add_action(displayMode);

        // About Dialog
        let aboutDialog = new Gio.SimpleAction({name: 'about'});
        aboutDialog.connect('activate', this._aboutDialog.bind(this));
        this.add_action(aboutDialog);

        // "Connect to..." Dialog
        let connectDialog = new Gio.SimpleAction({name: 'connect'});
        connectDialog.connect('activate', this._connectDialog.bind(this));
        this.add_action(connectDialog);

        // "Generate Support Log" GAction
        let generateSupportLog = new Gio.SimpleAction({name: 'support-log'});
        generateSupportLog.connect('activate', this._generateSupportLog.bind(this));
        this.add_action(generateSupportLog);

        // "Help" GAction
        let help = new Gio.SimpleAction({name: 'help'});
        help.connect('activate', this._help);
        this.add_action(help);
    }

    _refresh() {
        if (this.service.active && this.device_list.get_children().length < 1) {
            this.device_list_spinner.active = true;
            this.service.activate_action('refresh', null);
        } else {
            this.device_list_spinner.active = false;
        }

        return GLib.SOURCE_CONTINUE;
    }

    /**
     * Window State
     */
    _restoreGeometry() {
        this._windowState = new Gio.Settings({
            settings_schema: gsconnect.gschema.lookup(
                'org.gnome.Shell.Extensions.GSConnect.WindowState',
                true
            ),
            path: '/org/gnome/shell/extensions/gsconnect/preferences/'
        });

        // Size
        let [width, height] = this._windowState.get_value('window-size').deepUnpack();

        if (width && height) {
            this.set_default_size(width, height);
        }

        // Maximized State
        if (this._windowState.get_boolean('window-maximized')) {
            this.maximize();
        }
    }

    _saveGeometry() {
        let state = this.get_window().get_state();

        // Maximized State
        let maximized = (state & Gdk.WindowState.MAXIMIZED);
        this._windowState.set_boolean('window-maximized', maximized);

        // Leave the size at the value before maximizing
        if (maximized || (state & Gdk.WindowState.FULLSCREEN))
            return;

        // Size
        let size = this.get_size();
        this._windowState.set_value('window-size', new GLib.Variant('(ii)', size));
    }

    /**
     * About Dialog
     */
    _aboutDialog() {
        if (this._about === undefined) {
            this._about = new Gtk.AboutDialog({
                application: Gio.Application.get_default(),
                authors: [
                    'Andy Holmes <andrew.g.r.holmes@gmail.com>',
                    'Bertrand Lacoste <getzze@gmail.com>',
                    'Frank Dana <ferdnyc@gmail.com>'
                ],
                comments: _('A complete KDE Connect implementation for GNOME'),
                logo: GdkPixbuf.Pixbuf.new_from_resource_at_scale(
                    '/org/gnome/Shell/Extensions/GSConnect/icons/org.gnome.Shell.Extensions.GSConnect.svg',
                    128,
                    128,
                    true
                ),
                program_name: 'GSConnect',
                // TRANSLATORS: eg. 'Translator Name <your.email@domain.com>'
                translator_credits: _('translator-credits'),
                version: gsconnect.metadata.version.toString(),
                website: gsconnect.metadata.url,
                license_type: Gtk.License.GPL_2_0,
                modal: true,
                transient_for: this
            });

            // Persist
            this._about.connect('response', (dialog) => dialog.hide_on_delete());
            this._about.connect('delete-event', (dialog) => dialog.hide_on_delete());
        }

        this._about.present();
    }

    /**
     * Connect to..." Dialog
     */
    _connectDialog() {
        new ConnectDialog({
            application: Gio.Application.get_default(),
            modal: true,
            transient_for: this
        });
    }

    /**
     * "Generate Support Log" GAction
     */
    _generateSupportLog() {
        let dialog = new Gtk.MessageDialog({
            text: _('Generate Support Log'),
            secondary_text: _('Debug messages are being logged. Take any steps necessary to reproduce a problem then review the log.')
        });
        dialog.add_button(_('Cancel'), Gtk.ResponseType.CANCEL);
        dialog.add_button(_('Review Log'), Gtk.ResponseType.OK);

        // Enable debug logging and mark the current time
        this.settings.set_boolean('debug', true);
        let now = GLib.DateTime.new_now_local().format('%R');

        dialog.connect('response', (dialog, response_id) => {
            // Disable debug logging and destroy the dialog
            this.settings.set_boolean('debug', false);
            dialog.destroy();

            // Only generate a log if instructed
            if (response_id === Gtk.ResponseType.OK) {
                generateSupportLog(now);
            }
        });

        dialog.show_all();
    }

    /**
     * "Help" GAction
     */
    _help(action, parameter) {
        let uri = 'https://github.com/andyholmes/gnome-shell-extension-gsconnect';
        uri += '/wiki/Help';
        Gio.AppInfo.launch_default_for_uri_async(uri, null, null, null);
    }

    /**
     * HeaderBar Callbacks
     */
    _onPrevious(button, event) {
        // HeaderBar (Service)
        this.prev_button.visible = false;
        this.device_menu.visible = false;

        this.service_refresh.visible = true;
        this.service_edit.visible = true;
        this.service_menu.visible = true;

        this.headerbar.title = this.settings.get_string('name');
        this.headerbar.subtitle = null;

        // Panel
        this.stack.visible_child_name = 'service';
        this._setDeviceMenu();
    }

    _onEditServiceName(button, event) {
        this.rename_entry.text = this.headerbar.title;
        this.rename_entry.has_focus = true;
    }

    _onSetServiceName(widget) {
        if (this.rename_entry.text.length) {
            this.headerbar.title = this.rename_entry.text;
            this.settings.set_string('name', this.rename_entry.text);
        }

        this.service_edit.active = false;
    }

    /**
     * Context Switcher
     */
    _getTypeLabel(device) {
        switch (device.type) {
            case 'laptop':
                return _('Laptop');
            case 'phone':
                return _('Smartphone');
            case 'tablet':
                return _('Tablet');
            case 'tv':
                return _('Television');
            default:
                return _('Desktop');
        }
    }

    _setDeviceMenu(panel = null) {
        this.device_menu.insert_action_group('device', null);
        this.device_menu.insert_action_group('settings', null);
        this.device_menu.set_menu_model(null);

        if (panel) {
            this.device_menu.insert_action_group('device', panel.device.action_group);
            this.device_menu.insert_action_group('settings', panel.actions);
            this.device_menu.set_menu_model(panel.menu);
        }
    }

    _onDeviceChanged(statusLabel, device, pspec) {
        switch (false) {
            case device.paired:
                statusLabel.label = _('Unpaired');
                break;

            case device.connected:
                statusLabel.label = _('Disconnected');
                break;

            default:
                statusLabel.label = _('Connected');
        }
    }

    _createDeviceRow(device) {
        let row = new Gtk.ListBoxRow({
            height_request: 52,
            selectable: false,
            visible: true
        });
        row.set_name(device.id);

        let grid = new Gtk.Grid({
            column_spacing: 12,
            margin_left: 20,
            margin_right: 20,
            margin_bottom: 8,
            margin_top: 8,
            visible: true
        });
        row.add(grid);

        let icon = new Gtk.Image({
            gicon: new Gio.ThemedIcon({name: device.icon_name}),
            icon_size: Gtk.IconSize.BUTTON,
            visible: true
        });
        grid.attach(icon, 0, 0, 1, 1);

        let title = new Gtk.Label({
            halign: Gtk.Align.START,
            hexpand: true,
            valign: Gtk.Align.CENTER,
            vexpand: true,
            visible: true
        });
        grid.attach(title, 1, 0, 1, 1);

        let status = new Gtk.Label({
            halign: Gtk.Align.END,
            hexpand: true,
            valign: Gtk.Align.CENTER,
            vexpand: true,
            visible: true
        });
        grid.attach(status, 2, 0, 1, 1);

        // Keep name up to date
        device.bind_property(
            'name',
            title,
            'label',
            GObject.BindingFlags.SYNC_CREATE
        );

        // Keep status up to date
        device.connect(
            'notify::connected',
            this._onDeviceChanged.bind(null, status)
        );
        device.connect(
            'notify::paired',
            this._onDeviceChanged.bind(null, status)
        );
        this._onDeviceChanged(status, device, null);

        return row;
    }

    _onDeviceAdded(service, device) {
        try {
            if (!this.stack.get_child_by_name(device.id)) {
                // Add the device preferences
                let prefs = new Device.DevicePreferences(device);
                this.stack.add_titled(prefs, device.id, device.name);

                // Add a row to the device list
                prefs.row = this._createDeviceRow(device);
                this.device_list.add(prefs.row);
            }
        } catch (e) {
            logError (e);
        }
    }

    _onDeviceRemoved(service, device) {
        try {
            let prefs = this.stack.get_child_by_name(device.id);

            if (prefs !== null) {
                if (prefs === this.stack.get_visible_child()) {
                    this._onPrevious();
                }

                prefs.row.destroy();
                prefs.row = null;

                prefs.dispose();
                prefs.destroy();
            }
        } catch (e) {
            logError (e);
        }
    }

    _onDeviceSelected(box, row) {
        try {
            if (row === null) {
                this._onPrevious();
                return;
            }

            // Transition the panel
            let name = row.get_name();
            let prefs = this.stack.get_child_by_name(name);

            this.stack.visible_child = prefs;
            this._setDeviceMenu(prefs);

            // HeaderBar (Device)
            this.service_refresh.visible = false;
            this.service_edit.visible = false;
            this.service_menu.visible = false;

            this.prev_button.visible = true;
            this.device_menu.visible = true;

            this.headerbar.title = prefs.device.name;
            this.headerbar.subtitle = this._getTypeLabel(prefs.device);
        } catch (e) {
            logError(e);
        }
    }

    _onServiceChanged(service, pspec) {
        if (this.service.active) {
            this.device_list_placeholder.label = _('Searching for devices…');
        } else {
            this.device_list_placeholder.label = _('Waiting for service…');
        }
    }
});