#!/usr/bin/python3
import hashlib
import hmac
import json
import os
from pathlib import Path
import runpy
import secrets
import shutil
import socket
import subprocess
import sys
import tempfile
import threading
import xml.etree.ElementTree as ElementTree

BIN = Path(__file__).resolve().parent
RUNTIME = Path('/usr/local/lib/droiddeck-xbox')
DLLS = ('xgameruntime.dll', 'winhttp.dll', 'windows.web.dll', 'twinapi.appcore.dll', 'wintypes.dll', 'libnghttp2.dll')
CLASSES = {
    'twinapi.appcore.dll': ('Windows.ApplicationModel.DataTransfer.DataTransferManager',
                            'Windows.Security.ExchangeActiveSyncProvisioning.EasClientDeviceInformation',
                            'Windows.System.Profile.AnalyticsInfo', 'Windows.System.UserProfile.AdvertisingManager',
                            'Windows.UI.ViewManagement.ApplicationView'),
    'windows.web.dll': ('Windows.Data.Json.JsonArray', 'Windows.Data.Json.JsonObject', 'Windows.Data.Json.JsonValue'),
    'wintypes.dll': ('Windows.Foundation.PropertyValue', 'Windows.Foundation.Collections.PropertySet',
                     'Windows.Foundation.Metadata.ApiInformation', 'Windows.Storage.Streams.Buffer',
                     'Windows.Storage.Streams.DataWriter'),
}
CLASS_KEY = 'Software\\Microsoft\\WindowsRuntime\\ActivatableClassId\\'
VIEW_DRIVES = 'xwvutsrqponmlkjihgfe'


def bridge(upstream):
    key = secrets.token_hex(32).encode('ascii')
    server = socket.socket()
    server.bind(('127.0.0.1', 0))
    server.listen(16)
    clients = set()
    lock = threading.Lock()
    stopped = threading.Event()

    def forward(source, target):
        try:
            while not stopped.is_set():
                data = source.recv(65536)
                if not data:
                    break
                target.sendall(data)
        except OSError:
            pass
        finally:
            try:
                target.shutdown(socket.SHUT_WR)
            except OSError:
                pass

    def connect(client):
        remote = None
        try:
            client.settimeout(10)
            supplied = b''
            while len(supplied) < len(key):
                part = client.recv(len(key) - len(supplied))
                if not part:
                    return
                supplied += part
            if not hmac.compare_digest(supplied, key):
                return
            remote = socket.socket(socket.AF_UNIX)
            remote.connect(upstream)
            client.settimeout(None)
            with lock:
                clients.add(remote)
            writer = threading.Thread(target=forward, args=(client, remote), daemon=True)
            writer.start()
            forward(remote, client)
            writer.join(2)
        except OSError:
            pass
        finally:
            for sock in (client, remote):
                if sock is not None:
                    with lock:
                        clients.discard(sock)
                    sock.close()

    def accept():
        while not stopped.is_set():
            try:
                client, _ = server.accept()
            except OSError:
                break
            with lock:
                if len(clients) >= 64:
                    client.close()
                    continue
                clients.add(client)
            threading.Thread(target=connect, args=(client,), daemon=True).start()

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

    def close():
        stopped.set()
        server.close()
        with lock:
            for client in clients:
                try:
                    client.shutdown(socket.SHUT_RDWR)
                except OSError:
                    pass
                client.close()
            clients.clear()

    return server.getsockname()[1], key.decode('ascii'), close


def register_classes(proton, prefix, env):
    try:
        registry = (prefix / 'system.reg').read_text(encoding='utf-8', errors='replace')
    except OSError:
        return
    missing = [(name, dll) for dll, names in CLASSES.items() for name in names
               if '[%s]' % (CLASS_KEY + name).replace('\\', '\\\\') not in registry]
    if not missing:
        return
    text = 'Windows Registry Editor Version 5.00\r\n\r\n' + ''.join(
        '[HKEY_LOCAL_MACHINE\\%s%s]\r\n"DllPath"="C:\\\\windows\\\\system32\\\\%s"\r\n\r\n' % (CLASS_KEY, name, dll)
        for name, dll in missing)
    with tempfile.TemporaryDirectory(prefix='droiddeck-xbox-') as temporary:
        source = Path(temporary) / 'classes.reg'
        source.write_bytes(b'\xff\xfe' + text.encode('utf-16-le'))
        try:
            failed = subprocess.run([proton, 'run', 'reg.exe', 'import', 'Z:' + str(source).replace('/', '\\')],
                                    stdout=sys.stderr, env=env, timeout=90).returncode != 0
        except subprocess.TimeoutExpired:
            failed = True
    if failed:
        print('droiddeck-xbox: Windows Runtime class registration failed; launching without it', file=sys.stderr)


def game_config(exe):
    path = Path(exe)
    if not path.is_absolute():
        return None
    for folder in list(path.parents)[:4]:
        config = folder / 'MicrosoftGame.config'
        if config.is_file():
            return config
    return None


def windows_arguments(text):
    arguments, current, quoted, started, at = [], [], False, False, 0
    while at < len(text):
        char = text[at]
        if char == '\\':
            run = len(text) - at - len(text[at:].lstrip('\\'))
            at += run
            if at < len(text) and text[at] == '"':
                current.append('\\' * (run // 2))
                if run % 2:
                    current.append('"')
                    at += 1
            else:
                current.append('\\' * run)
            started = True
            continue
        if char == '"':
            if quoted and text[at + 1:at + 2] == '"':
                current.append('"')
                at += 2
                continue
            quoted = not quoted
            started = True
        elif char in ' \t' and not quoted:
            if started:
                arguments.append(''.join(current))
                current, started = [], False
        else:
            current.append(char)
            started = True
        at += 1
    if started:
        arguments.append(''.join(current))
    return arguments


def install_actions(config):
    try:
        root = ElementTree.fromstring(config.read_bytes())
    except (OSError, ElementTree.ParseError):
        return []
    actions = []
    for registration in root.iter():
        if registration.tag.rsplit('}', 1)[-1] != 'CustomInstallActions':
            continue
        folder = next((node.text or '' for node in registration if node.tag.rsplit('}', 1)[-1] == 'Folder'), '')
        for node in registration.iter():
            if node.tag.rsplit('}', 1)[-1] != 'InstallAction':
                continue
            name, file = node.get('Name', ''), node.get('File', '')
            parts = [part for part in (folder.strip() + '\\' + file).replace('/', '\\').split('\\') if part]
            if not name or not file or any(part in ('.', '..') or ':' in part for part in parts):
                continue
            target = config.parent.joinpath(*parts)
            try:
                inside = target.resolve().is_relative_to(config.parent.resolve())
            except OSError:
                inside = False
            if inside and target.is_file() and target.suffix.lower() in ('.msi', '.exe'):
                actions.append((name, target, windows_arguments(node.get('Arguments', ''))))
    return actions


def run_install_actions(proton, prefix, exe, env):
    config = game_config(exe)
    if config is None:
        return
    done = prefix / 'drive_c' / 'ProgramData' / 'DroidDeck' / 'install-actions'
    for name, target, arguments in install_actions(config):
        try:
            content = hashlib.sha256()
            with target.open('rb') as source:
                for block in iter(lambda: source.read(1 << 20), b''):
                    content.update(block)
            identity = hashlib.sha256(name.encode('utf-8') + b'\0' + content.digest()).hexdigest()[:24]
            marker = done / ('%s-%s' % (''.join(c for c in name if c.isalnum() or c in '-_')[:64], identity))
            if marker.exists():
                continue
        except OSError as error:
            print('droiddeck-xbox: install action %s could not be read (%s); launching without it' % (name, error), file=sys.stderr)
            continue
        windows = 'Z:' + str(target).replace('/', '\\')
        if target.suffix.lower() == '.msi':
            command = [proton, 'run', 'msiexec', '/i', windows, *arguments]
        else:
            command = [proton, 'run', windows, *arguments]
        try:
            code = subprocess.run(command, stdout=sys.stderr, env=env, timeout=600).returncode
        except (OSError, subprocess.TimeoutExpired):
            code = None
        if code != 0:
            print('droiddeck-xbox: install action %s did not finish; launching without it' % name, file=sys.stderr)
            continue
        try:
            done.mkdir(parents=True, exist_ok=True)
            marker.touch()
        except OSError as error:
            print('droiddeck-xbox: install action %s finished but could not be recorded (%s)' % (name, error), file=sys.stderr)


def view_drive(prefix, exe):
    path = Path(exe)
    view = next((parent for parent in path.parents if parent.name.startswith('droiddeck-xbox-')), None)
    if not path.is_absolute() or view is None:
        return exe, None
    devices = prefix / 'dosdevices'
    for letter in VIEW_DRIVES:
        link = devices / (letter + ':')
        staged = devices / ('.%s-%s' % (letter, secrets.token_hex(4)))
        try:
            if os.path.lexists(link) and (os.path.exists(link) or not os.readlink(link).startswith(str(view.parent.parent) + '/')):
                continue
            devices.mkdir(parents=True, exist_ok=True)
            staged.symlink_to(view.parent)
            os.replace(staged, link)
        except OSError:
            if os.path.lexists(staged):
                staged.unlink()
            continue
        return letter.upper() + ':\\' + str(path.relative_to(view.parent)).replace('/', '\\'), link
    return exe, None


def wine(argv, source_env=None):
    source_env = os.environ if source_env is None else source_env
    with open(source_env['DROIDDECK_XBOX_COMMAND_FILE'], encoding='utf-8') as file:
        command = json.load(file)
    if len(command) < 3 or command[1] != 'waitforexitandrun' or len(argv) != 1:
        raise ValueError('Invalid Xbox Proton invocation')
    env = dict(source_env)
    for name in ('DROIDDECK_XBOX_CREDENTIAL_SOCKET', 'DROIDDECK_XBOX_CREDENTIAL_PORT', 'DROIDDECK_XBOX_CREDENTIAL_KEY'):
        env.pop(name, None)
    env.pop('DROIDDECK_XBOX_COMMAND_FILE', None)
    prefix = Path(source_env['STEAM_COMPAT_DATA_PATH']) / 'pfx'
    prefix.parent.mkdir(parents=True, exist_ok=True)
    if not (prefix / 'system.reg').is_file():
        result = subprocess.run([command[0], 'run', 'cmd', '/c', 'exit', '0'], stdout=sys.stderr, env=env)
        if result.returncode:
            return result.returncode
    system = prefix / 'drive_c/windows/system32'
    system.mkdir(parents=True, exist_ok=True)
    for name in DLLS:
        target = system / name
        if target.is_symlink():
            target.unlink()
        shutil.copyfile(RUNTIME / 'windows' / name, target)
    register_classes(command[0], prefix, env)
    run_install_actions(command[0], prefix, argv[0], env)
    overrides = ';'.join(name[:-4] + '=n' for name in DLLS if name != 'libnghttp2.dll')
    env['WINEDLLOVERRIDES'] = overrides + ';' + env.get('WINEDLLOVERRIDES', '')
    exe, drive = view_drive(prefix, argv[0])
    try:
        return subprocess.call([*command[:2], exe, *command[3:]], env=env)
    finally:
        if drive is not None:
            try:
                drive.unlink()
            except OSError:
                pass


# PlayFab Game Saves picks its provider from the Gaming Runtime unless HKLM\SOFTWARE\Microsoft\GamingServices
# ForceUseInprocGameSaves is set, and its in-process provider needs a save folder the title never passes on Windows.
# The runtime has no GRTS saves, so titles such as Forza Horizon 6 stop with E:0-17. xodus-nexus ships a proxy
# (scripts/runtime-compat/playfab-save-folder.c, MIT) that keeps the title's own SDK as nexus_pgs_native.dll and
# supplies both; this stages it the same way.
PGS_PROXY = RUNTIME / 'compat' / 'PlayFabGameSave.dll'
PGS_NATIVE = 'nexus_pgs_native.dll'
PGS_EXPORTS = (
    'PFGameSaveFilesAddUserWithUiAsync', 'PFGameSaveFilesAddUserWithUiResult', 'PFGameSaveFilesGetFolder',
    'PFGameSaveFilesGetFolderSize', 'PFGameSaveFilesGetRemainingQuota', 'PFGameSaveFilesGetSaveDescriptionForDebug',
    'PFGameSaveFilesGetSaveDescriptionSizeForDebug', 'PFGameSaveFilesGetStatsJsonForDebug',
    'PFGameSaveFilesGetStatsJsonSizeForDebug', 'PFGameSaveFilesInitialize', 'PFGameSaveFilesIsConnectedToCloud',
    'PFGameSaveFilesPauseUploadForDebug', 'PFGameSaveFilesResetCloudAsync', 'PFGameSaveFilesResetCloudResult',
    'PFGameSaveFilesResumeUploadForDebug', 'PFGameSaveFilesSetActiveDeviceChangedCallback',
    'PFGameSaveFilesSetActiveDevicePollForceChangeForDebug', 'PFGameSaveFilesSetActiveDevicePollIntervalForDebug',
    'PFGameSaveFilesSetForceNullPendingManifestForDebug', 'PFGameSaveFilesSetForceOutOfStorageErrorForDebug',
    'PFGameSaveFilesSetForceSyncFailedErrorForDebug', 'PFGameSaveFilesSetMockDataFolderForDebug',
    'PFGameSaveFilesSetMockDeviceIdForDebug', 'PFGameSaveFilesSetMockForceOfflineForDebug',
    'PFGameSaveFilesSetMockManifestOffsetForDebug', 'PFGameSaveFilesSetMockRootFolderForDebug',
    'PFGameSaveFilesSetSaveDescriptionAsync', 'PFGameSaveFilesSetSaveDescriptionResult',
    'PFGameSaveFilesSetUiActiveDeviceContentionResponse', 'PFGameSaveFilesSetUiCallbacks',
    'PFGameSaveFilesSetUiConflictResponse', 'PFGameSaveFilesSetUiOutOfStorageResponse',
    'PFGameSaveFilesSetUiProgressResponse', 'PFGameSaveFilesSetUiSyncFailedResponse',
    'PFGameSaveFilesSetWriteManifestsToDiskForDebug', 'PFGameSaveFilesUiProgressGetProgress',
    'PFGameSaveFilesUninitializeAsync', 'PFGameSaveFilesUninitializeResult', 'PFGameSaveFilesUploadWithUiAsync',
    'PFGameSaveFilesUploadWithUiResult',
)


def pe_exports(data):
    """(export address table size, [(name, ordinal index, forwarder or None) for each named export]) of an x64
    PE image, or None. The table size also counts exports that have no name."""
    def u16(offset):
        return int.from_bytes(data[offset:offset + 2], 'little')

    def u32(offset):
        return int.from_bytes(data[offset:offset + 4], 'little')

    def string(offset):
        end = data.find(b'\0', offset)
        return None if offset is None or end < 0 else data[offset:end].decode('ascii', 'replace')

    if len(data) < 256 or data[:2] != b'MZ':
        return None
    pe = u32(60)
    if data[pe:pe + 4] != b'PE\0\0' or u16(pe + 4) != 0x8664:
        return None
    count, optional_size = u16(pe + 6), u16(pe + 20)
    optional = pe + 24
    if optional_size < 120 or u16(optional) != 0x20B or u32(optional + 108) < 1:
        return None
    sections = optional + optional_size

    def offset_of(address):
        for index in range(count):
            section = sections + index * 40
            start, size, raw = u32(section + 12), u32(section + 16), u32(section + 20)
            if start <= address < start + size and raw + address - start < len(data):
                return raw + address - start
        return None

    directory_rva, directory_size = u32(optional + 112), u32(optional + 116)
    directory = offset_of(directory_rva)
    if directory is None or u32(directory + 16) != 1:
        return None
    functions, names = u32(directory + 20), u32(directory + 24)
    function_table, name_table, ordinal_table = (offset_of(u32(directory + 28)), offset_of(u32(directory + 32)),
                                                 offset_of(u32(directory + 36)))
    if None in (function_table, name_table, ordinal_table):
        return None
    exports = []
    for index in range(names):
        name = string(offset_of(u32(name_table + 4 * index)))
        ordinal = u16(ordinal_table + 2 * index)
        address = u32(function_table + 4 * ordinal) if ordinal < functions else 0
        if name is None or not address:
            return None
        forward = string(offset_of(address)) if directory_rva <= address < directory_rva + directory_size else None
        exports.append((name, ordinal, forward))
    return functions, exports


def playfab_sdk(data):
    """The PlayFab Game Saves SDK the proxy was written for: exactly its 40 exports, all named, none forwarded."""
    parsed = pe_exports(data)
    if parsed is None or parsed[0] != len(PGS_EXPORTS):
        return False
    exports = parsed[1]
    return ([(name, ordinal) for name, ordinal, _ in exports] == list(zip(PGS_EXPORTS, range(len(PGS_EXPORTS))))
            and all(forward is None for _, _, forward in exports))


def playfab_proxy(data):
    """A save-folder proxy (this one or an earlier build): the same 40 exports, forwarding into nexus_pgs_native."""
    parsed = pe_exports(data)
    if parsed is None or parsed[0] != len(PGS_EXPORTS):
        return False
    exports = parsed[1]
    return ([name for name, _, _ in exports] == list(PGS_EXPORTS)
            and any((forward or '').startswith(PGS_NATIVE[:-4] + '.') for _, _, forward in exports))


def kept_sdk(native):
    """True when nexus_pgs_native.dll is a regular file holding a recognised SDK."""
    return not native.is_symlink() and native.is_file() and playfab_sdk(native.read_bytes())


def replace_file(directory, name, data):
    descriptor, temporary = tempfile.mkstemp(prefix='.droiddeck-pgs-', dir=directory)
    try:
        with os.fdopen(descriptor, 'wb') as file:
            file.write(data)
            file.flush()
            os.fsync(file.fileno())
        os.chmod(temporary, 0o644)
        os.replace(temporary, Path(directory) / name)
    except BaseException:
        try:
            os.unlink(temporary)
        except OSError:
            pass
        raise


def stage_playfab_proxy(folder):
    """Put the save-folder proxy in front of every PlayFab Game Saves SDK in the game folder. Returns how many."""
    try:
        proxy = PGS_PROXY.read_bytes()
    except OSError:
        return 0
    staged = 0
    for root, _, files in os.walk(folder):
        directory = Path(root)
        for name in files:
            if name.lower() != 'playfabgamesave.dll':
                continue
            path = directory / name
            native = directory / PGS_NATIVE
            try:
                if path.is_symlink():
                    continue
                data = path.read_bytes()
                if playfab_sdk(data):
                    # A first launch, or a game update that brought a new SDK: the update's copy becomes the native one,
                    # but only in place of nothing or of an earlier SDK copy, never over an unknown file or a link.
                    if os.path.lexists(native) and not kept_sdk(native):
                        print('droiddeck-xbox: unknown %s next to the PlayFab Game Saves SDK in %s; left unchanged'
                              % (PGS_NATIVE, directory), file=sys.stderr)
                        continue
                    replace_file(directory, PGS_NATIVE, data)
                elif not playfab_proxy(data):
                    print('droiddeck-xbox: PlayFab Game Saves SDK with unknown exports in %s; left unchanged' % directory,
                          file=sys.stderr)
                    continue
                elif not kept_sdk(native):
                    print('droiddeck-xbox: PlayFab save proxy without its SDK in %s; left unchanged' % directory,
                          file=sys.stderr)
                    continue
                if data != proxy:
                    replace_file(directory, name, proxy)
                staged += 1
            except OSError as error:
                print('droiddeck-xbox: PlayFab save proxy not staged in %s (%s)' % (directory, error), file=sys.stderr)
    return staged


def renew_lease(ask, channel, product, lease, stopped):
    while not stopped.wait(15):
        response = ask(channel, {'op': 'xbox-renew', 'id': product, 'lease': lease}, timeout=10)
        if response is not None and response.get('ok') is False:
            return


def launch(command, env):
    if len(command) < 3 or command[1] != 'waitforexitandrun' or env.get('DROIDDECK_XBOX_ACTIVE') == '1':
        return None
    try:
        store = runpy.run_path(str(BIN / 'droiddeck-store-launch'))
    except Exception as error:
        print('droiddeck-xbox: store detection unavailable (%s); stock launch' % error, file=sys.stderr)
        return None
    found = store['find_store_game'](command[2:])
    if found is None or found[1].get('store') != 'xbox':
        return None
    folder, sidecar = found
    for name in DLLS:
        if not (RUNTIME / 'windows' / name).is_file():
            raise RuntimeError('Xbox Windows runtime is missing; update the Linux runtime')
    launch_dir = env.get('DD_LAUNCH_DIR')
    if not launch_dir:
        raise RuntimeError('No Xbox account channel; start the game from DroidDeck')
    reply = store['ask'](Path(launch_dir) / 'stores', {'op': 'xbox-prepare', 'id': sidecar['id']}, timeout=190)
    if not reply or not reply.get('ok'):
        raise RuntimeError((reply or {}).get('reason') or 'Xbox account service is unavailable; sign in again and retry')
    stopped = threading.Event()
    close = lambda: None
    try:
        port, key, close = bridge(reply['socket'])

        threading.Thread(target=renew_lease, args=(store['ask'], Path(launch_dir) / 'stores',
                         sidecar['id'], reply['lease'], stopped), daemon=True).start()
        with tempfile.TemporaryDirectory(prefix='droiddeck-xbox-') as temporary:
            context = Path(temporary) / 'command.json'
            context.write_text(json.dumps(command), encoding='utf-8')
            context.chmod(0o600)
            owned_env = dict(env, DROIDDECK_XBOX_ACTIVE='1', DROIDDECK_XBOX_COMMAND_FILE=str(context),
                             XODUS_SOCKET=reply['socket'], XODUS_BRIDGE_PORT=str(port), XODUS_BRIDGE_KEY=key,
                             XODUS_LOG='off', RUST_LOG='off', XODUS_SAVE_SYNC='auto' if sidecar.get('cloud', True) else 'none')
            for name in ('DROIDDECK_XBOX_CREDENTIAL_SOCKET', 'DROIDDECK_XBOX_CREDENTIAL_PORT', 'DROIDDECK_XBOX_CREDENTIAL_KEY'):
                owned_env.pop(name, None)
            if reply.get('playfab'):
                owned_env['XODUS_XSTS_PLAYFAB'] = reply['playfab']
            # The runtime mounts DLC only inside this backend-owned workspace (E_NOTIMPL without it).
            mount_root = reply.get('mountRoot')
            if isinstance(mount_root, str) and mount_root.startswith('/'):
                owned_env['XODUS_MOUNT_ROOT'] = 'Z:' + mount_root.replace('/', '\\')
            content = folder / '.xbox-content'
            roots = []
            if content.is_dir():
                for entry in content.iterdir():
                    try:
                        marker = json.loads((entry / '.droiddeck-content.json').read_text())
                        if marker.get('parent') == sidecar['id'] and marker.get('productId') == entry.name and not entry.is_symlink():
                            roots.append('Z:' + str(entry).replace('/', '\\'))
                    except (OSError, ValueError, TypeError):
                        pass
            if roots:
                owned_env['XODUS_CONTENT_ROOTS'] = ';'.join(roots)
            # No DLL override for the proxy or the kept SDK: Wine has no builtin of either, so both load from the
            # game folder as they are. Forcing them native-only (as Nexus does) made Forza Horizon 6 fail with E:0-0-4.
            try:
                stage_playfab_proxy(folder)
            except Exception as error:
                print('droiddeck-xbox: PlayFab save proxy skipped (%s)' % error, file=sys.stderr)
            return wine([reply['exe']], owned_env)
    finally:
        stopped.set()
        close()
        store['ask'](Path(launch_dir) / 'stores', {'op': 'xbox-released', 'lease': reply['lease']})


if __name__ == '__main__':
    try:
        sys.exit(wine(sys.argv[1:]))
    except (OSError, ValueError, KeyError, RuntimeError):
        print('droiddeck-xbox: Xbox launch failed; check your account, runtime and package.', file=sys.stderr)
        sys.exit(1)
