#!/usr/bin/env python3
# Copyright (C) 2026 Apple Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
# THE POSSIBILITY OF SUCH DAMAGE.

"""
generate-cmake-xcode-project

Emits a thin Xcode project that wraps a CMake/Ninja build directory:
  - One PBXLegacyTarget that shells out to ninja, so Cmd-B is a ninja
    incremental (sub-second no-op) instead of a workspace dependency scan.
  - One scheme per discovered executable / .app bundle pointing directly at
    the ninja-built product, so Cmd-R launches under lldb.
  - Folder references to Source/, Tools/, and each <framework>/DerivedSources in
    the build dir, so the Project Navigator and Quick Open cover both checked-in
    and generated code.
  - An lldbinit that inverts the build's -fdebug-prefix-map so breakpoints
    set in the source editor resolve.

This is not `cmake -G Xcode` -- the Xcode generator routes compilation back
through Xcode's build system, reintroducing the script-phase / xcfilelist
overhead this project exists to avoid. Here ninja stays the build system;
Xcode is purely the debugger frontend.

Usage:
    Tools/Scripts/generate-cmake-xcode-project [build-dir]

Output:
    <build-dir>/WebKit.xcodeproj
    <build-dir>/lldbinit
"""

import argparse
import functools
import os
import plistlib
import re
import shutil
import struct
import subprocess
import sys
import uuid
from pathlib import Path


# Build-time helpers that happen to be Mach-O executables but are not useful
# debug targets. Filtered out of scheme generation.
BUILD_TOOL_NAMES = {
    "yasm",
    "LLIntOffsetsExtractor",
    "LLIntSettingsExtractor",
    "LayoutTestHelper",
    "ImageDiff",
}

# Mach-O magic numbers (thin + fat, both endians).
MACHO_MAGICS = {0xfeedface, 0xfeedfacf, 0xcefaedfe, 0xcffaedfe, 0xcafebabe, 0xbebafeca}


def pbxid(seed=None):
    """Xcode 96-bit object identifier (24 hex chars). Seeded IDs are stable
    across regenerations so scheme -> target references survive."""
    if seed:
        return uuid.uuid5(uuid.NAMESPACE_DNS, f"webkit.cmake.{seed}").hex[:24].upper()
    return uuid.uuid4().hex[:24].upper()


NINJA_TARGET_ID = pbxid("ninja-target")
PROJECT_NAME = "WebKit"

# Top-level source-tree directories exposed as folder references in the Project
# Navigator. Folder references (lastKnownFileType = folder) track the filesystem
# live, so the navigator matches `ls` without enumerating ~15,000 PBXFileReference
# entries the way the hand-maintained WebKit.xcodeproj does. Quick Open, gutter
# breakpoints, and Open Quickly all work against folder-reference contents.
#
# LayoutTests is intentionally omitted: at ~200,000 files it dominates Xcode's
# "Create build description" scan and turns a no-op Cmd-B into ~30 s. Tests can
# still be opened via File > Open or by path; they aren't useful for setting
# breakpoints anyway.
SOURCE_FOLDERS = ("Source", "Tools")


def find_ninja():
    p = shutil.which("ninja")
    if p:
        return p
    for candidate in ("/opt/homebrew/bin/ninja", "/usr/local/bin/ninja"):
        if os.path.exists(candidate):
            return candidate
    sys.exit("error: ninja not found on PATH")


@functools.lru_cache(maxsize=None)
def xcode_version_tag() -> str:
    """LastUpgradeCheck / LastUpgradeVersion want the Xcode version as a 4-digit
    MMmm string (Xcode 27.0 -> "2700", 17.2 -> "1720"). Matching the running
    Xcode suppresses the "project was created with an older Xcode" upgrade
    prompt on first open."""
    try:
        out = subprocess.check_output(["/usr/bin/xcrun", "xcodebuild", "-version"],
                                      text=True, stderr=subprocess.DEVNULL)
        m = re.search(r"Xcode\s+(\d+)(?:\.(\d+))?", out)
        if m:
            major, minor = int(m.group(1)), int(m.group(2) or 0)
            return f"{major:02d}{minor:02d}"
    except (OSError, subprocess.CalledProcessError):
        pass
    return "1600"


@functools.lru_cache(maxsize=None)
def read_build_ninja(build_dir: Path) -> str:
    """build.ninja is ~80-100 MB; read it once and let lru_cache hold it for
    the (short) lifetime of this script. Both read_isysroot and read_prefix_maps
    pull from it."""
    try:
        return (build_dir / "build.ninja").read_text()
    except OSError:
        return ""


@functools.lru_cache(maxsize=None)
def read_cmake_cache(build_dir: Path, key: str) -> str:
    try:
        for line in (build_dir / "CMakeCache.txt").read_text().splitlines():
            if line.startswith(f"{key}:"):
                return line.split("=", 1)[1]
    except OSError:
        pass
    return ""


def read_isysroot(build_dir: Path) -> str:
    """CMAKE_OSX_SYSROOT is often empty in the cache (CMake recomputes it from
    env on every configure). The authoritative value is the -isysroot flag
    baked into build.ninja -- using that guarantees the wrapper's SDKROOT
    matches what the existing object files were built against."""
    m = re.search(r"-isysroot\s+(\S+)", read_build_ninja(build_dir))
    if m:
        return m.group(1)
    return read_cmake_cache(build_dir, "CMAKE_OSX_SYSROOT")


# Variables Xcode may inject into the legacy-target environment even with
# passBuildSettingsInEnvironment = 0. If any of these reach a CMake reconfigure
# (triggered by ninja's build.ninja-regeneration rule whenever a CMakeLists.txt
# changes), CMake bakes the new values into every compile command and the next
# build is a full rebuild instead of a no-op. Scrub them.
XCODE_ENV_POLLUTANTS = (
    "SDKROOT", "SDK_NAME", "SDK_DIR", "PLATFORM_NAME", "PLATFORM_DIR",
    "MACOSX_DEPLOYMENT_TARGET", "IPHONEOS_DEPLOYMENT_TARGET",
    "ARCHS", "NATIVE_ARCH", "CURRENT_ARCH", "VALID_ARCHS",
    "LLVM_TARGET_TRIPLE_VENDOR", "LLVM_TARGET_TRIPLE_OS_VERSION",
    "LLVM_TARGET_TRIPLE_SUFFIX",
    "TOOLCHAINS", "CONFIGURATION", "CONFIGURATION_BUILD_DIR",
    "BUILT_PRODUCTS_DIR", "TARGET_BUILD_DIR", "OBJROOT", "SYMROOT",
    "CC", "CXX", "LD", "LDPLUSPLUS",
)


def generate_ninja_wrapper(build_dir: Path, ninja_path: str) -> Path:
    """Produce a hermetic launcher for ninja. The goal is bit-identical
    environment to a terminal `ninja -C <dir>` so that (a) no-op builds stay
    no-op, (b) ccache hits, and (c) any CMake reconfigure ninja triggers sees
    the same toolchain it was originally configured with."""
    sysroot = read_isysroot(build_dir)
    deployment = read_cmake_cache(build_dir, "CMAKE_OSX_DEPLOYMENT_TARGET")

    lines = [
        "#!/bin/sh",
        "# Generated by Tools/Scripts/generate-cmake-xcode-project.",
        "# Scrub Xcode-injected variables so CMake reconfigure (if ninja",
        "# triggers one) produces an identical build.ninja and the existing",
        "# object files / ccache entries remain valid.",
        "unset " + " ".join(XCODE_ENV_POLLUTANTS),
        "",
        "# Keep the inherited PATH (so user-installed tools the build relies on",
        "# -- ccache, python, perl modules -- remain reachable) but drop entries",
        "# Xcode prepends from inside its .app bundle, which would shadow the",
        "# system clang/ld and change CMake's compiler-ID detection.",
        'PATH=$(printf "%s" "$PATH" | /usr/bin/tr ":" "\\n" \\',
        '       | /usr/bin/grep -Ev "/Contents/Developer/|/Xcode[^/]*\\.app/" \\',
        '       | /usr/bin/paste -sd ":" -)',
        f'export PATH="{os.path.dirname(ninja_path)}:$PATH"',
    ]
    if sysroot:
        lines.append(f'export SDKROOT="{sysroot}"')
    else:
        lines.append('export SDKROOT="$(/usr/bin/xcrun --sdk macosx --show-sdk-path)"')
    if deployment:
        lines.append(f'export MACOSX_DEPLOYMENT_TARGET="{deployment}"')
    lines.append(f'exec "{ninja_path}" "$@"')

    wrapper = build_dir / "ninja-xcode-wrapper"
    wrapper.write_text("\n".join(lines) + "\n")
    wrapper.chmod(0o755)
    return wrapper


def is_macho_executable(path: Path) -> bool:
    if not (path.is_file() and os.access(path, os.X_OK)):
        return False
    try:
        with path.open("rb") as f:
            magic, = struct.unpack("<I", f.read(4))
        return magic in MACHO_MAGICS
    except (OSError, struct.error):
        return False


def discover_executables(build_dir: Path):
    """Yield (scheme_name, absolute_path, is_bundle) for every launchable
    product directly under build_dir. Re-run after building new targets."""
    for app in sorted(build_dir.glob("*.app")):
        yield app.stem, app, True
    for exe in sorted(build_dir.iterdir()):
        if exe.name in BUILD_TOOL_NAMES or exe.suffix in (".dylib", ".a"):
            continue
        if is_macho_executable(exe):
            yield exe.name, exe, False


def read_prefix_maps(build_dir: Path):
    """Extract -fdebug-prefix-map=FROM=TO pairs from build.ninja so the
    generated lldbinit exactly inverts whatever OptionsMac.cmake configured,
    rather than assuming a particular layout."""
    maps = []
    for from_path, to_token in set(re.findall(r"-fdebug-prefix-map=(\S+?)=(\S+)",
                                              read_build_ninja(build_dir))):
        maps.append((to_token, from_path))
    # Longer replacement tokens first so "build" sorts before ".".
    maps.sort(key=lambda m: -len(m[0]))
    return maps


def generate_pbxproj(build_dir: Path, source_dir: Path, ninja_path: str) -> str:
    ids = {k: pbxid(k) for k in (
        "project", "root_group", "products_group", "derived_group",
        "config_list_project", "config_list_target",
        "config_project", "config_target",
    )}
    ids["legacy_target"] = NINJA_TARGET_ID

    folder_refs = []
    folder_children = []
    for name in SOURCE_FOLDERS:
        if not (source_dir / name).is_dir():
            continue
        fid = pbxid(f"folder.{name}")
        folder_children.append(f"{fid} /* {name} */")
        folder_refs.append(
            f'\t\t{fid} /* {name} */ = {{\n'
            f'\t\t\tisa = PBXFileReference;\n'
            f'\t\t\tlastKnownFileType = folder;\n'
            f'\t\t\tname = {name};\n'
            f'\t\t\tpath = "{source_dir / name}";\n'
            f'\t\t\tsourceTree = "<absolute>";\n'
            f'\t\t}};'
        )

    # Build-dir DerivedSources, one folder ref per framework, grouped under a
    # "DerivedSources" PBXGroup so the navigator reads
    #   DerivedSources / WebKit / FooMessageReceiver.cpp
    # rather than exposing the whole build dir (which would drag in CMakeFiles
    # and *.o). Discovered at generation time so new frameworks appear after a
    # reconfigure.
    derived_children = []
    for d in sorted(build_dir.glob("*/DerivedSources")):
        if not any(d.iterdir()):
            continue
        framework = d.parent.name
        fid = pbxid(f"derived.{framework}")
        derived_children.append(f"{fid} /* {framework} */")
        folder_refs.append(
            f'\t\t{fid} /* {framework} */ = {{\n'
            f'\t\t\tisa = PBXFileReference;\n'
            f'\t\t\tlastKnownFileType = folder;\n'
            f'\t\t\tname = {framework};\n'
            f'\t\t\tpath = "{d}";\n'
            f'\t\t\tsourceTree = "<absolute>";\n'
            f'\t\t}};'
        )

    folder_refs_text = "\n".join(folder_refs)
    root_children = ", ".join(
        folder_children
        + [f'{ids["derived_group"]} /* DerivedSources */']
        + [f'{ids["products_group"]} /* Products */']
    )
    derived_children_text = ", ".join(derived_children)

    # passBuildSettingsInEnvironment = 0 keeps Xcode's ~200 build-setting env
    # vars (SDKROOT, ARCHS, etc.) out of the ninja invocation -- they would
    # perturb ccache hashes and the IDL preprocessor's -target flag handling.
    return f"""// !$*UTF8*$!
{{
\tarchiveVersion = 1;
\tclasses = {{}};
\tobjectVersion = 56;
\tobjects = {{
\t\t{ids["legacy_target"]} /* ninja */ = {{
\t\t\tisa = PBXLegacyTarget;
\t\t\tbuildArgumentsString = "-C {build_dir} $(ACTION)";
\t\t\tbuildConfigurationList = {ids["config_list_target"]};
\t\t\tbuildPhases = ();
\t\t\tbuildToolPath = "{ninja_path}";
\t\t\tbuildWorkingDirectory = "{source_dir}";
\t\t\tdependencies = ();
\t\t\tname = ninja;
\t\t\tpassBuildSettingsInEnvironment = 0;
\t\t\tproductName = ninja;
\t\t}};
\t\t{ids["project"]} /* Project */ = {{
\t\t\tisa = PBXProject;
\t\t\tattributes = {{
\t\t\t\tBuildIndependentTargetsInParallel = YES;
\t\t\t\tLastUpgradeCheck = {xcode_version_tag()};
\t\t\t}};
\t\t\tbuildConfigurationList = {ids["config_list_project"]};
\t\t\tcompatibilityVersion = "Xcode 14.0";
\t\t\tdevelopmentRegion = en;
\t\t\thasScannedForEncodings = 0;
\t\t\tknownRegions = (en, Base);
\t\t\tmainGroup = {ids["root_group"]};
\t\t\tproductRefGroup = {ids["products_group"]};
\t\t\tprojectDirPath = "";
\t\t\tprojectRoot = "";
\t\t\ttargets = ({ids["legacy_target"]});
\t\t}};
\t\t{ids["root_group"]} = {{
\t\t\tisa = PBXGroup;
\t\t\tchildren = ({root_children});
\t\t\tsourceTree = "<group>";
\t\t}};
\t\t{ids["products_group"]} /* Products */ = {{
\t\t\tisa = PBXGroup;
\t\t\tchildren = ();
\t\t\tname = Products;
\t\t\tsourceTree = "<group>";
\t\t}};
\t\t{ids["derived_group"]} /* DerivedSources */ = {{
\t\t\tisa = PBXGroup;
\t\t\tchildren = ({derived_children_text});
\t\t\tname = DerivedSources;
\t\t\tsourceTree = "<group>";
\t\t}};
{folder_refs_text}
\t\t{ids["config_project"]} /* Debug */ = {{
\t\t\tisa = XCBuildConfiguration;
\t\t\tbuildSettings = {{}};
\t\t\tname = Debug;
\t\t}};
\t\t{ids["config_target"]} /* Debug */ = {{
\t\t\tisa = XCBuildConfiguration;
\t\t\tbuildSettings = {{}};
\t\t\tname = Debug;
\t\t}};
\t\t{ids["config_list_project"]} = {{
\t\t\tisa = XCConfigurationList;
\t\t\tbuildConfigurations = ({ids["config_project"]});
\t\t\tdefaultConfigurationIsVisible = 0;
\t\t\tdefaultConfigurationName = Debug;
\t\t}};
\t\t{ids["config_list_target"]} = {{
\t\t\tisa = XCConfigurationList;
\t\t\tbuildConfigurations = ({ids["config_target"]});
\t\t\tdefaultConfigurationIsVisible = 0;
\t\t\tdefaultConfigurationName = Debug;
\t\t}};
\t}};
\trootObject = {ids["project"]};
}}
"""


def asan_options(build_dir: Path) -> str:
    """ASAN_OPTIONS for any process built with -fsanitize=address.
    allocator_may_return_null=1 matches Tools/Scripts/webkitpy/port/driver.py.
    The sandbox profiles allow ASan's sigaltstack/socketpair calls when
    preprocessed with -fsanitize=address (see PlatformMac.cmake), so no
    use_sigaltstack workaround is needed."""
    if "address" in read_cmake_cache(build_dir, "ENABLE_SANITIZERS"):
        return "allocator_may_return_null=1"
    return ""


def tsan_options(build_dir: Path) -> str:
    """TSAN_OPTIONS for any process built with -fsanitize=thread.
    Points at the in-tree suppressions file (JSC parallel-GC, JIT, allocator
    internals -- see Tools/Scripts/tsan_suppressions.txt). second_deadlock_stack
    gives both lock-order stacks; halt_on_error=0 lets a test surface multiple
    races in one run."""
    if "thread" not in read_cmake_cache(build_dir, "ENABLE_SANITIZERS"):
        return ""
    source_dir = Path(read_cmake_cache(build_dir, "CMAKE_HOME_DIRECTORY"))
    supp = source_dir / "Tools" / "Scripts" / "tsan_suppressions.txt"
    opts = "halt_on_error=0:second_deadlock_stack=1"
    if supp.exists():
        opts += f":suppressions={supp}"
    return opts


def bundle_identifier(app_path: Path, fallback_name: str) -> str:
    try:
        with (app_path / "Contents" / "Info.plist").open("rb") as f:
            return plistlib.load(f)["CFBundleIdentifier"]
    except (OSError, KeyError, plistlib.InvalidFileException):
        return f"org.WebKit.{fallback_name}"


def generate_scheme(name: str, executable_path: Path, is_bundle: bool,
                    build_dir: Path) -> str:
    if is_bundle:
        runnable = f"""
      <PathRunnable
         runnableDebuggingMode = "0"
         BundleIdentifier = "{bundle_identifier(executable_path, name)}"
         FilePath = "{executable_path}">
      </PathRunnable>"""
    else:
        runnable = f"""
      <PathRunnable
         runnableDebuggingMode = "0"
         FilePath = "{executable_path}">
      </PathRunnable>"""

    framework_path = f"{build_dir}:{build_dir}/lib"
    asan = asan_options(build_dir)
    tsan = tsan_options(build_dir)

    # Plain executables (jsc, testapi, ...) find their frameworks via LC_RPATH;
    # setting DYLD_FRAMEWORK_PATH on them would only redirect Xcode's injected
    # liblldbViewDebuggerSupport.dylib (which links system WebKit) to the
    # just-built one, which is pointless for binaries that don't use WebKit.
    #
    # App bundles need the full set, matching Tools/Scripts/run-minibrowser:
    # DYLD_FRAMEWORK_PATH for the UI process and __XPC_-prefixed copies that
    # launchd forwards (with the prefix stripped) to WebContent/Networking/GPU
    # children -- SIP would otherwise strip DYLD_* on the way to them. The
    # view-debugger redirect this causes is harmless because PlatformMac.cmake
    # makes WebKit.framework re-export WebKitLegacy, matching the system ABI.
    env = []
    if is_bundle:
        env += [
            ("DYLD_FRAMEWORK_PATH", framework_path),
            ("DYLD_LIBRARY_PATH", framework_path),
            ("__XPC_DYLD_FRAMEWORK_PATH", framework_path),
            ("__XPC_DYLD_LIBRARY_PATH", framework_path),
        ]
    if asan:
        env.append(("ASAN_OPTIONS", asan))
        if is_bundle:
            env.append(("__XPC_ASAN_OPTIONS", asan))
    if tsan:
        env.append(("TSAN_OPTIONS", tsan))
        if is_bundle:
            env.append(("__XPC_TSAN_OPTIONS", tsan))

    if env:
        entries = "".join(
            f"""
         <EnvironmentVariable
            key = "{k}"
            value = "{v}"
            isEnabled = "YES">
         </EnvironmentVariable>""" for k, v in env)
        env_vars = f"""
      <EnvironmentVariables>{entries}
      </EnvironmentVariables>"""
    else:
        env_vars = ""

    return f"""<?xml version="1.0" encoding="UTF-8"?>
<Scheme
   LastUpgradeVersion = "{xcode_version_tag()}"
   version = "1.7">
   <BuildAction
      parallelizeBuildables = "YES"
      buildImplicitDependencies = "YES">
      <BuildActionEntries>
         <BuildActionEntry
            buildForTesting = "YES"
            buildForRunning = "YES"
            buildForProfiling = "YES"
            buildForArchiving = "NO"
            buildForAnalyzing = "NO">
            <BuildableReference
               BuildableIdentifier = "primary"
               BlueprintIdentifier = "{NINJA_TARGET_ID}"
               BuildableName = "ninja"
               BlueprintName = "ninja"
               ReferencedContainer = "container:{PROJECT_NAME}.xcodeproj">
            </BuildableReference>
         </BuildActionEntry>
      </BuildActionEntries>
   </BuildAction>
   <TestAction
      buildConfiguration = "Debug"
      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
      shouldUseLaunchSchemeArgsEnv = "YES">
      <Testables/>
   </TestAction>
   <LaunchAction
      buildConfiguration = "Debug"
      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
      launchStyle = "0"
      useCustomWorkingDirectory = "NO"
      ignoresPersistentStateOnLaunch = "NO"
      debugDocumentVersioning = "NO"
      debugServiceExtension = "internal"
      allowLocationSimulation = "NO"
      customLLDBInitFile = "{build_dir}/lldbinit">{runnable}{env_vars}
   </LaunchAction>
   <ProfileAction
      buildConfiguration = "Debug"
      shouldUseLaunchSchemeArgsEnv = "YES"
      savedToolIdentifier = ""
      useCustomWorkingDirectory = "NO"
      debugDocumentVersioning = "NO">{runnable}
   </ProfileAction>
   <AnalyzeAction buildConfiguration = "Debug"/>
   <ArchiveAction buildConfiguration = "Debug" revealArchiveInOrganizer = "YES"/>
</Scheme>
"""


def generate_lldbinit(source_dir: Path, build_dir: Path) -> str:
    lines = ["# Generated by Tools/Scripts/generate-cmake-xcode-project"]
    for token, real_path in read_prefix_maps(build_dir):
        lines.append(f"settings append target.source-map {token} {real_path}")
    if not any("source-map" in l for l in lines):
        # Fall back to the conventional mapping if build.ninja was unreadable.
        lines.append(f"settings append target.source-map . {source_dir}")
        lines.append(f"settings append target.source-map build {build_dir}")
    formatters = source_dir / "Tools" / "lldb" / "lldb_webkit.py"
    if formatters.exists():
        lines.append("")
        lines.append(f"command script import {formatters}")
    return "\n".join(lines) + "\n"


def default_build_dir(source_dir: Path) -> Path:
    for cfg in ("Debug", "RelWithDebInfo", "Release"):
        candidate = source_dir / "WebKitBuild" / "cmake-mac" / cfg
        if (candidate / "CMakeCache.txt").exists():
            return candidate
    return source_dir / "WebKitBuild" / "cmake-mac" / "Release"


def main():
    script_dir = Path(__file__).resolve().parent
    source_dir = script_dir.parent.parent  # Tools/Scripts -> repo root

    ap = argparse.ArgumentParser(description=__doc__,
                                 formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("build_dir", nargs="?",
                    help="CMake binary dir (default: first configured "
                         "WebKitBuild/cmake-mac/{Debug,RelWithDebInfo,Release})")
    args = ap.parse_args()

    if args.build_dir:
        build_dir = Path(args.build_dir)
        if not build_dir.is_absolute():
            build_dir = (source_dir / build_dir).resolve()
    else:
        build_dir = default_build_dir(source_dir)

    if not (build_dir / "CMakeCache.txt").exists():
        sys.exit(f"error: {build_dir}/CMakeCache.txt not found -- run "
                 f"'cmake --preset mac-dev-release' first")

    ninja_path = find_ninja()
    wrapper = generate_ninja_wrapper(build_dir, ninja_path)

    proj = build_dir / f"{PROJECT_NAME}.xcodeproj"
    proj.mkdir(exist_ok=True)
    (proj / "project.pbxproj").write_text(
        generate_pbxproj(build_dir, source_dir, str(wrapper)))

    schemes_dir = proj / "xcshareddata" / "xcschemes"
    schemes_dir.mkdir(parents=True, exist_ok=True)

    schemes = list(discover_executables(build_dir))
    for name, path, is_bundle in schemes:
        (schemes_dir / f"{name}.xcscheme").write_text(
            generate_scheme(name, path, is_bundle, build_dir))

    # Xcode selects the alphabetically-first scheme by default; pin MiniBrowser
    # (or the first .app bundle) to orderHint 0 so a fresh open lands on the
    # thing most people want to debug. The management plist is per-user, which
    # is fine -- the project lives in the build dir and isn't shared.
    user = os.environ.get("USER", "default")
    mgmt_dir = proj / "xcuserdata" / f"{user}.xcuserdatad" / "xcschemes"
    mgmt_dir.mkdir(parents=True, exist_ok=True)
    preferred = next((n for n, _, b in schemes if b), schemes[0][0] if schemes else None)
    if preferred:
        ordered = [preferred] + sorted(n for n, _, _ in schemes if n != preferred)
        entries = "\n".join(
            f"\t\t<key>{n}.xcscheme_^#shared#^_</key>\n"
            f"\t\t<dict><key>orderHint</key><integer>{i}</integer></dict>"
            for i, n in enumerate(ordered)
        )
        (mgmt_dir / "xcschememanagement.plist").write_text(
            '<?xml version="1.0" encoding="UTF-8"?>\n'
            '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" '
            '"http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n'
            '<plist version="1.0">\n<dict>\n'
            '\t<key>SchemeUserState</key>\n\t<dict>\n'
            f'{entries}\n'
            '\t</dict>\n</dict>\n</plist>\n'
        )

    (build_dir / "lldbinit").write_text(generate_lldbinit(source_dir, build_dir))

    print(f"Generated {proj}")
    print(f"  {len(schemes)} scheme(s): "
          f"{', '.join(n for n, _, _ in schemes) or '(none yet -- build first, then re-run)'}")
    print(f"  lldbinit: {build_dir}/lldbinit")
    print()
    print(f"  open {proj}")
    print(f"  Cmd-B  -> {wrapper} -C {build_dir}")
    print(f"  Cmd-R  -> ninja, then launch + attach lldb")


if __name__ == "__main__":
    main()