#!/usr/bin/env python3
"""
Horizon Rustcraft Mini-Launcher
Simple, lightweight GUI launcher for Horizon (Minecraft Java Edition 26.3 in Rust).
Supports offline multiplayer/singleplayer, live server ping, and automatic client downloading/unpacking.
"""

import sys
import os
import json
import time
import socket
import struct
import re
import threading
import queue
import subprocess
import shutil
import zipfile
import urllib.request
from pathlib import Path

import tkinter as tk
from tkinter import ttk, messagebox

# Resolve base directory
if getattr(sys, "frozen", False):
    ROOT_DIR = Path(sys.executable).resolve().parent
    BUNDLE_DIR = Path(getattr(sys, "_MEIPASS", sys.executable)).resolve()
else:
    ROOT_DIR = Path(__file__).resolve().parent
    BUNDLE_DIR = ROOT_DIR

CONFIG_PATH = ROOT_DIR / "launcher_config.json"
ICON_PATH = BUNDLE_DIR / "crates" / "horizon-theme" / "icons" / "horizon-64.png"

DEFAULT_SERVERS = [
    "minecraft.tirel.top:25565",
    "10.0.1.12:25565",
    "127.0.0.1:25565"
]

DEFAULT_CONFIG = {
    "nickname": "Player",
    "password": "",
    "remember_password": True,
    "mode": "multiplayer",
    "selected_server": "minecraft.tirel.top:25565",
    "servers": DEFAULT_SERVERS,
    "fullscreen": False,
    "render_distance": 12,
    "close_on_launch": True,
    "client_url": "https://minecraft.tirel.top/client.zip",
    "skin_path": "",
    "skin_model": "classic"
}


def load_config():
    if CONFIG_PATH.is_file():
        try:
            with open(CONFIG_PATH, "r", encoding="utf-8") as f:
                data = json.load(f)
                cfg = {**DEFAULT_CONFIG, **data}
                # Миграция старых URL и IP на актуальный домен
                old_client = cfg.get("client_url", "")
                if not old_client or "share.tirel.top" in old_client or "10.0.1.12" in old_client or "213.108.173.221" in old_client:
                    cfg["client_url"] = "https://minecraft.tirel.top/client.zip"
                if cfg.get("selected_server") in ("213.108.173.221:25565", "10.0.1.12:25565"):
                    cfg["selected_server"] = "minecraft.tirel.top:25565"
                servers = cfg.get("servers", [])
                if "minecraft.tirel.top:25565" not in servers:
                    cfg["servers"] = ["minecraft.tirel.top:25565"] + [s for s in servers if s != "213.108.173.221:25565"]
                return cfg
        except Exception:
            pass
    return DEFAULT_CONFIG.copy()


def save_config(cfg):
    try:
        with open(CONFIG_PATH, "w", encoding="utf-8") as f:
            json.dump(cfg, f, indent=2, ensure_ascii=False)
    except Exception as e:
        print(f"Warning: failed to save config: {e}")


def clean_minecraft_text(text):
    if not text:
        return ""
    return re.sub(r'§[0-9a-fk-or]', '', text).strip()


def extract_motd_text(motd_obj):
    if isinstance(motd_obj, str):
        return motd_obj
    if isinstance(motd_obj, dict):
        text = motd_obj.get("text", "")
        for extra in motd_obj.get("extra", []):
            text += extract_motd_text(extra)
        return text
    if isinstance(motd_obj, list):
        return "".join(extract_motd_text(item) for item in motd_obj)
    return str(motd_obj) if motd_obj else ""


def ping_minecraft_server(host, port=25565, timeout=1.5):
    """Pings a Minecraft server using the Server List Ping protocol."""
    t0 = time.time()
    try:
        s = socket.create_connection((host, int(port)), timeout=timeout)
        host_bytes = host.encode('utf-8')
        # Handshake packet
        data = b'\x00\x89\x06' + struct.pack('>B', len(host_bytes)) + host_bytes + struct.pack('>H', int(port)) + b'\x01'
        s.sendall(struct.pack('>B', len(data)) + data)
        # Status request
        s.sendall(b'\x01\x00')

        def read_varint():
            val = 0
            for i in range(5):
                b = s.recv(1)
                if not b:
                    raise EOFError("Socket closed")
                b_val = b[0]
                val |= (b_val & 0x7F) << (7 * i)
                if not (b_val & 0x80):
                    break
            return val

        packet_len = read_varint()
        packet_id = read_varint()
        str_len = read_varint()
        res = b''
        while len(res) < str_len:
            chunk = s.recv(min(4096, str_len - len(res)))
            if not chunk:
                break
            res += chunk
        s.close()

        ping_ms = int((time.time() - t0) * 1000)
        info = json.loads(res.decode('utf-8'))
        raw_motd = info.get('description', '')
        motd = clean_minecraft_text(extract_motd_text(raw_motd))
        players = info.get('players', {})
        version = info.get('version', {}).get('name', '26.3')

        return {
            'online': True,
            'ping_ms': ping_ms,
            'motd': motd or "Minecraft Server",
            'players_online': players.get('online', 0),
            'players_max': players.get('max', 0),
            'version': version
        }
    except Exception as e:
        return {'online': False, 'error': str(e)}


def find_horizon_client():
    if sys.platform == "win32":
        candidates = [
            ROOT_DIR / "horizon-client.exe",
            ROOT_DIR / "client" / "horizon-client.exe",
            ROOT_DIR / "target" / "x86_64-pc-windows-msvc" / "fast" / "horizon-client.exe",
            ROOT_DIR / "target" / "fast" / "horizon-client.exe",
            ROOT_DIR / "target" / "release" / "horizon-client.exe",
        ]
        for c in candidates:
            if c.is_file():
                return c.resolve()
        which = shutil.which("horizon-client.exe")
        if which:
            return Path(which).resolve()
    else:
        candidates = [
            ROOT_DIR / "target" / "fast" / "horizon-client",
            ROOT_DIR / "target" / "release" / "horizon-client",
            ROOT_DIR / "horizon-client",
            ROOT_DIR / "client" / "horizon-client",
        ]
        for c in candidates:
            if c.is_file():
                return c.resolve()
        which = shutil.which("horizon-client")
        if which:
            return Path(which).resolve()
    return None


def find_resources():
    candidates = [
        ROOT_DIR / ".local" / "horizon-client" / "26.3",
        ROOT_DIR / "resources",
        ROOT_DIR / "client" / "resources",
        ROOT_DIR / "client" / ".local" / "horizon-client" / "26.3",
        ROOT_DIR / ".local" / "horizon-client",
    ]
    for c in candidates:
        if c.is_dir():
            return c.resolve()
    return None


def auto_auth_session(ctl_file, password, timeout=30):
    """
    Connects to Horizon's local control socket, monitors chat log for auth prompts,
    and automatically sends /register or /login without user intervention.
    """
    if not password:
        return

    # 1. Wait for control socket endpoint file (up to 15s)
    t0 = time.time()
    endpoint = None
    while time.time() - t0 < 15:
        if ctl_file.is_file():
            try:
                data = json.loads(ctl_file.read_text(encoding="utf-8"))
                if "port" in data and "token" in data:
                    endpoint = data
                    break
            except Exception:
                pass
        time.sleep(0.1)

    if not endpoint:
        return

    # 2. Connect to control socket
    try:
        s = socket.create_connection(("127.0.0.1", int(endpoint["port"])), timeout=4)
        s.settimeout(2.0)
        s.sendall(f"auth {endpoint['token']}\n".encode("utf-8"))

        buf = b""
        while b"\n" not in buf:
            try:
                chunk = s.recv(1024)
                if not chunk:
                    break
                buf += chunk
            except Exception:
                break
        if b'"ok":true' not in buf and b'"ok": true' not in buf:
            s.close()
            return
    except Exception:
        return

    def read_line():
        line = b""
        t_start = time.time()
        while b"\n" not in line and time.time() - t_start < 2.0:
            try:
                c = s.recv(2048)
                if not c:
                    break
                line += c
            except Exception:
                break
        return line.decode("utf-8", errors="ignore").strip()

    # 3. Poll chat-log
    auth_sent = False
    start_poll = time.time()
    try:
        while time.time() - start_poll < timeout:
            try:
                s.sendall(b"chat-log 10\n")
                resp_line = read_line()
                if resp_line:
                    resp = json.loads(resp_line)
                    chats = resp.get("chat", [])
                    full_text = " ".join(chats)

                    if (
                        "Registration successful" in full_text
                        or "Login successful" in full_text
                        or "успешно" in full_text
                        or "вошли в игру" in full_text
                    ):
                        break

                    if not auth_sent:
                        if (
                            "/register" in full_text
                            or "Please register" in full_text
                            or "зарегистрируйтесь" in full_text
                            or "Зарегистрируйтесь" in full_text
                        ):
                            s.sendall(f"chat /register {password} {password}\n".encode("utf-8"))
                            read_line()
                            auth_sent = True
                        elif (
                            "/login" in full_text
                            or "Please log in" in full_text
                            or "войдите" in full_text
                            or "Войдите" in full_text
                        ):
                            s.sendall(f"chat /login {password}\n".encode("utf-8"))
                            read_line()
                            auth_sent = True
            except Exception:
                pass
            time.sleep(0.25)
    except Exception:
        pass
    finally:
        try:
            s.close()
        except Exception:
            pass
        if ctl_file.is_file():
            try:
                ctl_file.unlink()
            except Exception:
                pass


class LauncherApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Horizon — Minecraft 26.3 Launcher")
        self.root.geometry("560x790")
        self.root.resizable(False, False)

        self.cfg = load_config()
        self.msg_queue = queue.Queue()
        self.check_queue()

        self.is_downloading = False

        self.setup_styles()
        self.setup_ui()
        self.load_icon()

        # Update initial client and server status
        self.update_client_status()
        if self.cfg.get("mode") == "multiplayer":
            self.refresh_server_status()

    def check_queue(self):
        try:
            while True:
                fn = self.msg_queue.get_nowait()
                fn()
        except queue.Empty:
            pass
        self.root.after(100, self.check_queue)

    def load_icon(self):
        icon_candidates = [
            BUNDLE_DIR / "horizon.ico",
            ROOT_DIR / "horizon.ico",
            ICON_PATH,
            ROOT_DIR / "crates" / "horizon-theme" / "icons" / "horizon-64.png",
        ]
        for p in icon_candidates:
            if p.is_file():
                try:
                    if p.suffix.lower() == ".ico" and sys.platform == "win32":
                        self.root.iconbitmap(str(p))
                        break
                    elif p.suffix.lower() == ".png":
                        self.icon_image = tk.PhotoImage(file=str(p))
                        self.root.iconphoto(True, self.icon_image)
                        break
                except Exception:
                    pass

    def setup_styles(self):
        # Modern Dark Color Palette
        self.c_bg = "#18181b"          # Zinc-900
        self.c_card = "#27272a"        # Zinc-800
        self.c_card_border = "#3f3f46" # Zinc-700
        self.c_text = "#fafafa"        # Zinc-50
        self.c_muted = "#a1a1aa"       # Zinc-400
        self.c_input_bg = "#1e1e24"    # Dark input field
        self.c_input_border = "#3f3f46"
        self.c_green = "#22c55e"       # Emerald-500
        self.c_green_hover = "#16a34a" # Emerald-600
        self.c_blue = "#3b82f6"        # Blue-500
        self.c_blue_hover = "#2563eb"
        self.c_red = "#ef4444"         # Red-500
        self.c_yellow = "#eab308"      # Yellow-500

        self.root.configure(bg=self.c_bg)

        style = ttk.Style()
        style.theme_use("clam")

        # Configure Combobox
        style.configure(
            "Dark.TCombobox",
            fieldbackground=self.c_input_bg,
            background=self.c_card_border,
            foreground="#ffffff",
            darkcolor=self.c_card_border,
            lightcolor=self.c_card_border,
            arrowcolor="#ffffff",
            padding=5
        )
        self.root.option_add("*TCombobox*Listbox.background", self.c_card)
        self.root.option_add("*TCombobox*Listbox.foreground", "#ffffff")
        self.root.option_add("*TCombobox*Listbox.selectBackground", self.c_green)
        self.root.option_add("*TCombobox*Listbox.selectForeground", "#ffffff")

        # Configure Progressbar
        style.configure(
            "Green.Horizontal.TProgressbar",
            background=self.c_green,
            troughcolor=self.c_input_bg,
            bordercolor=self.c_card_border,
            lightcolor=self.c_green,
            darkcolor=self.c_green_hover
        )

    def setup_ui(self):
        # Header
        header = tk.Frame(self.root, bg=self.c_bg)
        header.pack(fill="x", padx=20, pady=(14, 10))

        title_lbl = tk.Label(
            header,
            text="⛏ HORIZON RUSTCRAFT",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 17, "bold"),
            fg=self.c_text,
            bg=self.c_bg
        )
        title_lbl.pack(anchor="w")

        sub_lbl = tk.Label(
            header,
            text="Minecraft: Java Edition 26.3 • Native Rust Engine",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 9),
            fg=self.c_muted,
            bg=self.c_bg
        )
        sub_lbl.pack(anchor="w", pady=(1, 0))

        # Main Container
        main_frame = tk.Frame(self.root, bg=self.c_bg)
        main_frame.pack(fill="both", expand=True, padx=20)

        # 1. Profile Section
        prof_card = self.create_card(main_frame, "👤 ИГРОК И АВТОРИЗАЦИЯ")
        prof_card.pack(fill="x", pady=(0, 8))

        nick_row = tk.Frame(prof_card, bg=self.c_card)
        nick_row.pack(fill="x", padx=12, pady=(8, 4))

        tk.Label(
            nick_row,
            text="Игровой ник:",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 9),
            fg=self.c_muted,
            bg=self.c_card,
            width=12,
            anchor="w"
        ).pack(side="left")

        self.nick_var = tk.StringVar(value=self.cfg.get("nickname", "Player"))
        self.nick_entry = tk.Entry(
            nick_row,
            textvariable=self.nick_var,
            bg=self.c_input_bg,
            fg=self.c_text,
            insertbackground="#ffffff",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 10, "bold"),
            relief="flat",
            highlightthickness=1,
            highlightbackground=self.c_input_border,
            highlightcolor=self.c_green
        )
        self.nick_entry.pack(side="left", fill="x", expand=True, ipady=3)

        # Password row
        pass_row = tk.Frame(prof_card, bg=self.c_card)
        pass_row.pack(fill="x", padx=12, pady=(2, 4))

        tk.Label(
            pass_row,
            text="Пароль:",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 9),
            fg=self.c_muted,
            bg=self.c_card,
            width=12,
            anchor="w"
        ).pack(side="left")

        self.pass_var = tk.StringVar(value=self.cfg.get("password", ""))
        self.pass_entry = tk.Entry(
            pass_row,
            textvariable=self.pass_var,
            show="•",
            bg=self.c_input_bg,
            fg=self.c_text,
            insertbackground="#ffffff",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 10),
            relief="flat",
            highlightthickness=1,
            highlightbackground=self.c_input_border,
            highlightcolor=self.c_green
        )
        self.pass_entry.pack(side="left", fill="x", expand=True, padx=(0, 6), ipady=3)

        self.btn_toggle_pass = tk.Button(
            pass_row,
            text="👁",
            command=self.toggle_show_pass,
            bg=self.c_card_border,
            fg="#ffffff",
            activebackground=self.c_green,
            activeforeground="#ffffff",
            relief="flat",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            cursor="hand2"
        )
        self.btn_toggle_pass.pack(side="left", ipadx=4, ipady=1)

        # Password options row
        pass_opt_row = tk.Frame(prof_card, bg=self.c_card)
        pass_opt_row.pack(fill="x", padx=12, pady=(0, 8))

        self.remember_pass_var = tk.BooleanVar(value=self.cfg.get("remember_password", True))
        tk.Checkbutton(
            pass_opt_row,
            text="Запомнить пароль для сервера",
            variable=self.remember_pass_var,
            bg=self.c_card,
            fg=self.c_muted,
            selectcolor=self.c_card,
            activebackground=self.c_card,
            activeforeground=self.c_text,
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8)
        ).pack(side="left")

        tk.Label(
            pass_opt_row,
            text="• Авто-вход / регистрация",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8, "italic"),
            fg="#71717a",
            bg=self.c_card
        ).pack(side="right")

        # 2. Game Mode & Server Section
        mode_card = self.create_card(main_frame, "🌐 РЕЖИМ И СЕРВЕР")
        mode_card.pack(fill="x", pady=(0, 8))

        mode_row = tk.Frame(mode_card, bg=self.c_card)
        mode_row.pack(fill="x", padx=12, pady=(8, 4))

        self.mode_var = tk.StringVar(value=self.cfg.get("mode", "multiplayer"))
        rb_mp = tk.Radiobutton(
            mode_row,
            text="Сетевая игра (Сервер)",
            variable=self.mode_var,
            value="multiplayer",
            command=self.on_mode_change,
            bg=self.c_card,
            fg=self.c_text,
            selectcolor=self.c_card,
            activebackground=self.c_card,
            activeforeground=self.c_text,
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 9, "bold")
        )
        rb_mp.pack(side="left")

        rb_sp = tk.Radiobutton(
            mode_row,
            text="Одиночная игра",
            variable=self.mode_var,
            value="singleplayer",
            command=self.on_mode_change,
            bg=self.c_card,
            fg=self.c_text,
            selectcolor=self.c_card,
            activebackground=self.c_card,
            activeforeground=self.c_text,
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 9, "bold")
        )
        rb_sp.pack(side="left", padx=(16, 0))

        # Server selection block
        self.server_frame = tk.Frame(mode_card, bg=self.c_card)
        self.server_frame.pack(fill="x", padx=12, pady=(0, 8))

        srv_row = tk.Frame(self.server_frame, bg=self.c_card)
        srv_row.pack(fill="x", pady=(2, 6))

        tk.Label(
            srv_row,
            text="Адрес:",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 9),
            fg=self.c_muted,
            bg=self.c_card
        ).pack(side="left")

        self.server_list = list(self.cfg.get("servers", DEFAULT_SERVERS))
        self.server_var = tk.StringVar(value=self.cfg.get("selected_server", "minecraft.tirel.top:25565"))
        self.server_combo = ttk.Combobox(
            srv_row,
            textvariable=self.server_var,
            values=self.server_list,
            style="Dark.TCombobox",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 9)
        )
        self.server_combo.pack(side="left", fill="x", expand=True, padx=(8, 6))
        self.server_combo.bind("<<ComboboxSelected>>", lambda e: self.refresh_server_status())
        self.server_combo.bind("<Return>", lambda e: self.refresh_server_status())

        btn_add = tk.Button(
            srv_row,
            text="➕",
            command=self.add_server,
            bg=self.c_card_border,
            fg="#ffffff",
            activebackground=self.c_green,
            activeforeground="#ffffff",
            relief="flat",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            cursor="hand2"
        )
        btn_add.pack(side="left", padx=(0, 3), ipadx=2)

        btn_del = tk.Button(
            srv_row,
            text="✕",
            command=self.del_server,
            bg=self.c_card_border,
            fg="#ffffff",
            activebackground=self.c_red,
            activeforeground="#ffffff",
            relief="flat",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            cursor="hand2"
        )
        btn_del.pack(side="left", padx=(0, 3), ipadx=3)

        btn_refresh = tk.Button(
            srv_row,
            text="🔄",
            command=self.refresh_server_status,
            bg=self.c_card_border,
            fg="#ffffff",
            activebackground=self.c_green,
            activeforeground="#ffffff",
            relief="flat",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            cursor="hand2"
        )
        btn_refresh.pack(side="left", ipadx=3)

        # Server Status Box
        self.status_box = tk.Frame(
            self.server_frame,
            bg=self.c_input_bg,
            highlightthickness=1,
            highlightbackground=self.c_input_border
        )
        self.status_box.pack(fill="x", pady=(2, 0))

        status_inner = tk.Frame(self.status_box, bg=self.c_input_bg)
        status_inner.pack(fill="x", padx=10, pady=6)

        self.status_indicator = tk.Label(
            status_inner,
            text="● Проверка...",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 9, "bold"),
            fg=self.c_yellow,
            bg=self.c_input_bg
        )
        self.status_indicator.pack(anchor="w")

        self.status_motd = tk.Label(
            status_inner,
            text="Подключение к серверу...",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8, "italic"),
            fg=self.c_muted,
            bg=self.c_input_bg
        )
        self.status_motd.pack(anchor="w", pady=(1, 0))

        self.status_details = tk.Label(
            status_inner,
            text="",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            fg=self.c_muted,
            bg=self.c_input_bg
        )
        self.status_details.pack(anchor="w", pady=(1, 0))

        # 3. Client Download & Installation Section
        client_card = self.create_card(main_frame, "📦 КЛИЕНТ ИГРЫ")
        client_card.pack(fill="x", pady=(0, 8))

        client_inner = tk.Frame(client_card, bg=self.c_card)
        client_inner.pack(fill="x", padx=12, pady=8)

        # Status row
        status_row = tk.Frame(client_inner, bg=self.c_card)
        status_row.pack(fill="x")

        self.client_state_lbl = tk.Label(
            status_row,
            text="● Проверка файлов...",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 9, "bold"),
            fg=self.c_yellow,
            bg=self.c_card
        )
        self.client_state_lbl.pack(side="left")

        # URL row
        url_row = tk.Frame(client_inner, bg=self.c_card)
        url_row.pack(fill="x", pady=(6, 4))

        tk.Label(
            url_row,
            text="Ссылка на ZIP:",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            fg=self.c_muted,
            bg=self.c_card
        ).pack(side="left")

        self.url_var = tk.StringVar(value=self.cfg.get("client_url", "https://minecraft.tirel.top/client.zip"))
        self.url_entry = tk.Entry(
            url_row,
            textvariable=self.url_var,
            bg=self.c_input_bg,
            fg=self.c_text,
            insertbackground="#ffffff",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            relief="flat",
            highlightthickness=1,
            highlightbackground=self.c_input_border,
            highlightcolor=self.c_blue
        )
        self.url_entry.pack(side="left", fill="x", expand=True, padx=(6, 6), ipady=2)

        self.btn_download = tk.Button(
            url_row,
            text="📥 Скачать",
            command=self.start_client_download,
            bg=self.c_blue,
            fg="#ffffff",
            activebackground=self.c_blue_hover,
            activeforeground="#ffffff",
            relief="flat",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8, "bold"),
            cursor="hand2"
        )
        self.btn_download.pack(side="left", ipadx=4)

        # Progress bar container (hidden when idle)
        self.progress_frame = tk.Frame(client_inner, bg=self.c_card)
        self.progress_frame.pack(fill="x", pady=(4, 0))

        self.prog_bar = ttk.Progressbar(
            self.progress_frame,
            style="Green.Horizontal.TProgressbar",
            maximum=100,
            value=0
        )
        self.prog_bar.pack(fill="x")

        self.prog_lbl = tk.Label(
            self.progress_frame,
            text="",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            fg=self.c_muted,
            bg=self.c_card
        )
        self.prog_lbl.pack(anchor="w", pady=(2, 0))
        self.progress_frame.pack_forget()

        # 4. Skin Card
        skin_card = self.create_card(main_frame, "🎨 СКИН ПЕРСОНАЖА")
        skin_card.pack(fill="x", pady=(0, 8))

        skin_inner = tk.Frame(skin_card, bg=self.c_card)
        skin_inner.pack(fill="x", padx=12, pady=8)

        skin_row = tk.Frame(skin_inner, bg=self.c_card)
        skin_row.pack(fill="x")

        self.skin_path_var = tk.StringVar(value=self.cfg.get("skin_path", ""))
        self.skin_entry = tk.Entry(
            skin_row,
            textvariable=self.skin_path_var,
            bg=self.c_input_bg,
            fg=self.c_text,
            insertbackground="#ffffff",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            relief="flat",
            highlightthickness=1,
            highlightbackground=self.c_input_border,
            highlightcolor=self.c_blue
        )
        self.skin_entry.pack(side="left", fill="x", expand=True, padx=(0, 6), ipady=2)

        def browse_skin():
            from tkinter import filedialog
            f = filedialog.askopenfilename(
                title="Выберите скин (.png)",
                filetypes=[("PNG изображения", "*.png"), ("Все файлы", "*.*")]
            )
            if f:
                self.skin_path_var.set(f)
                self.save_current_settings()

        def clear_skin():
            self.skin_path_var.set("")
            self.save_current_settings()

        tk.Button(
            skin_row,
            text="📂 Выбрать PNG...",
            command=browse_skin,
            bg=self.c_blue,
            fg="#ffffff",
            activebackground=self.c_blue_hover,
            activeforeground="#ffffff",
            relief="flat",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8, "bold"),
            cursor="hand2"
        ).pack(side="left", padx=(0, 4))

        tk.Button(
            skin_row,
            text="❌",
            command=clear_skin,
            bg=self.c_card_border,
            fg=self.c_red,
            activebackground=self.c_card_border,
            activeforeground=self.c_red,
            relief="flat",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            cursor="hand2"
        ).pack(side="left")

        model_row = tk.Frame(skin_inner, bg=self.c_card)
        model_row.pack(fill="x", pady=(6, 0))

        tk.Label(
            model_row,
            text="Модель рук:",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            fg=self.c_muted,
            bg=self.c_card
        ).pack(side="left", padx=(0, 8))

        self.skin_model_var = tk.StringVar(value=self.cfg.get("skin_model", "classic"))

        tk.Radiobutton(
            model_row,
            text="Классическая (Стив, 4px)",
            variable=self.skin_model_var,
            value="classic",
            bg=self.c_card,
            fg=self.c_text,
            selectcolor=self.c_input_bg,
            activebackground=self.c_card,
            activeforeground=self.c_text,
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            command=self.save_current_settings
        ).pack(side="left", padx=(0, 10))

        tk.Radiobutton(
            model_row,
            text="Тонкая (Алекс, 3px)",
            variable=self.skin_model_var,
            value="slim",
            bg=self.c_card,
            fg=self.c_text,
            selectcolor=self.c_input_bg,
            activebackground=self.c_card,
            activeforeground=self.c_text,
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            command=self.save_current_settings
        ).pack(side="left")

        # 5. Settings Card
        opt_card = self.create_card(main_frame, "⚙ НАСТРОЙКИ ЗАПУСКА")
        opt_card.pack(fill="x", pady=(0, 8))

        opt_frame = tk.Frame(opt_card, bg=self.c_card)
        opt_frame.pack(fill="x", padx=12, pady=8)

        self.fs_var = tk.BooleanVar(value=self.cfg.get("fullscreen", False))
        tk.Checkbutton(
            opt_frame,
            text="Полноэкранный режим",
            variable=self.fs_var,
            bg=self.c_card,
            fg=self.c_text,
            selectcolor=self.c_card,
            activebackground=self.c_card,
            activeforeground=self.c_text,
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8)
        ).pack(anchor="w")

        self.close_var = tk.BooleanVar(value=self.cfg.get("close_on_launch", True))
        tk.Checkbutton(
            opt_frame,
            text="Закрывать лаунчер при старте игры",
            variable=self.close_var,
            bg=self.c_card,
            fg=self.c_text,
            selectcolor=self.c_card,
            activebackground=self.c_card,
            activeforeground=self.c_text,
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8)
        ).pack(anchor="w", pady=(1, 4))

        rd_row = tk.Frame(opt_frame, bg=self.c_card)
        rd_row.pack(fill="x")

        tk.Label(
            rd_row,
            text="Дальность прорисовки (чанков):",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            fg=self.c_muted,
            bg=self.c_card
        ).pack(side="left")

        self.rd_var = tk.IntVar(value=self.cfg.get("render_distance", 12))
        rd_spin = tk.Spinbox(
            rd_row,
            from_=2,
            to=32,
            textvariable=self.rd_var,
            width=4,
            bg=self.c_input_bg,
            fg=self.c_text,
            buttonbackground=self.c_card_border,
            relief="flat",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8)
        )
        rd_spin.pack(side="left", padx=(6, 0))

        # 5. Launch Action Button
        bottom_frame = tk.Frame(self.root, bg=self.c_bg)
        bottom_frame.pack(fill="x", padx=20, pady=(6, 12))

        self.launch_btn = tk.Button(
            bottom_frame,
            text="▶   ИГРАТЬ",
            command=self.launch_game,
            bg=self.c_green,
            fg="#ffffff",
            activebackground=self.c_green_hover,
            activeforeground="#ffffff",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 12, "bold"),
            relief="flat",
            cursor="hand2",
            pady=8
        )
        self.launch_btn.pack(fill="x")

        self.info_lbl = tk.Label(
            bottom_frame,
            text="Готов к запуску",
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8),
            fg=self.c_muted,
            bg=self.c_bg
        )
        self.info_lbl.pack(pady=(4, 0))

        self.on_mode_change()

    def create_card(self, parent, title):
        card = tk.Frame(
            parent,
            bg=self.c_card,
            highlightthickness=1,
            highlightbackground=self.c_card_border
        )
        header = tk.Frame(card, bg=self.c_card_border)
        header.pack(fill="x")

        tk.Label(
            header,
            text=title,
            font=("Segoe UI" if sys.platform == "win32" else "DejaVu Sans", 8, "bold"),
            fg="#e4e4e7",
            bg=self.c_card_border
        ).pack(anchor="w", padx=10, pady=3)
        return card

    def update_client_status(self):
        client = find_horizon_client()
        res = find_resources()
        if client and res:
            self.client_state_lbl.config(
                text="● Клиент установлен и готов",
                fg=self.c_green
            )
            self.btn_download.config(text="🔄 Обновить")
        elif client:
            self.client_state_lbl.config(
                text="● Найден исполняемый файл, но отсутствуют ресурсы",
                fg=self.c_yellow
            )
            self.btn_download.config(text="📥 Скачать")
        else:
            self.client_state_lbl.config(
                text="● Клиент не установлен (файлы игры не найдены)",
                fg=self.c_red
            )
            self.btn_download.config(text="📥 Скачать")

    def start_client_download(self):
        if self.is_downloading:
            return

        raw_url = self.url_var.get().strip()
        if not raw_url or not (raw_url.startswith("http://") or raw_url.startswith("https://")):
            messagebox.showwarning("Внимание", "Пожалуйста, введите корректный URL (http:// или https://) к ZIP-архиву клиента!")
            return

        # Если указан только домен или папка без .zip, автоматически дописываем /client.zip
        download_url = raw_url
        if not download_url.lower().endswith(".zip"):
            download_url = f"{download_url.rstrip('/')}/client.zip"

        self.save_current_settings()
        self.is_downloading = True
        self.btn_download.config(state="disabled")
        self.launch_btn.config(state="disabled")
        self.progress_frame.pack(fill="x", pady=(4, 0))
        self.prog_bar["value"] = 0
        self.prog_lbl.config(text="Подключение к серверу...", fg=self.c_text)

        def worker():
            zip_dest = ROOT_DIR / "client_download_temp.zip"
            try:
                # 1. Download
                req = urllib.request.Request(
                    download_url,
                    headers={"User-Agent": "HorizonLauncher/1.0 (Minecraft 26.3 Rust)"}
                )
                with urllib.request.urlopen(req, timeout=15) as resp:
                    total_size = int(resp.headers.get("Content-Length", 0))
                    downloaded = 0
                    chunk_size = 65536
                    start_time = time.time()

                    with open(zip_dest, "wb") as f:
                        while True:
                            chunk = resp.read(chunk_size)
                            if not chunk:
                                break
                            f.write(chunk)
                            downloaded += len(chunk)

                            elapsed = max(0.001, time.time() - start_time)
                            speed_mb = (downloaded / (1024 * 1024)) / elapsed
                            pct = int((downloaded / total_size * 100)) if total_size > 0 else 0

                            msg = f"Скачивание: {downloaded / (1024*1024):.1f} / {total_size / (1024*1024):.1f} МБ ({speed_mb:.1f} МБ/с) • {pct}%" if total_size > 0 else f"Скачано: {downloaded / (1024*1024):.1f} МБ"

                            def update_dl(p=pct, m=msg):
                                self.prog_bar["value"] = p
                                self.prog_lbl.config(text=m)
                            self.msg_queue.put(update_dl)

                # 2. Extract
                def update_ex_start():
                    self.prog_bar["value"] = 0
                    self.prog_lbl.config(text="Распаковка архива...")
                self.msg_queue.put(update_ex_start)

                with zipfile.ZipFile(zip_dest, "r") as zf:
                    members = zf.infolist()
                    total_files = len(members)
                    current_exe_name = Path(sys.executable).name.lower()

                    for i, member in enumerate(members):
                        fname_lower = Path(member.filename).name.lower()
                        # Skip extracting the running launcher executable to avoid Permission Denied on Windows
                        if fname_lower in ("horizonlauncher.exe", current_exe_name):
                            continue

                        try:
                            zf.extract(member, ROOT_DIR)
                        except (PermissionError, OSError):
                            continue

                        # Restore file permissions on Linux/macOS
                        if sys.platform != "win32":
                            target = ROOT_DIR / member.filename
                            mode = member.external_attr >> 16
                            if mode & 0o111:
                                try:
                                    target.chmod(mode & 0o777)
                                except Exception:
                                    pass
                            elif member.filename.endswith("horizon-client") or member.filename.endswith(".sh"):
                                try:
                                    target.chmod(0o755)
                                except Exception:
                                    pass

                        if i % 15 == 0 or i == total_files - 1:
                            pct_ex = int((i + 1) / total_files * 100)
                            msg_ex = f"Распаковка: {i+1} / {total_files} файлов ({pct_ex}%)"
                            def update_ex(p=pct_ex, m=msg_ex):
                                self.prog_bar["value"] = p
                                self.prog_lbl.config(text=m)
                            self.msg_queue.put(update_ex)

                # Cleanup temp zip
                if zip_dest.is_file():
                    zip_dest.unlink()

                def on_done():
                    self.is_downloading = False
                    self.btn_download.config(state="normal")
                    self.launch_btn.config(state="normal")
                    self.prog_lbl.config(text="Установка завершена успешно!", fg=self.c_green)
                    self.update_client_status()
                    messagebox.showinfo("Успех", "Клиент успешно загружен и установлен!")
                    self.root.after(3000, self.progress_frame.pack_forget)
                self.msg_queue.put(on_done)

            except Exception as e:
                if zip_dest.is_file():
                    try:
                        zip_dest.unlink()
                    except Exception:
                        pass
                def on_err(err=str(e)):
                    self.is_downloading = False
                    self.btn_download.config(state="normal")
                    self.launch_btn.config(state="normal")
                    self.prog_lbl.config(text=f"Ошибка: {err}", fg=self.c_red)
                    messagebox.showerror("Ошибка загрузки", f"Не удалось загрузить или распаковать клиент:\n{err}")
                self.msg_queue.put(on_err)

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

    def toggle_show_pass(self):
        if self.pass_entry.cget("show") == "":
            self.pass_entry.config(show="•")
            self.btn_toggle_pass.config(text="👁")
        else:
            self.pass_entry.config(show="")
            self.btn_toggle_pass.config(text="🔒")

    def on_mode_change(self):
        mode = self.mode_var.get()
        if mode == "multiplayer":
            self.server_frame.pack(fill="x", padx=12, pady=(0, 8))
            self.refresh_server_status()
        else:
            self.server_frame.pack_forget()

    def add_server(self):
        addr = self.server_var.get().strip()
        if addr and addr not in self.server_list:
            self.server_list.append(addr)
            self.server_combo['values'] = self.server_list
            self.save_current_settings()

    def del_server(self):
        addr = self.server_var.get().strip()
        if addr in self.server_list:
            self.server_list.remove(addr)
            self.server_combo['values'] = self.server_list
            if self.server_list:
                self.server_var.set(self.server_list[0])
            else:
                self.server_var.set("")
            self.save_current_settings()
            self.refresh_server_status()

    def refresh_server_status(self):
        if self.mode_var.get() != "multiplayer":
            return

        addr = self.server_var.get().strip()
        if not addr:
            self.status_indicator.config(text="● Введите адрес сервера", fg=self.c_yellow)
            self.status_motd.config(text="")
            self.status_details.config(text="")
            return

        self.status_indicator.config(text="● Опрос сервера...", fg=self.c_yellow)
        self.status_motd.config(text="Подключение...")
        self.status_details.config(text="")

        def do_ping():
            parts = addr.split(":")
            host = parts[0]
            port = int(parts[1]) if len(parts) > 1 else 25565
            res = ping_minecraft_server(host, port)

            def update_ui():
                if res.get('online'):
                    self.status_indicator.config(text="● Онлайн", fg=self.c_green)
                    self.status_motd.config(text=res.get('motd', 'Minecraft Server'))
                    details = f"Пинг: {res.get('ping_ms')} мс  |  Игроки: {res.get('players_online')}/{res.get('players_max')}  |  Версия: {res.get('version')}"
                    self.status_details.config(text=details)
                else:
                    self.status_indicator.config(text="● Не в сети (Оффлайн)", fg=self.c_red)
                    self.status_motd.config(text="Сервер недоступен или не отвечает")
                    self.status_details.config(text=f"Ошибка: {res.get('error', 'Connection failed')}")

            self.msg_queue.put(update_ui)

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

    def save_current_settings(self):
        self.cfg["nickname"] = self.nick_var.get().strip() or "Player"
        self.cfg["remember_password"] = self.remember_pass_var.get()
        if self.remember_pass_var.get():
            self.cfg["password"] = self.pass_var.get().strip()
        else:
            self.cfg["password"] = ""
        self.cfg["mode"] = self.mode_var.get()
        self.cfg["selected_server"] = self.server_var.get().strip()
        self.cfg["servers"] = self.server_list
        self.cfg["fullscreen"] = self.fs_var.get()
        self.cfg["render_distance"] = self.rd_var.get()
        self.cfg["close_on_launch"] = self.close_var.get()
        self.cfg["client_url"] = self.url_var.get().strip()
        self.cfg["skin_path"] = self.skin_path_var.get().strip()
        self.cfg["skin_model"] = self.skin_model_var.get()
        save_config(self.cfg)

    def launch_game(self):
        nick = self.nick_var.get().strip()
        if not nick:
            messagebox.showwarning("Внимание", "Пожалуйста, введите игровой ник!")
            return

        client_bin = find_horizon_client()
        res_path = find_resources()

        if not client_bin or not res_path:
            ask = messagebox.askyesno(
                "Клиент не найден",
                "Файлы игры или ресурсы не найдены.\n\n"
                "Скачать клиент сейчас по указанной ссылке?"
            )
            if ask:
                self.start_client_download()
            return

        self.save_current_settings()

        game_dir = ROOT_DIR / "game"
        game_dir.mkdir(exist_ok=True)

        cmd = [
            str(client_bin),
            "--name", nick,
            "--resources", str(res_path),
            "--game-dir", str(game_dir),
            "--render-distance", str(self.rd_var.get())
        ]

        if self.fs_var.get():
            cmd.append("--fullscreen")

        is_multiplayer = self.mode_var.get() == "multiplayer"
        password = self.pass_var.get().strip()

        if is_multiplayer:
            server_addr = self.server_var.get().strip()
            if server_addr:
                cmd.extend(["--server", server_addr])

        ctl_file = None
        if is_multiplayer and password:
            import tempfile
            ctl_file = Path(tempfile.gettempdir()) / f"horizon-ctl-{os.getpid()}-{int(time.time()*1000)}.json"
            cmd.extend(["--control", "--control-socket", str(ctl_file)])

        self.info_lbl.config(text="Запуск игры...", fg=self.c_green)
        self.launch_btn.config(state="disabled")

        try:
            env = os.environ.copy()
            if password:
                env["HORIZON_AUTH_PASSWORD"] = password

            skin_path = self.skin_path_var.get().strip()
            if skin_path and os.path.isfile(skin_path):
                env["HORIZON_OFFLINE_SKIN"] = str(Path(skin_path).resolve())
                env["HORIZON_OFFLINE_SKIN_MODEL"] = self.skin_model_var.get()

            if sys.platform == "win32":
                subprocess.Popen(cmd, cwd=str(ROOT_DIR), env=env, creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
            else:
                subprocess.Popen(cmd, cwd=str(ROOT_DIR), env=env, start_new_session=True)

            if is_multiplayer and password and ctl_file:
                should_close = self.close_var.get()
                if should_close:
                    self.root.withdraw()

                def auth_worker():
                    auto_auth_session(ctl_file, password)
                    if should_close:
                        self.msg_queue.put(self.root.destroy)
                    else:
                        def on_auth_done():
                            self.info_lbl.config(text="Игра запущена (авторизован)!", fg=self.c_green)
                            self.root.after(3000, lambda: [
                                self.launch_btn.config(state="normal"),
                                self.info_lbl.config(text="Готов к запуску", fg=self.c_muted)
                            ])
                        self.msg_queue.put(on_auth_done)

                threading.Thread(target=auth_worker, daemon=True).start()
            else:
                if self.close_var.get():
                    self.root.after(800, self.root.destroy)
                else:
                    self.info_lbl.config(text="Игра успешно запущена!", fg=self.c_green)
                    self.root.after(3000, lambda: [
                        self.launch_btn.config(state="normal"),
                        self.info_lbl.config(text="Готов к запуску", fg=self.c_muted)
                    ])
        except Exception as e:
            self.launch_btn.config(state="normal")
            self.info_lbl.config(text="Ошибка запуска", fg=self.c_red)
            messagebox.showerror("Ошибка запуска", f"Не удалось запустить процесс: {e}")


def main():
    root = tk.Tk()
    app = LauncherApp(root)
    root.mainloop()


if __name__ == "__main__":
    main()
