#!/usr/bin/python3

import os
import sys
import subprocess
import gi
import threading
import shutil
import configparser
import locale

gi.require_version('Gtk', '3.0')
gi.require_version('GLib', '2.0')
gi.require_version('Gdk', '3.0')

from gi.repository import Gtk, GLib, Gdk
from locale import gettext as _

# --- Локализация ---
DOMAIN = "ovl-kiosk-gui"
LOCALE_DIR = "/usr/share/locale"

locale.bindtextdomain(DOMAIN, LOCALE_DIR)
locale.textdomain(DOMAIN)

# Путь к UI файлу
UI_FILE = "/usr/share/ovl-kiosk/ovl-kiosk.ui"

if not os.path.exists(UI_FILE):
    UI_FILE = os.path.join(os.path.dirname(__file__), "ovl-kiosk.ui")

if not os.path.exists(UI_FILE):
    print(f"ERROR: UI file not found: {UI_FILE}")
    sys.exit(1)


def get_apps():
    """
    Сканирует /usr/share/applications/*.desktop и возвращает список приложений,
    которые попадают в меню DE.

    Возвращает список кортежей (app_id, display_name):
    - app_id — имя файла без .desktop (используется в cmdline, всегда ASCII)
    - display_name — Name[<locale>] или Name (для отображения пользователю)
    """
    apps_dir = "/usr/share/applications"
    apps = []

    if not os.path.isdir(apps_dir):
        return apps

    # Определяем локаль пользователя (например, "ru" из "ru_RU.UTF-8")
    try:
        lang = locale.getlocale()[0] or ""
        lang_short = lang.split("_")[0] if lang else ""
    except Exception:
        lang_short = ""

    for filename in os.listdir(apps_dir):
        if not filename.endswith(".desktop"):
            continue

        filepath = os.path.join(apps_dir, filename)

        try:
            parser = configparser.ConfigParser(interpolation=None)
            parser.read(filepath, encoding="utf-8")

            if not parser.has_section("Desktop Entry"):
                continue

            entry = parser["Desktop Entry"]

            # Type должен быть Application
            if entry.get("Type", "").strip() != "Application":
                continue

            # NoDisplay и Hidden — не показывать
            if entry.getboolean("NoDisplay", fallback=False):
                continue
            if entry.getboolean("Hidden", fallback=False):
                continue

            # Name обязателен
            name = entry.get("Name", "").strip()
            if not name:
                continue

            # Пытаемся получить локализованное имя
            display_name = name
            if lang_short:
                local_name = entry.get(f"Name[{lang_short}]", "").strip()
                if local_name:
                    display_name = local_name

            # Exec обязателен
            if not entry.get("Exec", "").strip():
                continue

            # OnlyShowIn / NotShowIn — пока не учитываем

            # app_id = имя файла без .desktop
            app_id = filename[:-len(".desktop")]
            apps.append((app_id, display_name))

        except Exception:
            # Игнорируем битые файлы
            continue

    # Сортируем по display_name (регистронезависимо)
    apps.sort(key=lambda x: x[1].lower())
    return apps


class OvlKioskGUI:
    def __init__(self):
        self.builder = Gtk.Builder()
        self.builder.set_translation_domain(DOMAIN)
        self.builder.add_from_file(UI_FILE)
        self.builder.connect_signals(self)

        # Основные виджеты
        self.window = self.builder.get_object("window_main")
        if self.window is None:
            print("ERROR: window_main not found")
            sys.exit(1)

        self.entry_username = self.builder.get_object("entry_username")
        self.entry_password = self.builder.get_object("entry_password")
        self.entry_homes = self.builder.get_object("entry_homes")

        self.chk_panel = self.builder.get_object("chk_panel")
        self.chk_notty = self.builder.get_object("chk_notty")
        self.chk_home_preserve = self.builder.get_object("chk_home_preserve")
        self.chk_firejail = self.builder.get_object("chk_firejail")
        if self.chk_firejail:
            if shutil.which("firejail") is None:
                self.chk_firejail.set_sensitive(False)
                self.chk_firejail.set_tooltip_text(_("firejail not found"))

        self.chk_network = self.builder.get_object("chk_network")
        self.chk_prin_scan = self.builder.get_object("chk_prin_scan")
        self.services_entry = self.builder.get_object("services_entry")

        self.text_command = self.builder.get_object("text_command")
        if self.text_command is None:
            print("ERROR: text_command not found in UI")
            sys.exit(1)

        self.textbuffer_command = self.text_command.get_buffer()
        if self.textbuffer_command is None:
            print("ERROR: textbuffer_command is None")
            sys.exit(1)

        self.progress_bar = self.builder.get_object("progress_bar")
        self.label_apps_count = self.builder.get_object("label_apps_count")
        self.vbox_apps_list = self.builder.get_object("vbox_apps_list")

        self.vbox_users_list = self.builder.get_object("vbox_users_list")
        self.label_users_count = self.builder.get_object("label_users_count")
        self.btn_refresh_users = self.builder.get_object("btn_refresh_users")
        self.btn_remove_users = self.builder.get_object("btn_remove_users")

        self.btn_build = self.builder.get_object("btn_build")
        self.btn_terminal = self.builder.get_object("btn_terminal")
        self.btn_cancel = self.builder.get_object("btn_cancel")
        self.btn_select_all = self.builder.get_object("btn_select_all")
        self.btn_clear_all = self.builder.get_object("btn_clear_all")
        self.btn_refresh_apps = self.builder.get_object("btn_refresh_apps")
        self.btn_update_command = self.builder.get_object("btn_update_command")
        self.btn_copy_command = self.builder.get_object("btn_copy_command")

        self.build_running = False
        self.process = None

        self.window.show_all()

        self.refresh_apps()
        self.update_apps_count()
        self.refresh_users()

        self.entry_username.connect("changed", lambda w: self.generate_command())
        self.entry_password.connect("changed", lambda w: self.generate_command())
        self.entry_homes.connect("changed", lambda w: self.generate_command())

        for chk in [self.chk_panel, self.chk_notty, self.chk_home_preserve,
                    self.chk_firejail, self.chk_network, self.chk_prin_scan]:
            if chk:
                chk.connect("toggled", self.on_any_toggled)

        if self.services_entry:
            self.services_entry.connect("changed", lambda w: self.generate_command())

        self.generate_command()

    # ============ Обработчики сигналов ============

    def on_window_destroy(self, widget):
        Gtk.main_quit()

    def on_cancel_clicked(self, widget):
        Gtk.main_quit()

    def on_select_all_clicked(self, widget):
        if not self.vbox_apps_list:
            return
        for child in self.vbox_apps_list.get_children():
            if isinstance(child, Gtk.Box):
                for chk in child.get_children():
                    if isinstance(chk, Gtk.CheckButton):
                        name = chk.get_name()
                        if name and name.endswith("_enable"):
                            chk.set_active(True)
                            break
        self.update_apps_count()
        self.generate_command()

    def on_clear_all_clicked(self, widget):
        if not self.vbox_apps_list:
            return
        for child in self.vbox_apps_list.get_children():
            if isinstance(child, Gtk.Box):
                for chk in child.get_children():
                    if isinstance(chk, Gtk.CheckButton):
                        chk.set_active(False)
        self.update_apps_count()
        self.generate_command()

    def on_refresh_apps_clicked(self, widget):
        self.refresh_apps()
        self.update_apps_count()
        self.generate_command()

    def on_update_command_clicked(self, widget):
        self.generate_command()

    def on_copy_command_clicked(self, widget):
        if not self.textbuffer_command:
            return
        clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
        text = self.textbuffer_command.get_text(
            self.textbuffer_command.get_start_iter(),
            self.textbuffer_command.get_end_iter(),
            False
        )
        clipboard.set_text(text, -1)
        self.show_notification(_("Command copied to clipboard"))

    def on_terminal_clicked(self, widget):
        if self.build_running:
            self.show_dialog(_("Information"), _("Build is already running"))
            return

        if not self.textbuffer_command:
            self.show_dialog(_("Error"), _("textbuffer_command is not initialized"), mtype='error')
            return

        command = self.textbuffer_command.get_text(
            self.textbuffer_command.get_start_iter(),
            self.textbuffer_command.get_end_iter(),
            False
        )
        if not command.strip():
            self.show_dialog(_("Error"), _("Command is not generated"), mtype='error')
            return

        inner = command + "; exec bash"

        # Определяем доступный терминал
        terminals = [
            ("x-terminal-emulator", ["-e", "bash", "-c", inner]),
            ("konsole", ["-e", "bash", "-c", inner]),
            ("gnome-terminal", ["--", "bash", "-c", inner]),
            ("xfce4-terminal", ["-e", "bash", "-c", inner]),
            ("xterm", ["-e", "bash", "-c", inner]),
        ]

        for term, args in terminals:
            try:
                subprocess.Popen([term] + args)
                return
            except FileNotFoundError:
                continue

        self.show_dialog(_("Error"), _("Terminal not found"), mtype='error')

    def on_build_clicked(self, widget):
        if self.build_running:
            self.show_dialog(_("Information"), _("Build is already running"))
            return

        if not self.textbuffer_command:
            self.show_dialog(_("Error"), _("textbuffer_command is not initialized"), mtype='error')
            return

        command = self.textbuffer_command.get_text(
            self.textbuffer_command.get_start_iter(),
            self.textbuffer_command.get_end_iter(),
            False
        )
        if not command.strip():
            self.show_dialog(_("Error"), _("Command is not generated"), mtype='error')
            return

        self.build_running = True
        self.progress_bar.set_visible(True)
        self.progress_bar.set_text(_("Building image..."))
        self.progress_bar.set_fraction(0.0)
        self.btn_build.set_sensitive(False)
        self.btn_terminal.set_sensitive(False)

        threading.Thread(target=self.run_build, args=(command,), daemon=True).start()

    def on_any_toggled(self, widget):
        self.generate_command()

    def on_app_toggled(self, widget):
        """Обработчик изменения чекбокса приложения"""
        parent_box = widget.get_parent()
        if not isinstance(parent_box, Gtk.Box):
            self.update_apps_count()
            self.generate_command()
            return

        chk_enable = None
        chk_autostart = None
        chk_desktop = None

        for child in parent_box.get_children():
            if isinstance(child, Gtk.CheckButton):
                name = child.get_name()
                if name and name.endswith("_enable"):
                    chk_enable = child
                elif name and name.endswith("_autostart"):
                    chk_autostart = child
                elif name and name.endswith("_desktop"):
                    chk_desktop = child

        # Если включили Autostart — снимаем его у всех остальных
        if widget == chk_autostart and widget.get_active():
            for other_child in self.vbox_apps_list.get_children():
                if not isinstance(other_child, Gtk.Box):
                    continue
                for w in other_child.get_children():
                    if isinstance(w, Gtk.CheckButton):
                        n = w.get_name()
                        if n and n.endswith("_autostart") and w != widget:
                            w.set_active(False)

        if widget == chk_enable:
            if not chk_enable.get_active():
                if chk_autostart:
                    chk_autostart.set_active(False)
                if chk_desktop:
                    chk_desktop.set_active(False)

        if widget == chk_autostart or widget == chk_desktop:
            if widget.get_active():
                if chk_enable:
                    chk_enable.set_active(True)

        self.update_apps_count()
        self.generate_command()

    # ============ Вкладка Users ============

    def refresh_users(self):
        """Обновить список пользователей киоска из /var/kiosk/"""
        if not self.vbox_users_list:
            return

        # Очищаем текущий список
        for child in self.vbox_users_list.get_children():
            self.vbox_users_list.remove(child)

        # Сканируем /var/kiosk/*.xzm
        kiosk_dir = "/var/kiosk"
        users = []
        try:
            for name in sorted(os.listdir(kiosk_dir)):
                if name.endswith(".xzm"):
                    users.append(name[:-4])
        except FileNotFoundError:
            pass
        except PermissionError:
            pass

        # Добавляем пользователей в список
        for user in users:
            hbox = Gtk.Box(spacing=12)
            hbox.set_visible(True)

            label = Gtk.Label(label=user)
            label.set_xalign(0)
            label.set_visible(True)
            hbox.pack_start(label, True, True, 0)

            chk = Gtk.CheckButton(label=_("Remove"))
            chk.set_active(False)
            chk.set_visible(True)
            chk.set_name(f"chk_user_{user}")
            chk.connect("toggled", self.on_user_toggled)
            hbox.pack_start(chk, False, False, 0)

            self.vbox_users_list.pack_start(hbox, False, True, 0)

        self.vbox_users_list.show_all()
        self.update_users_count()

    def update_users_count(self):
        """Обновить счётчик выбранных пользователей и состояние кнопки удаления"""
        if not self.vbox_users_list:
            return

        count = 0
        for child in self.vbox_users_list.get_children():
            if isinstance(child, Gtk.Box):
                for chk in child.get_children():
                    if isinstance(chk, Gtk.CheckButton) and chk.get_name() and chk.get_name().startswith("chk_user_"):
                        if chk.get_active():
                            count += 1
                        break

        if self.label_users_count:
            self.label_users_count.set_text(_("Selected: %d") % count)

        if self.btn_remove_users:
            self.btn_remove_users.set_sensitive(count > 0)

    def on_refresh_users_clicked(self, widget):
        """Обновить список пользователей"""
        self.refresh_users()

    def on_user_toggled(self, widget):
        """Обработчик изменения чекбокса пользователя"""
        self.update_users_count()

    def on_remove_users_clicked(self, widget):
        """Удалить выбранных пользователей"""
        if not self.vbox_users_list:
            return

        # Собираем выбранных пользователей
        selected = []
        for child in self.vbox_users_list.get_children():
            if not isinstance(child, Gtk.Box):
                continue

            label = None
            chk = None
            for w in child.get_children():
                if isinstance(w, Gtk.Label):
                    label = w.get_text()
                elif isinstance(w, Gtk.CheckButton):
                    chk = w

            if label and chk and chk.get_active():
                selected.append(label)

        if not selected:
            self.show_dialog(_("Error"), _("No users selected"), mtype='error')
            return

        # Подтверждение
        users_str = ", ".join(selected)
        result = self.show_dialog(
            _("Confirmation"),
            _("Remove the following kiosk users:\n\n%s\n\n"
              "Modules, saves and GRUB entries will be removed.") % users_str,
            mtype='question',
            btn=[Gtk.STOCK_YES, Gtk.ResponseType.YES,
                 Gtk.STOCK_NO, Gtk.ResponseType.NO]
        )

        if result != Gtk.ResponseType.YES:
            return

        # Показываем прогресс-бар
        self.progress_bar.set_visible(True)
        self.progress_bar.set_text(_("Removing users..."))
        self.progress_bar.set_fraction(0.0)
        self.btn_remove_users.set_sensitive(False)

        # Запускаем удаление в отдельном потоке
        threading.Thread(
            target=self.run_remove_users,
            args=(selected,),
            daemon=True
        ).start()

    def run_remove_users(self, users):
        """Запуск удаления пользователей в отдельном потоке"""
        log_file = "/tmp/ovl-kiosk-remove.log"
        output_lines = []

        try:
            cmd = ["ovl-kiosk-remove"] + users
            self.process = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                bufsize=1,
                universal_newlines=True
            )

            with open(log_file, "w") as log:
                for line in iter(self.process.stdout.readline, ''):
                    if not line:
                        break
                    line = line.strip()
                    if line:
                        output_lines.append(line)
                        log.write(line + "\n")
                        log.flush()
                        GLib.idle_add(self.update_progress, line)

            self.process.wait()

            if self.process.returncode == 0:
                GLib.idle_add(self.remove_users_finished, True, "\n".join(output_lines))
            else:
                GLib.idle_add(self.remove_users_finished, False, "\n".join(output_lines))

        except Exception as e:
            GLib.idle_add(self.remove_users_finished, False, str(e))

    def remove_users_finished(self, success, output):
        """Завершение удаления пользователей"""
        self.process = None

        self.progress_bar.set_visible(False)
        self.btn_remove_users.set_sensitive(False)

        log_file = "/tmp/ovl-kiosk-remove.log"

        if success:
            self.show_dialog(_("Success"), _("Selected users removed"))
            self.refresh_users()
        else:
            msg = _("Removal failed.") + "\n"
            msg += _("Full log saved to: %s") % log_file + "\n"
            if output:
                msg += "\n..." + output[-500:]

            self.show_dialog(_("Error"), msg, mtype='error')
            self.refresh_users()

    # ============ Основные функции ============

    def refresh_apps(self):
        """Обновить список приложений"""
        TOP_APPS = [
            "chromium-browser",
            "firefox",
            "libreoffice-writer",
            "libreoffice-calc",
        ]

        ALL_APPS = get_apps()  # [(app_id, display_name), ...]

        # Сортируем: сначала топ-приложения (в порядке TOP_APPS), затем остальные
        sorted_apps = []
        top_ids = set()

        for top in TOP_APPS:
            for app_id, display_name in ALL_APPS:
                if app_id == top:
                    sorted_apps.append((app_id, display_name))
                    top_ids.add(app_id)
                    break

        for app_id, display_name in ALL_APPS:
            if app_id not in top_ids:
                sorted_apps.append((app_id, display_name))

        # Определяем приложение по умолчанию
        default_app = None
        for top in TOP_APPS:
            for app_id, display_name in sorted_apps:
                if app_id == top:
                    default_app = app_id
                    break
            if default_app:
                break

        if default_app is None and sorted_apps:
            default_app = sorted_apps[0][0]

        # Очищаем список
        for child in self.vbox_apps_list.get_children():
            self.vbox_apps_list.remove(child)

        # Добавляем приложения
        for app_id, display_name in sorted_apps:
            hbox = Gtk.Box(spacing=12)
            hbox.set_visible(True)

            label = Gtk.Label(label=display_name)
            label.set_xalign(0)
            label.set_visible(True)
            label.set_tooltip_text(app_id)
            hbox.pack_start(label, True, True, 0)

            chk_enable = Gtk.CheckButton(label=_("Keep"))
            chk_enable.set_active(app_id == default_app)
            chk_enable.set_visible(True)
            chk_enable.set_name(f"chk_{app_id}_enable")
            chk_enable.connect("toggled", self.on_app_toggled)
            hbox.pack_start(chk_enable, False, False, 0)

            chk_autostart = Gtk.CheckButton(label=_("Autostart"))
            chk_autostart.set_active(False)
            chk_autostart.set_visible(True)
            chk_autostart.set_name(f"chk_{app_id}_autostart")
            chk_autostart.connect("toggled", self.on_app_toggled)
            hbox.pack_start(chk_autostart, False, False, 0)

            chk_desktop = Gtk.CheckButton(label=_("Desktop"))
            chk_desktop.set_active(app_id == default_app)
            chk_desktop.set_visible(True)
            chk_desktop.set_name(f"chk_{app_id}_desktop")
            chk_desktop.connect("toggled", self.on_app_toggled)
            hbox.pack_start(chk_desktop, False, False, 0)

            self.vbox_apps_list.pack_start(hbox, False, True, 0)

        self.vbox_apps_list.show_all()
        self.update_apps_count()
        self.generate_command()

    def run_build(self, command):
        """Запуск сборки в отдельном потоке"""
        log_file = "/tmp/ovl-kiosk-build.log"
        output_lines = []

        try:
            self.process = subprocess.Popen(
                command,
                shell=True,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                bufsize=1,
                universal_newlines=True
            )

            with open(log_file, "w") as log:
                for line in iter(self.process.stdout.readline, ''):
                    if not line:
                        break
                    line = line.strip()
                    if line:
                        output_lines.append(line)
                        log.write(line + "\n")
                        log.flush()
                        GLib.idle_add(self.update_progress, line)

            self.process.wait()

            if self.process.returncode == 0:
                GLib.idle_add(self.build_finished, True, "\n".join(output_lines))
            else:
                GLib.idle_add(self.build_finished, False, "\n".join(output_lines))

        except Exception as e:
            GLib.idle_add(self.build_finished, False, str(e))

    def update_progress(self, line):
        """Обновление прогресс-бара из меток PROGRESS:дробь:текст"""
        if not self.progress_bar:
            return False

        if line.startswith("PROGRESS:"):
            parts = line.split(":", 2)
            if len(parts) >= 3:
                try:
                    fraction = float(parts[1])
                    text = parts[2]
                    self.progress_bar.set_text(text)
                    self.progress_bar.set_fraction(fraction)
                except ValueError:
                    pass

        return False

    def build_finished(self, success, output):
        """Завершение сборки"""
        self.build_running = False
        self.process = None

        self.progress_bar.set_visible(False)
        self.btn_build.set_sensitive(True)
        self.btn_terminal.set_sensitive(True)
        
        # Переименовываем кнопку Отмена в Выход
        self.btn_cancel.set_label(_("Exit"))

        log_file = "/tmp/ovl-kiosk-build.log"

        if success:
            kiosk_user = self.entry_username.get_text().strip() or "kiosk"
            msg = _("Image built successfully.") + "\n\n"
            msg += _("You can now reboot the machine\n"
                     "and select - \"Kiosk: %s\"\n" 
                     "in the boot loader menu.") % kiosk_user
            self.show_dialog(_("Success"), msg)
            self.refresh_users()
        else:
            msg = _("Build failed.") + "\n"
            msg += _("Full log saved to: %s") % log_file + "\n"
            if output:
                msg += "\n..." + output[-500:]

            self.show_dialog(_("Error"), msg, mtype='error')

    def update_apps_count(self):
        """Обновить счетчик выбранных приложений"""
        if not self.vbox_apps_list or not self.label_apps_count:
            return

        count = 0
        for child in self.vbox_apps_list.get_children():
            if isinstance(child, Gtk.Box):
                for chk in child.get_children():
                    if isinstance(chk, Gtk.CheckButton):
                        name = chk.get_name()
                        if name and name.endswith("_enable"):
                            if chk.get_active():
                                count += 1
                            break
        self.label_apps_count.set_text(_("Selected: %d") % count)

    def generate_command(self):
        """Генерация команды из GUI"""
        if not self.textbuffer_command:
            return

        username = self.entry_username.get_text().strip()
        password = self.entry_password.get_text().strip()
        homes = self.entry_homes.get_text().strip()

        panel = "yes" if self.chk_panel.get_active() else "no"
        notty = "yes" if self.chk_notty.get_active() else "no"
        preserve = "yes" if self.chk_home_preserve.get_active() else "no"
        firejail = "yes" if self.chk_firejail.get_active() else "no"

        # Сбор приложений
        kiosk_apps = []       # для KIOSK_APPS (Desktop)
        autostart_app = None  # для KIOSK_AUTOSTART
        keep_only_apps = []   # позиционные параметры (только Keep)

        if self.vbox_apps_list:
            for child in self.vbox_apps_list.get_children():
                if not isinstance(child, Gtk.Box):
                    continue

                chk_enable = None
                chk_autostart = None
                chk_desktop = None

                for widget in child.get_children():
                    if isinstance(widget, Gtk.CheckButton):
                        name = widget.get_name()
                        if name and name.endswith("_enable"):
                            chk_enable = widget
                        elif name and name.endswith("_autostart"):
                            chk_autostart = widget
                        elif name and name.endswith("_desktop"):
                            chk_desktop = widget

                if chk_enable and chk_enable.get_active():
                    # Извлекаем app_id из имени виджета: chk_<app_id>_enable
                    name = chk_enable.get_name()
                    app_id = name[len("chk_"):-len("_enable")]

                    has_autostart = chk_autostart and chk_autostart.get_active()
                    has_desktop = chk_desktop and chk_desktop.get_active()

                    if has_autostart:
                        autostart_app = app_id

                    if has_desktop:
                        kiosk_apps.append(app_id)

                    if not has_autostart and not has_desktop:
                        keep_only_apps.append(app_id)

        # Сбор сервисов для маскировки
        masked_services = []

        # Сеть — если чекбокс «Disable networking» включён, маскируем NetworkManager
        if self.chk_network and self.chk_network.get_active():
            masked_services.extend(["NetworkManager", "NetworkManager-dispatcher"])

        # Печать/сканирование
        if self.chk_prin_scan and self.chk_prin_scan.get_active():
            masked_services.extend(["cups", "cups-browsed", "saned"])

        # Дополнительные сервисы из поля ввода
        if self.services_entry:
            extra = self.services_entry.get_text().strip()
            if extra:
                masked_services.extend(extra.split())

        # Формируем команду
        cmd_parts = []
        if username:
            cmd_parts.append(f'KIOSK_USER="{username}"')
        if password:
            cmd_parts.append(f'KIOSK_PASSWD="{password}"')
        if homes:
            cmd_parts.append(f'KIOSK_HOMES="{homes}"')

        cmd_parts.append(f'KIOSK_PANEL={panel}')
        cmd_parts.append(f'KIOSK_NOTTY={notty}')
        cmd_parts.append(f'KIOSK_HOME_PRESERVE={preserve}')
        cmd_parts.append(f'KIOSK_FIREJAIL={firejail}')

        if masked_services:
            cmd_parts.append(f'KIOSK_MASKED_SERVICES="{" ".join(masked_services)}"')

        if autostart_app:
            cmd_parts.append(f'KIOSK_AUTOSTART={autostart_app}')

        if kiosk_apps:
            cmd_parts.append(f'KIOSK_APPS="{" ".join(kiosk_apps)}"')

        # Добавляем ovl-kiosk
        cmd_parts.append("ovl-kiosk")

        # Позиционные параметры — только Keep (без Autostart и Desktop)
        if keep_only_apps:
            cmd_parts.append(" ".join(keep_only_apps))

        command = " \\\n".join(cmd_parts)
        self.textbuffer_command.set_text(command)

    # ============ Вспомогательные функции ============

    def show_dialog(self, first=_('Warning!'), second=None, mtype='info',
                    btn=None, entry=False, passwd=False, above=True):
        """Диалоговое окно по принципу updaterlib.dialog"""
        if mtype == 'info':
            mtype = Gtk.MessageType.INFO
        elif mtype == 'error':
            mtype = Gtk.MessageType.ERROR
        elif mtype == 'warning':
            mtype = Gtk.MessageType.WARNING
        elif mtype == 'question':
            mtype = Gtk.MessageType.QUESTION

        # Кнопки по умолчанию — OK
        if btn is None:
            btn = [Gtk.STOCK_OK, Gtk.ResponseType.OK]

        messagedialog = Gtk.MessageDialog(
            transient_for=self.window,
            destroy_with_parent=True,
            modal=True,
            message_type=mtype,
            buttons=Gtk.ButtonsType.NONE,
            text=first
        )
        messagedialog.set_keep_above(above)
        messagedialog.set_skip_taskbar_hint(True)
        messagedialog.set_skip_pager_hint(True)
        messagedialog.set_decorated(True)

        if second:
            messagedialog.format_secondary_text(second)

        text = None
        msgEntry = None

        if entry:
            dialogBox = messagedialog.get_content_area()
            msgEntry = Gtk.Entry()
            if passwd:
                msgEntry.set_visibility(False)
                msgEntry.set_invisible_char("*")
            msgEntry.set_margin_start(20)
            msgEntry.set_margin_end(20)
            msgEntry.set_margin_bottom(10)
            dialogBox.pack_end(msgEntry, False, False, 0)
            msgEntry.set_activates_default(True)

        # Кнопки
        buttons = []
        for i, (label, response_id) in enumerate(zip(btn[::2], btn[1::2])):
            button = messagedialog.add_button(label, response_id)
            buttons.append(button)
            if i == 0:
                button.set_can_default(True)
                button.grab_default()

        messagedialog.set_default_response(btn[1])

        messagedialog.show_all()
        if entry and msgEntry:
            msgEntry.grab_focus()

        response = messagedialog.run()

        if entry and msgEntry:
            text = msgEntry.get_text()

        messagedialog.destroy()

        if text is not None and text != '':
            return text
        if response == Gtk.ResponseType.OK:
            return True
        elif response == Gtk.ResponseType.CANCEL or response == Gtk.ResponseType.DELETE_EVENT:
            return False
        else:
            return response

    def show_notification(self, message):
        """Показать уведомление"""
        try:
            subprocess.run(["notify-send", "ovl-kiosk", message], check=False)
        except:
            print(f"Notify: {message}")


def main():
    app = OvlKioskGUI()
    Gtk.main()


if __name__ == "__main__":
    main()
    
