#!/usr/bin/env bash
# Installs Project Reclaimer (Halo 3 via your own MCC install) on Bazzite or SteamOS
# and adds it to Steam as a non-Steam game running under Proton Experimental.
#
#   curl -fsSL halo.jaxon.dev | bash
#   curl -fsSL halo.jaxon.dev | bash -s -- --ui-window
#
# --ui-window   sets RECLAIMER_UI_COMPOSITION=window, for missing or black menus/chat
# RECLAIMER_DIR=<path> installs somewhere other than ~/Games/ProjectReclaimer
#
# Re-running it updates the client to the latest release and repoints the shortcut.
set -euo pipefail

REPO=ProjectReclaimer/project-reclaimer-releases
APP_NAME="Project Reclaimer"
MCC_APPID=976730

say() { printf '\033[1;32m==>\033[0m %s\n' "$*"; }
warn() { printf '\033[1;33m!!\033[0m %s\n' "$*" >&2; }
die() { printf '\033[1;31mxx\033[0m %s\n' "$*" >&2; exit 1; }

# Binary shortcuts.vdf and text config.vdf editing, plus Steam library lookup.
read -r -d '' PY <<'PY' || true
import os, re, shutil, struct, sys, time, zlib

def bvdf_read(b, i):
    d = {}
    while True:
        t = b[i]; i += 1
        if t == 8:
            return d, i
        j = b.index(b'\0', i); k = b[i:j].decode('utf-8', 'surrogateescape'); i = j + 1
        if t == 0:
            v, i = bvdf_read(b, i)
        elif t == 1:
            j = b.index(b'\0', i); v = b[i:j].decode('utf-8', 'surrogateescape'); i = j + 1
        elif t == 2:
            v = struct.unpack_from('<I', b, i)[0]; i += 4
        else:
            sys.exit(f'shortcuts.vdf: unsupported field type {t}, not touching it')
        d[k] = v

def bvdf_write(d):
    out = b''
    for k, v in d.items():
        k = k.encode('utf-8', 'surrogateescape') + b'\0'
        if isinstance(v, dict):
            out += b'\0' + k + bvdf_write(v)
        elif isinstance(v, int):
            out += b'\2' + k + struct.pack('<I', v & 0xFFFFFFFF)
        else:
            out += b'\1' + k + v.encode('utf-8', 'surrogateescape') + b'\0'
    return out + b'\x08'

# Text VDF is kept as [key, value] pairs with strings left escaped, so a
# round trip doesn't change anything we didn't touch.
def tvdf_parse(s):
    toks, i, n = [], 0, len(s)
    while i < n:
        c = s[i]
        if c.isspace():
            i += 1
        elif s.startswith('//', i):
            i = s.find('\n', i)
            i = n if i < 0 else i
        elif c in '{}':
            toks.append(c); i += 1
        elif c == '"':
            j = i + 1
            while s[j] != '"':
                j += 2 if s[j] == '\\' else 1
            toks.append(('s', s[i + 1:j])); i = j + 1
        else:
            j = i
            while j < n and not s[j].isspace() and s[j] not in '{}"':
                j += 1
            toks.append(('s', s[i:j])); i = j
    pos = 0
    def block():
        nonlocal pos
        node = []
        while pos < len(toks) and toks[pos] != '}':
            key = toks[pos][1]; pos += 1
            if toks[pos] == '{':
                pos += 1; val = block(); pos += 1
            else:
                val = toks[pos][1]; pos += 1
            node.append([key, val])
        return node
    return block()

def tvdf_write(node, depth=0):
    out, tab = '', '\t' * depth
    for k, v in node:
        if isinstance(v, list):
            out += f'{tab}"{k}"\n{tab}{{\n{tvdf_write(v, depth + 1)}{tab}}}\n'
        else:
            out += f'{tab}"{k}"\t\t"{v}"\n'
    return out

def child(node, key, create=True):
    for kv in node:
        if kv[0].lower() == key.lower():
            return kv[1]
    if not create:
        return None
    new = []
    node.append([key, new])
    return new

def save(path, data):
    if os.path.exists(path):
        shutil.copy2(path, f'{path}.bak-reclaimer-{time.strftime("%Y%m%d%H%M%S")}')
    tmp = path + '.tmp'
    with open(tmp, 'wb') as f:
        f.write(data)
    os.replace(tmp, path)

def libraries(root):
    paths = [root]
    lf = os.path.join(root, 'steamapps', 'libraryfolders.vdf')
    if os.path.exists(lf):
        for _, v in child(tvdf_parse(open(lf, encoding='utf-8').read()), 'libraryfolders'):
            p = isinstance(v, list) and child(v, 'path', create=False)
            if p:
                paths.append(p.replace('\\\\', '\\'))
    seen = []
    for p in paths:
        p = os.path.realpath(p)
        if p not in seen and os.path.isdir(os.path.join(p, 'steamapps')):
            seen.append(p)
    return seen

def find_app(root, appid, dirname):
    for lib in libraries(root):
        if os.path.exists(os.path.join(lib, 'steamapps', f'appmanifest_{appid}.acf')):
            print(os.path.join(lib, 'steamapps', 'common', dirname))
            return
    sys.exit(1)

def steam_user(root):
    users = [u for u in os.listdir(os.path.join(root, 'userdata')) if u.isdigit() and u != '0']
    lu = os.path.join(root, 'config', 'loginusers.vdf')
    if len(users) != 1 and os.path.exists(lu):
        for sid, v in child(tvdf_parse(open(lu, encoding='utf-8').read()), 'users'):
            if child(v, 'MostRecent', create=False) == '1':
                acct = str(int(sid) - 76561197960265728)
                if acct in users:
                    return acct
    if not users:
        sys.exit('No Steam user found. Log in to Steam once, then run this again.')
    return max(users, key=lambda u: os.path.getmtime(os.path.join(root, 'userdata', u)))

def add_shortcut(root, exe, name, launch_options):
    user = steam_user(root)
    path = os.path.join(root, 'userdata', user, 'config', 'shortcuts.vdf')
    os.makedirs(os.path.dirname(path), exist_ok=True)
    shortcuts = {}
    if os.path.exists(path) and os.path.getsize(path):
        shortcuts = bvdf_read(open(path, 'rb').read(), 0)[0].get('shortcuts', {})

    entry = next((s for s in shortcuts.values()
                  if s.get('AppName', '').lower() == name.lower()
                  or 'project-reclaimer-client' in s.get('Exe', '')), None)
    if entry is None:
        entry = {
            'appid': zlib.crc32(f'"{exe}"{name}'.encode()) | 0x80000000,
            'AppName': name, 'Exe': '', 'StartDir': '', 'icon': '', 'ShortcutPath': '',
            'LaunchOptions': '', 'IsHidden': 0, 'AllowDesktopConfig': 1, 'AllowOverlay': 1,
            'OpenVR': 0, 'Devkit': 0, 'DevkitGameID': '', 'DevkitOverrideAppID': 0,
            'LastPlayTime': 0, 'FlatpakAppID': '', 'tags': {},
        }
        idx = max((int(k) for k in shortcuts if k.isdigit()), default=-1) + 1
        shortcuts[str(idx)] = entry
    entry['AppName'] = name
    entry['Exe'] = f'"{exe}"'
    entry['StartDir'] = os.path.dirname(exe) + '/'
    if launch_options is not None:
        entry['LaunchOptions'] = launch_options
    appid = entry['appid'] & 0xFFFFFFFF
    icon = add_art(os.path.join(root, 'userdata', user, 'config', 'grid'), appid)
    if icon and not entry.get('icon'):
        entry['icon'] = icon
    save(path, b'\0shortcuts\0' + bvdf_write(shortcuts) + b'\x08')
    return appid

# Library art in Steam's grid naming. Anything already there (e.g. art the user
# picked in Steam) is left alone. Failures are skipped; the shortcut works without art.
ART = {'p.jpg': 'portrait.jpg', '.jpg': 'capsule.jpg', '_hero.jpg': 'hero.jpg',
       '_logo.png': 'logo.png', '_icon.png': 'icon.png'}

def add_art(grid, appid):
    import glob, subprocess
    os.makedirs(grid, exist_ok=True)
    for suffix, src in ART.items():
        stem, ext = os.path.splitext(f'{appid}{suffix}')
        if glob.glob(os.path.join(grid, glob.escape(stem) + '.*')):
            continue
        dest = os.path.join(grid, stem + ext)
        if subprocess.run(['curl', '-fsSL', '--max-time', '60', '-o', dest + '.part',
                           f'https://halo.jaxon.dev/art/{src}']).returncode == 0:
            os.replace(dest + '.part', dest)
        else:
            print(f'Skipped artwork {src}', file=sys.stderr)
            if os.path.exists(dest + '.part'):
                os.remove(dest + '.part')
    icon = os.path.join(grid, f'{appid}_icon.png')
    return icon if os.path.exists(icon) else None

def set_compat_tool(root, appid, tool):
    path = os.path.join(root, 'config', 'config.vdf')
    tree = tvdf_parse(open(path, encoding='utf-8').read()) if os.path.exists(path) else []
    node = tree
    for key in ('InstallConfigStore', 'Software', 'Valve', 'Steam', 'CompatToolMapping'):
        node = child(node, key)
    entry = child(node, str(appid))
    entry[:] = [['name', tool], ['config', ''], ['priority', '250']]
    save(path, tvdf_write(tree).encode('utf-8'))

cmd, args = sys.argv[1], sys.argv[2:]
if cmd == 'find-app':
    find_app(*args)
elif cmd == 'install':
    root, exe, name, opts = args
    appid = add_shortcut(root, exe, name, None if opts == '-' else opts)
    set_compat_tool(root, appid, 'proton_experimental')
    print(appid)
PY

py() { python3 -I -c "$PY" "$@"; }

steam_running() { pgrep -x steam >/dev/null || pgrep -x steamwebhelper >/dev/null; }

main() {
  local launch_opts=-
  while (($#)); do
    case $1 in
      --ui-window) launch_opts='RECLAIMER_UI_COMPOSITION=window %command%' ;;
      *) die "Unknown option: $1" ;;
    esac
    shift
  done

  [[ ${XDG_CURRENT_DESKTOP:-} == gamescope ]] &&
    die "Switch to Desktop Mode first (Steam menu → Power → Switch to Desktop)."
  for bin in curl python3 sha256sum; do
    command -v "$bin" >/dev/null || die "Missing $bin."
  done

  local steam_root=${STEAM_ROOT:-}
  if [[ -z $steam_root ]]; then
    for d in "$HOME/.local/share/Steam" "$HOME/.steam/steam" "$HOME/.steam/root"; do
      [[ -d $d/steamapps ]] && { steam_root=$(realpath "$d"); break; }
    done
  fi
  if [[ -z $steam_root ]]; then
    [[ -d $HOME/.var/app/com.valvesoftware.Steam ]] &&
      die "Only Flatpak Steam was found. This script supports the regular Steam that ships with Bazzite and SteamOS."
    die "Couldn't find Steam. Install it, log in, and run this again."
  fi
  say "Steam: $steam_root"

  # 1. MCC with Halo 3
  local mcc
  if ! mcc=$(py find-app "$steam_root" "$MCC_APPID" "Halo The Master Chief Collection"); then
    warn "Halo: The Master Chief Collection isn't installed."
    warn "Opening the Steam install dialog. In MCC → Properties → DLC, keep Halo 3 Campaign"
    warn "and Halo 3 Multiplayer ticked (untick the rest to save space). Run this again once it's downloaded."
    steam "steam://install/$MCC_APPID" >/dev/null 2>&1 &
    exit 1
  fi
  if [[ ! -f $mcc/halo3/halo3.dll ]]; then
    die "MCC is installed but Halo 3 isn't (or is still downloading). In Steam, right-click MCC → Properties → DLC, tick Halo 3 Campaign and Halo 3 Multiplayer, let it finish, then run this again."
  fi
  say "Halo 3: $mcc/halo3"

  # 2. Latest client
  local dir=${RECLAIMER_DIR:-$HOME/Games/ProjectReclaimer}
  mkdir -p "$dir"
  local tag
  tag=$(curl -fsSL "https://api.github.com/repos/$REPO/releases/latest" |
    python3 -I -c 'import json,sys; print(json.load(sys.stdin)["tag_name"])') ||
    die "Couldn't reach GitHub to find the latest release."
  local exe_name="project-reclaimer-client-$tag.exe" base="https://github.com/$REPO/releases/download/$tag"
  local exe=$dir/$exe_name sum
  sum=$(curl -fsSL "$base/SHA256SUMS.txt" | grep -F " $exe_name") || die "No checksum for $exe_name."
  if [[ -f $exe ]] && (cd "$dir" && sha256sum -c --status <<<"$sum"); then
    say "Client $tag already downloaded"
  else
    say "Downloading client $tag"
    curl -fL --progress-bar -o "$exe.part" "$base/$exe_name"
    (cd "$dir" && sha256sum -c --status <<<"${sum/$exe_name/$exe_name.part}") ||
      { rm -f "$exe.part"; die "Checksum mismatch on the download. Try again."; }
    mv "$exe.part" "$exe"
  fi
  find "$dir" -maxdepth 1 -name 'project-reclaimer-client-v*.exe' ! -name "$exe_name" -delete

  # 3. Steam shortcut. Steam rewrites shortcuts.vdf and config.vdf on exit, so it has to be closed.
  local was_running=0
  if steam_running; then
    was_running=1
    say "Closing Steam so the shortcut sticks"
    steam -shutdown >/dev/null 2>&1 || true
    for _ in $(seq 60); do steam_running || break; sleep 1; done
    steam_running && die "Steam didn't close. Quit it from the tray icon and run this again."
  fi
  local appid
  appid=$(py install "$steam_root" "$exe" "$APP_NAME" "$launch_opts")
  say "Added \"$APP_NAME\" to Steam (Proton Experimental, app ID $appid)"

  if ((was_running)); then
    say "Starting Steam"
    setsid -f steam >/dev/null 2>&1 </dev/null
  fi

  cat <<EOF

Done. Find "$APP_NAME" in your Steam library and hit Play.
The first launch builds about 350 MB of caches, so give it a minute.
If Proton Experimental isn't installed yet, Steam downloads it on that first launch.
If menus, chat or loading screens are missing or black, run this again with --ui-window:
  curl -fsSL halo.jaxon.dev | bash -s -- --ui-window
EOF
}

main "$@"