#!/usr/bin/env python3
"""
Окно для zapret.py (GTK 3): включить/выключить, стратегия, автозапуск, подбор, обновление.

    python3 zapret-gui.py       без sudo; пароль спросит система при первом действии

Само обходом не занимается: действия выполняет /opt/zapret-discord-youtube/zapret.py через pkexec.
Если zapret ещё не установлен — берёт zapret.py рядом с собой или скачивает с сайта и ставит.
"""
import importlib.util
import os
import re
import subprocess
import sys
import threading
import urllib.request

try:
    import gi
    gi.require_version("Gtk", "3.0")
    from gi.repository import GLib, Gtk, Pango
except (ImportError, ValueError):
    sys.exit("Нужен GTK: sudo apt install python3-gi gir1.2-gtk-3.0")

INSTALLED = "/opt/zapret-discord-youtube/zapret.py"
SITE = "https://emptyprojects.pro/zapret-gui/zapret.py"
API = 2   # какая версия zapret.py нужна окну (строка API = N в zapret.py)
HERE = os.path.dirname(os.path.abspath(__file__))
CACHE = os.path.expanduser("~/.cache/zapret-gui")
DESKTOP = os.path.expanduser("~/.local/share/applications/zapret-gui.desktop")


def api_of(path):
    try:
        m = re.search(r"^API = (\d+)", open(path, encoding="utf-8").read(), re.M)
        return int(m.group(1)) if m else 0
    except OSError:
        return 0


def load_backend():
    spec = importlib.util.spec_from_file_location("zapret", INSTALLED)
    mod = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(mod)
    return mod


def fresh_backend():
    """zapret.py для установки: рядом с окном или с сайта."""
    near = os.path.join(HERE, "zapret.py")
    if api_of(near) >= API:
        return near
    os.makedirs(CACHE, exist_ok=True)
    path = os.path.join(CACHE, "zapret.py")
    urllib.request.urlretrieve(SITE, path)
    if api_of(path) < API:
        raise RuntimeError("На сайте старая версия zapret.py")
    return path


def privileged(*args):
    """Код возврата и текст ошибки. 126/127 — пароль не ввели."""
    p = subprocess.run(["pkexec"] + list(args), capture_output=True, text=True)
    lines = [l for l in (p.stderr or p.stdout).splitlines() if l.strip()]
    return p.returncode, lines[-1] if lines else ""


def write_desktop():
    text = f"""[Desktop Entry]
Type=Application
Name=Zapret
Comment=Обход блокировок Discord и YouTube
Exec=/usr/bin/python3 "{os.path.abspath(__file__)}"
Icon=network-vpn
Terminal=false
Categories=Network;
"""
    try:
        if not os.path.exists(DESKTOP) or open(DESKTOP).read() != text:
            os.makedirs(os.path.dirname(DESKTOP), exist_ok=True)
            with open(DESKTOP, "w") as f:
                f.write(text)
    except OSError:
        pass


class Window(Gtk.Window):
    def __init__(self):
        super().__init__(title="Zapret")
        self.set_default_size(540, 640)
        self.z = None
        self.busy = False
        self.syncing = False
        self.test_proc = None
        self.best = None

        hb = Gtk.HeaderBar(title="Zapret", subtitle="Discord и YouTube", show_close_button=True)
        self.update_btn = Gtk.Button.new_from_icon_name("view-refresh-symbolic", Gtk.IconSize.BUTTON)
        self.update_btn.set_tooltip_text("Обновить zapret (стратегии и nfqws)")
        self.update_btn.connect("clicked", self.on_update)
        hb.pack_end(self.update_btn)
        self.set_titlebar(hb)

        self.stack = Gtk.Stack(transition_type=Gtk.StackTransitionType.CROSSFADE)
        self.stack.add_named(self.build_setup(), "setup")
        self.stack.add_named(self.build_main(), "main")
        self.add(self.stack)

        self.connect("delete-event", self.on_close)
        self.show_all()
        self.progress.hide()
        self.best_box.hide()
        self.check_installed()
        GLib.timeout_add_seconds(2, self.refresh)

    # --- экраны ---

    def build_setup(self):
        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=14, margin=40, valign=Gtk.Align.CENTER)
        title = Gtk.Label()
        title.set_markup("<span size='x-large' weight='bold'>zapret ещё не установлен</span>")
        text = Gtk.Label(wrap=True, justify=Gtk.Justification.CENTER, label=(
            "Скачаю стратегии zapret-discord-youtube и nfqws в /opt/zapret-discord-youtube. "
            "Система спросит пароль."))
        self.setup_btn = Gtk.Button(label="Установить")
        self.setup_btn.get_style_context().add_class("suggested-action")
        self.setup_btn.set_halign(Gtk.Align.CENTER)
        self.setup_btn.connect("clicked", self.on_setup)
        self.setup_spinner = Gtk.Spinner()
        self.setup_msg = Gtk.Label(wrap=True, selectable=True)
        for w in (title, text, self.setup_btn, self.setup_spinner, self.setup_msg):
            box.pack_start(w, False, False, 0)
        return box

    def build_main(self):
        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12, margin=18)

        status = Gtk.Box(spacing=14)
        self.dot = Gtk.Label()
        texts = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2, valign=Gtk.Align.CENTER)
        self.state_title = Gtk.Label(xalign=0)
        self.state_sub = Gtk.Label(xalign=0, ellipsize=Pango.EllipsizeMode.END)
        self.state_sub.get_style_context().add_class("dim-label")
        texts.pack_start(self.state_title, False, False, 0)
        texts.pack_start(self.state_sub, False, False, 0)
        status.pack_start(self.dot, False, False, 0)
        status.pack_start(texts, True, True, 0)
        box.pack_start(status, False, False, 4)

        row = Gtk.Box(spacing=10)
        row.pack_start(Gtk.Label(label="Стратегия"), False, False, 0)
        self.combo = Gtk.ComboBoxText()
        self.combo.connect("changed", lambda *_: self.update_buttons())
        row.pack_start(self.combo, True, True, 0)
        box.pack_start(row, False, False, 0)

        self.toggle_btn = Gtk.Button()
        self.toggle_btn.set_size_request(-1, 44)
        self.toggle_btn.connect("clicked", self.on_toggle)
        box.pack_start(self.toggle_btn, False, False, 0)

        row = Gtk.Box(spacing=10)
        row.pack_start(Gtk.Label(label="Запускать при загрузке системы", xalign=0), True, True, 0)
        self.autostart = Gtk.Switch()
        self.autostart.connect("notify::active", self.on_autostart)
        row.pack_start(self.autostart, False, False, 0)
        box.pack_start(row, False, False, 0)

        box.pack_start(Gtk.Separator(), False, False, 6)

        row = Gtk.Box(spacing=10)
        texts = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
        head = Gtk.Label(xalign=0)
        head.set_markup("<b>Подбор стратегии</b>")
        desc = Gtk.Label(xalign=0, wrap=True, label="По очереди включит каждую и проверит Discord, YouTube, Google и Cloudflare. "
                                                     "Займёт несколько минут.")
        desc.get_style_context().add_class("dim-label")
        texts.pack_start(head, False, False, 0)
        texts.pack_start(desc, False, False, 0)
        row.pack_start(texts, True, True, 0)
        self.test_btn = Gtk.Button(label="Подобрать", valign=Gtk.Align.CENTER)
        self.test_btn.connect("clicked", self.on_test)
        row.pack_start(self.test_btn, False, False, 0)
        box.pack_start(row, False, False, 0)

        self.progress = Gtk.ProgressBar(show_text=True)
        box.pack_start(self.progress, False, False, 0)

        # стратегия, «12/36», «16/16», сортировочный ключ
        self.results = Gtk.ListStore(str, str, str, int)
        self.results.set_sort_column_id(3, Gtk.SortType.DESCENDING)
        view = Gtk.TreeView(model=self.results)
        for i, title in enumerate(("Стратегия", "Сайты", "Ping")):
            col = Gtk.TreeViewColumn(title, Gtk.CellRendererText(), text=i)
            col.set_expand(i == 0)
            view.append_column(col)
        scroll = Gtk.ScrolledWindow(vexpand=True)
        scroll.set_shadow_type(Gtk.ShadowType.IN)
        scroll.add(view)
        box.pack_start(scroll, True, True, 0)

        self.best_box = Gtk.Box(spacing=10)
        self.best_label = Gtk.Label(xalign=0, wrap=True)
        self.best_btn = Gtk.Button(label="Включить её")
        self.best_btn.get_style_context().add_class("suggested-action")
        self.best_btn.connect("clicked", self.on_best)
        self.best_box.pack_start(self.best_label, True, True, 0)
        self.best_box.pack_start(self.best_btn, False, False, 0)
        box.pack_start(self.best_box, False, False, 0)

        self.msg = Gtk.Label(xalign=0, wrap=True, selectable=True)
        self.msg.get_style_context().add_class("dim-label")
        box.pack_start(self.msg, False, False, 0)
        return box

    # --- состояние ---

    def check_installed(self):
        if api_of(INSTALLED) >= API and os.path.exists(os.path.dirname(INSTALLED) + "/bin/nfqws"):
            self.z = load_backend()
            self.fill_strategies()
            self.stack.set_visible_child_name("main")
            self.update_btn.set_sensitive(True)
            self.refresh()
        else:
            # не установлен или стоит версия без команд для окна
            self.stack.set_visible_child_name("setup")
            self.update_btn.set_sensitive(False)

    def fill_strategies(self):
        cur = self.combo.get_active_text() or self.z.service_strategy()
        self.combo.remove_all()
        names = self.z.strategies()
        for n in names:
            self.combo.append_text(n)
        self.combo.set_active(names.index(cur) if cur in names else 0)

    def systemctl(self, *args):
        return subprocess.run(["systemctl"] + list(args) + [self.z.SERVICE],
                              stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode == 0

    def refresh(self):
        if not self.z:
            return True
        self.active = self.systemctl("is-active", "--quiet")
        self.current = self.z.service_strategy()
        enabled = self.systemctl("is-enabled", "--quiet")
        testing = self.test_proc is not None
        if testing:
            color, title, sub = "#e5a50a", "Идёт подбор стратегии", "обход включается и выключается сам"
        elif self.active:
            color, title, sub = "#2ec27e", "Обход работает", self.current
        else:
            color, title, sub = "#9a9996", "Обход выключен", "выберите стратегию и нажмите «Включить»"
        self.dot.set_markup(f"<span size='xx-large' foreground='{color}'>●</span>")
        self.state_title.set_markup(f"<span size='large' weight='bold'>{title}</span>")
        self.state_sub.set_text(sub or "")
        self.syncing = True
        self.autostart.set_active(enabled)
        self.syncing = False
        self.update_buttons()
        return True

    def update_buttons(self):
        if not self.z:
            return
        active = getattr(self, "active", False)
        same = self.combo.get_active_text() == getattr(self, "current", None)
        ctx = self.toggle_btn.get_style_context()
        ctx.remove_class("suggested-action")
        ctx.remove_class("destructive-action")
        if active and same:
            self.toggle_btn.set_label("Выключить")
            ctx.add_class("destructive-action")
        else:
            self.toggle_btn.set_label("Переключить на эту стратегию" if active else "Включить")
            ctx.add_class("suggested-action")
        idle = not self.busy and self.test_proc is None
        for w in (self.toggle_btn, self.autostart, self.combo, self.update_btn, self.best_btn):
            w.set_sensitive(idle)
        self.test_btn.set_sensitive(not self.busy)
        self.test_btn.set_label("Остановить" if self.test_proc else "Подобрать")

    # --- действия ---

    def run_async(self, work, done=None):
        """work() в фоне, done(result) в окне."""
        self.busy = True
        self.msg.set_text("")
        self.update_buttons()

        def thread():
            try:
                res = work()
            except Exception as e:
                res = (1, str(e))
            GLib.idle_add(finish, res)

        def finish(res):
            self.busy = False
            code, text = res
            if code in (126, 127):
                self.msg.set_text("Пароль не введён — ничего не изменилось")
            elif code != 0:
                self.msg.set_text(text or "Не получилось")
            if done:
                done(code)
            self.refresh()

        threading.Thread(target=thread, daemon=True).start()

    def on_toggle(self, _):
        name = self.combo.get_active_text()
        if self.active and name == self.current:
            self.run_async(lambda: privileged(INSTALLED, "stop"))
        elif name:
            self.run_async(lambda: privileged(INSTALLED, "start", name))

    def on_autostart(self, sw, _):
        if self.syncing:
            return
        if sw.get_active() and not self.current:
            self.msg.set_text("Сначала включите обход, потом автозапуск")
            self.refresh()
            return
        self.run_async(lambda: privileged(INSTALLED, "autostart", "on" if sw.get_active() else "off"))

    def on_update(self, _):
        def done(code):
            if code == 0:
                self.fill_strategies()
                self.msg.set_text("zapret обновлён")
        self.run_async(lambda: privileged(INSTALLED, "update"), done)

    def on_setup(self, _):
        self.setup_btn.set_sensitive(False)
        self.setup_spinner.start()
        self.setup_msg.set_text("Скачиваю…")

        def work():
            try:
                return privileged("/usr/bin/python3", fresh_backend(), "install")
            except Exception as e:
                return 1, str(e)

        def done(res):
            code, text = res
            self.setup_spinner.stop()
            self.setup_btn.set_sensitive(True)
            if code in (126, 127):
                self.setup_msg.set_text("Пароль не введён")
            elif code != 0:
                self.setup_msg.set_text(text or "Не получилось")
            else:
                self.setup_msg.set_text("")
                self.check_installed()

        threading.Thread(target=lambda: GLib.idle_add(done, work()), daemon=True).start()

    # --- подбор ---

    def on_test(self, _):
        if self.test_proc:
            self.stop_test()
            return
        self.results.clear()
        self.best_box.hide()
        self.msg.set_text("")
        self.progress.set_fraction(0)
        self.progress.set_text("Жду пароль…")
        self.progress.show()
        self.test_proc = subprocess.Popen(["pkexec", INSTALLED, "test", "--batch"], stdin=subprocess.PIPE,
                                          stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1)
        self.refresh()
        threading.Thread(target=self.read_test, args=(self.test_proc,), daemon=True).start()

    def stop_test(self):
        # закрытый stdin — сигнал zapret.py прервать проверку и всё выключить
        try:
            self.test_proc.stdin.close()
        except OSError:
            pass
        self.progress.set_text("Останавливаю…")

    def read_test(self, proc):
        for line in proc.stdout:
            parts = line.rstrip("\n").split("\t")
            GLib.idle_add(self.on_test_line, parts)
        err = proc.stderr.read().strip().splitlines()
        code = proc.wait()
        GLib.idle_add(self.on_test_done, code, err[-1] if err else "")

    def on_test_line(self, parts):
        kind = parts[0]
        if kind == "PROGRESS":
            i, n, name = int(parts[1]), int(parts[2]), parts[3]
            self.progress.set_fraction((i - 1) / n)
            self.progress.set_text(f"{i} из {n}: {name}")
        elif kind == "RESULT":
            name, ok, total, pings, targets = parts[1], *map(int, parts[2:6])
            if ok < 0:
                self.results.append([name, "не запустилась", "", -1])
            else:
                self.results.append([name, f"{ok} из {total}", f"{pings} из {targets}", ok * 100 + pings])
        elif kind == "BEST":
            self.best = parts[1] or None

    def on_test_done(self, code, err):
        self.test_proc = None
        self.progress.hide()
        if code in (126, 127):
            self.msg.set_text("Пароль не введён — подбор не запускался")
        elif code != 0 and err:
            self.msg.set_text(err)
        if self.best:
            self.best_label.set_markup(f"Лучшая: <b>{GLib.markup_escape_text(self.best)}</b>")
            self.best_box.show()
        elif len(self.results):
            self.msg.set_text("Ни одна стратегия не помогла. Отчёт — в папке utils/test results.")
        self.refresh()

    def on_best(self, _):
        name = self.best
        names = self.z.strategies()
        if name in names:
            self.combo.set_active(names.index(name))
        self.run_async(lambda: privileged(INSTALLED, "start", name), lambda code: code == 0 and self.best_box.hide())

    def on_close(self, *_):
        if self.test_proc:
            self.stop_test()
        Gtk.main_quit()


def main():
    write_desktop()
    Window()
    Gtk.main()


if __name__ == "__main__":
    main()
