#!/usr/bin/env python3

import json
import os
import re
import shutil
import subprocess
import sys

sys_re = re.compile("^/System")
usr_re = re.compile("^/usr/lib/")
exe_re = re.compile("@executable_path")

def is_user_lib(objfile, libname):
    return not sys_re.match(libname) and \
           not usr_re.match(libname) and \
           not exe_re.match(libname) and \
           "libobjc." not in libname and \
           "libSystem." not in libname and \
           "libc." not in libname and \
           "libgcc." not in libname and \
           os.path.basename(libname) != "Python" and \
           os.path.basename(objfile) not in libname and \
           "libswift" not in libname

def otool(objfile, rapths):
    output = subprocess.check_output(
        ["otool", "-L", objfile], universal_newlines=True,
    )
    libs = set()
    for line in output.splitlines():
        if not line.startswith("\t"):
            continue
        lib = line.split()[0]
        if is_user_lib(objfile, lib):
            libs.add(lib)

    libs_resolved = set()
    libs_relative = set()
    for lib in libs:
        lib_path = resolve_lib_path(objfile, lib, rapths)
        libs_resolved.add(lib_path)
        if lib_path != lib:
            libs_relative.add(lib)

    return libs_resolved, libs_relative

def iter_rpaths(objfile):
    output = subprocess.check_output(
        ["otool", "-l", objfile], universal_newlines=True,
    )
    path_re = re.compile(r"^\s*path (.*) \(offset \d*\)$")
    for line in output.splitlines():
        if match := path_re.match(line):
            yield match.group(1).strip()

def get_rapths(objfile):
    loader_path = os.path.dirname(objfile)
    return [
        # resolve @loader_path
        os.path.normpath(rpath.replace("@loader_path", loader_path, 1))
        for rpath in iter_rpaths(objfile)
    ]

def get_rpaths_dev_tools(binary):
    return [
        rpath for rpath in iter_rpaths(binary)
        if "Xcode" in rpath or "CommandLineTools" in rpath
    ]

def resolve_lib_path(objfile, lib, rapths):
    if os.path.exists(lib):
        return lib

    if lib.startswith("@rpath/"):
        lib = lib[len("@rpath/"):]
        for rpath in rapths:
            lib_path = os.path.join(rpath, lib)
            if os.path.exists(lib_path):
                return lib_path
    elif lib.startswith("@loader_path/"):
        lib = lib[len("@loader_path/"):]
        lib_path = os.path.normpath(os.path.join(objfile, lib))
        if os.path.exists(lib_path):
            return lib_path

    raise Exception("Could not resolve library: " + lib)

def check_vulkan_max_version(version):
    try:
        subprocess.check_output(
            ["pkg-config", "vulkan", f"--max-version={version}"],
        )
        return True
    except Exception:
        return False

def get_homebrew_prefix():
    # set default to standard ARM path, intel path is already in the vulkan
    # loader search array
    result = "/opt/homebrew"
    try:
        result = subprocess.check_output(
            ["brew", "--prefix"],
            universal_newlines=True,
            stderr=subprocess.DEVNULL,
        ).strip()
    except Exception:
        pass

    return result

def install_name_tool_change(old, new, objfile):
    subprocess.call(
        ["install_name_tool", "-change", old, new, objfile],
        stderr=subprocess.DEVNULL,
    )

def install_name_tool_id(name, objfile):
    subprocess.call(
        ["install_name_tool", "-id", name, objfile],
        stderr=subprocess.DEVNULL,
    )

def install_name_tool_add_rpath(rpath, binary):
    subprocess.call(["install_name_tool", "-add_rpath", rpath, binary])

def install_name_tool_delete_rpath(rpath, binary):
    subprocess.call(["install_name_tool", "-delete_rpath", rpath, binary])

def libraries(objfile, result=None, result_relative=None, rapths=None):
    if result is None:
        result = {}

    if result_relative is None:
        result_relative = set()

    if rapths is None:
        rapths = []

    rapths = get_rapths(objfile) + rapths
    libs_list, libs_relative = otool(objfile, rapths)
    result[objfile] = libs_list
    result_relative |= libs_relative

    for lib in libs_list:
        if lib not in result:
            libraries(lib, result, result_relative, rapths)

    return result, result_relative

def lib_path(binary):
    return os.path.join(os.path.dirname(binary), "lib")

def resources_path(binary):
    return os.path.join(os.path.dirname(binary), "../Resources")

def lib_name(lib):
    return os.path.join("@executable_path", "lib", os.path.basename(lib))

def process_libraries(libs_dict, libs_dyn, binary):
    libs_set = set(libs_dict)
    # Remove binary from libs_set to prevent a duplicate of the binary being
    # added to the libs directory.
    libs_set.remove(binary)

    for src in libs_set:
        name = lib_name(src)
        dst = os.path.join(lib_path(binary), os.path.basename(src))

        shutil.copy(src, dst)
        os.chmod(dst, 0o755)
        install_name_tool_id(name, dst)

        if src in libs_dict[binary]:
            install_name_tool_change(src, name, binary)

        for p in libs_set:
            if p in libs_dict[src]:
                install_name_tool_change(p, lib_name(p), dst)

        for lib in libs_dyn:
            install_name_tool_change(lib, lib_name(lib), dst)

    for lib in libs_dyn:
        install_name_tool_change(lib, lib_name(lib), binary)

def process_swift_libraries(binary):
    swift_stdlib_tool = subprocess.check_output(
        ["xcrun", "--find", "swift-stdlib-tool"],
        universal_newlines=True,
    ).strip()
    # from xcode11 on the dynamic swift libs reside in a separate directory from
    # the std one, might need versioned paths for future swift versions
    swift_lib_path = os.path.join(swift_stdlib_tool, "../../lib/swift-5.0/macosx")
    swift_lib_path = os.path.abspath(swift_lib_path)

    command = [
        swift_stdlib_tool, "--copy", "--platform", "macosx",
        "--scan-executable", binary, "--destination", lib_path(binary),
    ]

    if os.path.exists(swift_lib_path):
        command.extend(["--source-libraries", swift_lib_path])

    subprocess.check_output(command, universal_newlines=True)

    print(">> setting additional rpath for swift libraries")
    install_name_tool_add_rpath("@executable_path/lib", binary)

def process_vulkan_loader(binary, loader_name, loader_relative_folder, library_node):
    # https://github.com/KhronosGroup/Vulkan-Loader/blob/main/docs/LoaderDriverInterface.md#example-macos-driver-search-path
    # https://github.com/KhronosGroup/Vulkan-Loader/blob/main/docs/LoaderLayerInterface.md#macos-layer-discovery
    loader_system_search_folders = [
        os.path.join(os.path.expanduser("~"), ".config", loader_relative_folder),
        os.path.join("/etc/xdg", loader_relative_folder),
        os.path.join("/usr/local/etc", loader_relative_folder),
        os.path.join("/etc", loader_relative_folder),
        os.path.join(os.path.expanduser("~"), ".local/share", loader_relative_folder),
        os.path.join("/usr/local/share", loader_relative_folder),
        os.path.join("/usr/share", loader_relative_folder),
        os.path.join(get_homebrew_prefix(), "etc", loader_relative_folder),
        os.path.join(get_homebrew_prefix(), "share", loader_relative_folder), # old location
    ]

    loader_system_folder = ""
    loader_system_path = ""
    for loader_system_search_folder in loader_system_search_folders:
        if os.path.exists(loader_system_search_folder):
            loader_system_folder = loader_system_search_folder
            if os.path.exists(os.path.join(loader_system_folder, loader_name)):
                loader_system_path = os.path.join(loader_system_folder, loader_name)
                break

    if not loader_system_folder:
        print(">>> could not find loader folder " + loader_relative_folder)
        return

    if not loader_system_path:
        print(">>> could not find loader " + loader_name)
        return

    loader_bundle_folder = os.path.join(resources_path(binary), loader_relative_folder)
    loader_bundle_path = os.path.join(loader_bundle_folder, loader_name)
    library_relative_folder = "../../../Frameworks/"

    if not os.path.exists(loader_bundle_folder):
        os.makedirs(loader_bundle_folder)

    loader_system_file = open(loader_system_path)
    loader_json_data = json.load(loader_system_file)
    library_path = loader_json_data[library_node]["library_path"]
    library_system_path = os.path.join(loader_system_folder, library_path)

    if not os.path.exists(library_system_path):
        print(">>> could not find loader library " + library_system_path)
        return

    print(">>> modifying and writing loader json " + loader_name)
    loader_bundle_file = open(loader_bundle_path, "w")
    loader_library_name = os.path.basename(library_system_path)
    library_path = os.path.join(library_relative_folder, loader_library_name)
    loader_json_data[library_node]["library_path"] = library_path
    json.dump(loader_json_data, loader_bundle_file, indent=4)

    print(">>> copying loader library " + loader_library_name)
    framework_bundle_folder = os.path.join(
        loader_bundle_folder, library_relative_folder,
    )
    if not os.path.exists(framework_bundle_folder):
        os.makedirs(framework_bundle_folder)
    library_target_path = os.path.join(framework_bundle_folder, loader_library_name)
    shutil.copy(library_system_path, library_target_path)

def remove_dev_tools_rapths(binary):
    for path in get_rpaths_dev_tools(binary):
        install_name_tool_delete_rpath(path, binary)

def process(binary):
    binary = os.path.abspath(binary)
    if not os.path.exists(lib_path(binary)):
        os.makedirs(lib_path(binary))
    print(">> gathering all linked libraries")
    libs, libs_rel = libraries(binary)

    print(">> copying and processing all linked libraries")
    process_libraries(libs, libs_rel, binary)

    print(">> removing rpath definitions towards dev tools")
    remove_dev_tools_rapths(binary)

    print(">> copying and processing swift libraries")
    process_swift_libraries(binary)

    print(">> copying and processing vulkan loader")
    process_vulkan_loader(binary, "MoltenVK_icd.json", "vulkan/icd.d", "ICD")
    if check_vulkan_max_version("1.3.261.1"):
        process_vulkan_loader(
            binary,
            "VkLayer_khronos_synchronization2.json",
            "vulkan/explicit_layer.d",
            "layer",
        )

if __name__ == "__main__":
    process(sys.argv[1])
