# -*- coding: utf-8 -*-
"""
Chaapa'ai Launcher - Phase 1

Funktionen:
- liest lokale Version aus version.txt
- fragt aktuelle Server-Version über latest.json ab
- Update-Button ist bei gleicher Version deaktiviert
- prüft vor Update/Spielstart, ob Game.exe bereits läuft
- startet Game.exe
- Update-Download/Patchen kommt in Phase 2

Erwartete Dateien im gleichen Ordner wie dieses Script:
    Chaapaai_Launcher.py
    Game.exe
    version.txt

Server:
    http://46.225.133.211:8000/latest.json
"""

import json
import subprocess
import sys
import time
import urllib.request
import urllib.error
import tkinter as tk
from pathlib import Path
from tkinter import messagebox


APP_TITLE = "Chaapa'ai Launcher"
GAME_EXE = "Game.exe"
VERSION_FILE = "version.txt"
LATEST_URL = "http://46.225.133.211:8000/latest.json"

BASE_DIR = Path(__file__).resolve().parent
GAME_PATH = BASE_DIR / GAME_EXE
LOCAL_VERSION_PATH = BASE_DIR / VERSION_FILE


class ChaapaaiLauncher:
    def __init__(self, root):
        self.root = root
        self.root.title(APP_TITLE)
        self.root.resizable(False, False)

        self.local_version = self.read_local_version()
        self.server_version = None
        self.server_manifest = None

        self.status_var = tk.StringVar(value="Prüfe auf Updates...")
        self.local_var = tk.StringVar(
            value=f"Installierte Version: {self.local_version}"
        )
        self.server_var = tk.StringVar(value="Server-Version: —")

        self.build_ui()
        self.check_for_updates()

    # ------------------------------------------------------------------
    # UI
    # ------------------------------------------------------------------
    def build_ui(self):
        frame = tk.Frame(self.root, padx=24, pady=20)
        frame.pack()

        title = tk.Label(
            frame,
            text="Chaapa'ai",
            font=("Segoe UI", 22, "bold")
        )
        title.pack(pady=(0, 12))

        subtitle = tk.Label(
            frame,
            text="Multiplayer Launcher",
            font=("Segoe UI", 10)
        )
        subtitle.pack(pady=(0, 15))

        tk.Label(
            frame,
            textvariable=self.local_var,
            anchor="w",
            justify="left"
        ).pack(fill="x", pady=2)

        tk.Label(
            frame,
            textvariable=self.server_var,
            anchor="w",
            justify="left"
        ).pack(fill="x", pady=2)

        self.update_button = tk.Button(
            frame,
            text="UPDATE",
            width=24,
            state=tk.DISABLED,
            command=self.start_update
        )
        self.update_button.pack(pady=(18, 8))

        self.play_button = tk.Button(
            frame,
            text="SPIEL STARTEN",
            width=24,
            command=self.start_game
        )
        self.play_button.pack(pady=8)

        self.status_label = tk.Label(
            frame,
            textvariable=self.status_var,
            justify="left",
            wraplength=360
        )
        self.status_label.pack(pady=(15, 0))

    # ------------------------------------------------------------------
    # Versionsdatei
    # ------------------------------------------------------------------
    def read_local_version(self):
        try:
            value = LOCAL_VERSION_PATH.read_text(encoding="utf-8").strip()
            return value or "1.0.0"
        except OSError:
            return "1.0.0"

    # ------------------------------------------------------------------
    # Server-Version prüfen
    # ------------------------------------------------------------------
    def check_for_updates(self):
        self.update_button.config(state=tk.DISABLED)
        self.status_var.set("Prüfe Server-Version...")

        try:
            request = urllib.request.Request(
                LATEST_URL,
                headers={"User-Agent": "ChaapaaiLauncher/1.0"}
            )

            with urllib.request.urlopen(request, timeout=10) as response:
                payload = response.read().decode("utf-8")

            data = json.loads(payload)

            self.server_version = str(data["version"]).strip()
            self.server_manifest = data.get("manifest")

            self.server_var.set(
                f"Server-Version: {self.server_version}"
            )

            if self.server_version == self.local_version:
                self.update_button.config(
                    state=tk.DISABLED,
                    text="KEIN UPDATE VERFÜGBAR"
                )
                self.status_var.set(
                    "Das Spiel ist bereits auf dem neuesten Stand."
                )
            else:
                self.update_button.config(
                    state=tk.NORMAL,
                    text=f"UPDATE AUF {self.server_version}"
                )
                self.status_var.set(
                    "Eine neue Version ist verfügbar."
                )

        except (urllib.error.URLError, TimeoutError) as exc:
            self.server_var.set("Server-Version: nicht erreichbar")
            self.status_var.set(
                "Der Update-Server ist momentan nicht erreichbar."
            )
            self.update_button.config(
                state=tk.DISABLED,
                text="UPDATE NICHT VERFÜGBAR"
            )
            print(f"Netzwerkfehler: {exc}")

        except (ValueError, KeyError, json.JSONDecodeError) as exc:
            self.server_var.set("Server-Version: ungültige Antwort")
            self.status_var.set(
                "Die Antwort des Update-Servers konnte nicht gelesen werden."
            )
            self.update_button.config(
                state=tk.DISABLED,
                text="UPDATE NICHT VERFÜGBAR"
            )
            print(f"Manifest-/JSON-Fehler: {exc}")

        except Exception as exc:
            self.server_var.set("Server-Version: Fehler")
            self.status_var.set(
                "Beim Prüfen der Version ist ein Fehler aufgetreten."
            )
            self.update_button.config(
                state=tk.DISABLED,
                text="UPDATE NICHT VERFÜGBAR"
            )
            print(f"Fehler: {exc}")

    # ------------------------------------------------------------------
    # Prüfen, ob Game.exe läuft
    # ------------------------------------------------------------------
    @staticmethod
    def game_is_running():
        try:
            result = subprocess.run(
                [
                    "tasklist",
                    "/FI",
                    f"IMAGENAME eq {GAME_EXE}"
                ],
                capture_output=True,
                text=True,
                creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0)
            )

            return GAME_EXE.lower() in result.stdout.lower()

        except Exception:
            return False

    # ------------------------------------------------------------------
    # Spiel starten
    # ------------------------------------------------------------------
    def start_game(self):
        if not GAME_PATH.exists():
            messagebox.showerror(
                APP_TITLE,
                f"{GAME_EXE} wurde nicht gefunden:\n\n{GAME_PATH}"
            )
            return

        if self.game_is_running():
            messagebox.showwarning(
                APP_TITLE,
                "Game.exe läuft bereits."
            )
            return

        try:
            subprocess.Popen(
                [str(GAME_PATH)],
                cwd=str(BASE_DIR)
            )

            self.root.destroy()

        except OSError as exc:
            messagebox.showerror(
                APP_TITLE,
                f"Game.exe konnte nicht gestartet werden:\n\n{exc}"
            )

    # ------------------------------------------------------------------
    # Update Phase 1
    # ------------------------------------------------------------------
    def start_update(self):
        if self.server_version is None:
            messagebox.showwarning(
                APP_TITLE,
                "Es konnte keine gültige Server-Version ermittelt werden."
            )
            return

        if self.server_version == self.local_version:
            self.update_button.config(state=tk.DISABLED)
            return

        if self.game_is_running():
            messagebox.showwarning(
                APP_TITLE,
                "Das Spiel läuft noch.\n\n"
                "Bitte Game.exe vollständig schließen und danach "
                "das Update erneut starten."
            )
            return

        messagebox.showinfo(
            APP_TITLE,
            "Der Versionsabgleich funktioniert bereits.\n\n"
            "Der eigentliche Delta-Download wird im nächsten Schritt "
            "eingebaut."
        )

    # ------------------------------------------------------------------
    # Start
    # ------------------------------------------------------------------
    def run(self):
        self.root.mainloop()


def main():
    root = tk.Tk()

    try:
        root.iconname(APP_TITLE)
    except Exception:
        pass

    ChaapaaiLauncher(root).run()


if __name__ == "__main__":
    main()
