#!/usr/bin/env python3
"""Add Egress to Steam as a non-Steam game, with its artwork (standard library only; Steam Deck and desktop Linux).

    python3 egress_steam.py --exe PATH [--start-dir DIR] [--launch-options "..."] --art DIR [--name Egress]
                            [--restart-steam] [--check]

Finds the shortcut by name in every Steam user's config/shortcuts.vdf. If it is missing (or its exe, start folder, icon
or launch options differ) the file has to be rewritten, which Steam only accepts while it is closed: without
--restart-steam the script stops and says so; with it, Steam is shut down, the file is written and Steam is started
again. The artwork goes into config/grid/ under the shortcut's app id, which needs no restart (Steam shows it the next
time it loads the library). --check only reports what it would do.

ART holds icon.png, capsule.png (600x900), wide.png (920x430), background.png (1920x620) and logo.png.
"""
import argparse
import binascii
import os
import shutil
import struct
import subprocess
import sys
import time
from pathlib import Path

# ---- binary VDF (the format of shortcuts.vdf) --------------------------------------------------------------------------
MAP, STR, INT, END = 0x00, 0x01, 0x02, 0x08


def _cstr(data, i):
    j = data.index(b"\x00", i)
    return data[i:j].decode("utf-8", "surrogateescape"), j + 1


def _parse_map(data, i):
    items = []
    while True:
        t = data[i]
        i += 1
        if t == END:
            return items, i
        key, i = _cstr(data, i)
        if t == MAP:
            value, i = _parse_map(data, i)
        elif t == STR:
            value, i = _cstr(data, i)
        elif t == INT:
            value = struct.unpack_from("<i", data, i)[0]
            i += 4
        else:
            raise ValueError(f"shortcuts.vdf: unknown field type {t:#x} at byte {i - 1}")
        items.append([key, t, value])


def parse(data):
    items, i = _parse_map(data, 0)
    if i != len(data):
        raise ValueError("shortcuts.vdf: unexpected bytes after the root map")
    return items


def _dump_map(items):
    out = bytearray()
    for key, t, value in items:
        out.append(t)
        out += key.encode("utf-8", "surrogateescape") + b"\x00"
        if t == MAP:
            out += _dump_map(value)
        elif t == STR:
            out += value.encode("utf-8", "surrogateescape") + b"\x00"
        else:
            out += struct.pack("<i", value)
    out.append(END)
    return bytes(out)


def dump(items):
    return _dump_map(items)          # the root map's own END closes the file


def get(items, key, default=None):
    for k, _, v in items:
        if k.lower() == key.lower():
            return v
    return default


def put(items, key, t, value):
    for entry in items:
        if entry[0].lower() == key.lower():
            entry[1], entry[2] = t, value
            return
    items.append([key, t, value])


# ---- Steam ---------------------------------------------------------------------------------------------------------
def steam_roots():
    seen, roots = set(), []
    for p in (Path.home() / ".local/share/Steam", Path.home() / ".steam/steam", Path.home() / ".steam/root",
              Path.home() / ".var/app/com.valvesoftware.Steam/.local/share/Steam"):
        if p.is_dir():
            r = p.resolve()
            if r not in seen and (r / "userdata").is_dir():
                seen.add(r)
                roots.append(r)
    return roots


def user_configs():
    for root in steam_roots():
        for u in sorted((root / "userdata").iterdir()):
            if u.name.isdigit() and u.name != "0" and (u / "config").is_dir():
                yield u / "config"


def steam_running():
    return subprocess.run(["pgrep", "-x", "steam"], capture_output=True).returncode == 0


def shortcut_appid(exe, name):
    """Steam's id for a non-Steam shortcut: crc32 of the quoted exe and the name, top bit set."""
    return (binascii.crc32((exe + name).encode("utf-8")) & 0xFFFFFFFF) | 0x80000000


def signed(u):
    return u - (1 << 32) if u >= 1 << 31 else u


def install_art(config, appid, art):
    grid = config / "grid"
    grid.mkdir(parents=True, exist_ok=True)
    for src, dst in (("capsule.png", f"{appid}p.png"), ("wide.png", f"{appid}.png"), ("background.png", f"{appid}_hero.png"),
                     ("logo.png", f"{appid}_logo.png"), ("icon.png", f"{appid}_icon.png")):
        if (art / src).is_file():
            shutil.copyfile(art / src, grid / dst)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--exe", required=True)
    ap.add_argument("--start-dir")
    ap.add_argument("--launch-options", default="")
    ap.add_argument("--art", required=True)
    ap.add_argument("--name", default="Egress")
    ap.add_argument("--restart-steam", action="store_true")
    ap.add_argument("--check", action="store_true")
    a = ap.parse_args()

    art = Path(a.art).expanduser().resolve()
    exe = str(Path(a.exe).expanduser().resolve())
    start = str(Path(a.start_dir or Path(exe).parent).expanduser().resolve())
    icon = str(art / "icon.png")
    want = {"Exe": f'"{exe}"', "StartDir": f'"{start}"', "icon": icon, "LaunchOptions": a.launch_options}

    configs = list(user_configs())
    if not configs:
        print("egress-steam: no Steam user folder found; is Steam installed and logged in once?", file=sys.stderr)
        return 1

    plans = []      # (config, items or None to keep, appid)
    for config in configs:
        path = config / "shortcuts.vdf"
        data = path.read_bytes() if path.is_file() else None
        root = parse(data) if data else [["shortcuts", MAP, []]]
        if data and dump(root) != data:
            print(f"egress-steam: {path} does not round-trip; leaving it alone", file=sys.stderr)
            return 1
        shortcuts = get(root, "shortcuts")
        if shortcuts is None:
            shortcuts = []
            root.append(["shortcuts", MAP, shortcuts])
        entry = next((v for _, t, v in shortcuts if t == MAP and str(get(v, "AppName", get(v, "appname", ""))).lower()
                      == a.name.lower()), None)
        if entry is None:
            appid = shortcut_appid(want["Exe"], a.name)
            entry = [["appid", INT, signed(appid)], ["AppName", STR, a.name]]
            for k in ("Exe", "StartDir", "icon"):
                entry.append([k, STR, want[k]])
            entry += [["ShortcutPath", STR, ""], ["LaunchOptions", STR, want["LaunchOptions"]], ["IsHidden", INT, 0],
                      ["AllowDesktopConfig", INT, 1], ["AllowOverlay", INT, 1], ["OpenVR", INT, 0], ["Devkit", INT, 0],
                      ["DevkitGameID", STR, ""], ["DevkitOverrideAppID", INT, 0], ["LastPlayTime", INT, 0],
                      ["FlatpakAppID", STR, ""], ["tags", MAP, []]]
            index = max((int(k) for k, _, _ in shortcuts if k.isdigit()), default=-1) + 1
            shortcuts.append([str(index), MAP, entry])
            plans.append((config, root, appid, "add"))
            continue
        appid = get(entry, "appid")
        appid = (appid & 0xFFFFFFFF) if appid is not None else shortcut_appid(get(entry, "Exe", want["Exe"]), a.name)
        changed = [k for k, v in want.items() if get(entry, k, "") != v]
        if get(entry, "appid") is None:
            put(entry, "appid", INT, signed(appid))
            changed.append("appid")
        for k in changed:
            if k != "appid":
                put(entry, k, STR, want[k])
        plans.append((config, root if changed else None, appid, "update " + ", ".join(changed) if changed else "keep"))

    for config, items, appid, what in plans:
        print(f"egress-steam: {config.parent.name}: {a.name} (app id {appid}): {what}; artwork into {config / 'grid'}")
    if a.check:
        return 0

    writes = [(c, items) for c, items, _, _ in plans if items is not None]
    restarted = False
    if writes and steam_running():
        if not a.restart_steam:
            print("egress-steam: Steam is running; close it (or pass --restart-steam) so the shortcut can be written",
                  file=sys.stderr)
            for config, _, appid, _ in plans:
                install_art(config, appid, art)
            return 3
        subprocess.run(["steam", "-shutdown"], capture_output=True)
        for _ in range(60):
            if not steam_running():
                break
            time.sleep(1)
        else:
            print("egress-steam: Steam did not close within a minute; nothing written", file=sys.stderr)
            return 1
        time.sleep(2)
        restarted = True
    for config, items in writes:
        path = config / "shortcuts.vdf"
        if path.is_file():
            shutil.copyfile(path, path.with_suffix(".vdf.egress-bak"))
        tmp = path.with_suffix(".vdf.part")
        tmp.write_bytes(dump(items))
        os.replace(tmp, path)
    for config, _, appid, _ in plans:
        install_art(config, appid, art)
    if restarted:
        subprocess.Popen(["steam"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
    print("egress-steam: done" + (" (Steam restarted)" if restarted else ""))
    return 0


if __name__ == "__main__":
    sys.exit(main())
