if _ACTION == 'ninja' then
    require('ninja')
end

if _ACTION == 'export-compile-commands' then
    require('export-compile-commands')
end

workspace('rive')

newoption({
    trigger = 'config',
    description = 'one-and-only config (for multiple configs, target a new --out directory)',
    allowed = { { 'debug' }, { 'release' }, { nil } },
    default = nil,
})
newoption({ trigger = 'release', description = 'shortcut for \'--config=release\'' })
if _OPTIONS['release'] then
    if _OPTIONS['config'] then
        error('use either \'--release\' or \'--config=release/debug\' (not both)')
    end
    _OPTIONS['config'] = 'release'
    _OPTIONS['release'] = nil
elseif not _OPTIONS['config'] then
    _OPTIONS['config'] = 'debug'
end
RIVE_BUILD_CONFIG = _OPTIONS['config']

newoption({
    trigger = 'out',
    description = 'Directory to generate build files',
    default = nil,
})
RIVE_BUILD_OUT = _WORKING_DIR .. '/' .. (_OPTIONS['out'] or ('out/' .. RIVE_BUILD_CONFIG))

newoption({
    trigger = 'toolset',
    value = 'type',
    description = 'Choose which toolchain to build with',
    allowed = {
        { 'clang', 'Build with Clang' },
        { 'msc', 'Build with the Microsoft C/C++ compiler' },
    },
    default = 'clang',
})

newoption({
    trigger = 'arch',
    value = 'ABI',
    description = 'The ABI with the right toolchain for this build, generally with Android',
    allowed = {
        { 'host' },
        { 'x86' },
        { 'x64' },
        { 'arm' },
        { 'arm64' },
        { 'universal', '"fat" library on apple platforms' },
        { 'wasm', 'emscripten targeting web assembly' },
        { 'js', 'emscripten targeting javascript' },
    },
    default = 'host',
})

-- Premake stopped supporting "--os=android". Add our own flag for android.
newoption({
    trigger = 'for_android',
    description = 'compile for android (supersedes --os)',
})

newoption({
    trigger = 'android_api',
    description = 'Target Android API version number',
    default = '21',
})

newoption({
    trigger = 'variant',
    value = 'type',
    description = 'Choose a particular variant to build',
    allowed = {
        { 'system', 'Builds the static library for the provided system' },
        { 'emulator', 'Builds for a simulator for the provided system' },
        { 'xros', 'Builds for Apple Vision Pro' },
        { 'xrsimulator', 'Builds for Apple Vision Pro simulator' },
        { 'appletvos', 'Builds for Apple TV' },
        { 'appletvsimulator', 'Builds for Apple TV simulator' },
        { 'maccatalyst', 'Builds for Mac Catalyst' },
        {
            'runtime',
            'Build the static library specifically targeting our runtimes',
        },
    },
    default = 'system',
})

newoption({
    trigger = 'with-rtti',
    description = 'don\'t disable rtti (nonstandard for Rive)',
})

newoption({
    trigger = 'with-pic',
    description = 'enable position independent code',
})

newoption({
    trigger = 'with-exceptions',
    description = 'don\'t disable exceptions (nonstandard for Rive)',
})

newoption({
    trigger = 'no-wasm-simd',
    description = 'disable simd for wasm builds',
})

newoption({
    trigger = 'wasm_single',
    description = 'Embed wasm directly into the js, instead of side-loading it.',
})

newoption({
    trigger = 'no-lto',
    description = 'Don\'t build with link time optimizations.',
})

newoption({
    trigger = 'for_unreal',
    description = 'compile for unreal engine',
})

newoption({
    trigger = 'with-asan',
    description = 'enable AddressSanitizer',
})

newoption({
    trigger = 'with_ubsan',
    description = 'enable UndefinedBehaviorSanitizer',
})

newoption({ trigger = 'with_optick', description = 'use optick profiler' })
if _OPTIONS['with_optick'] then
    defines({ 'RIVE_OPTICK' })
    RIVE_OPTICK_URL = 'bombomby/optick'
    RIVE_OPTICK_VERSION = '1.4.0.0'
end

newoption({ trigger = 'with_microprofile', description = 'use microprofile profiler' })
if _OPTIONS['with_microprofile'] then
    defines({ 'RIVE_MICROPROFILE' })
    RIVE_MICROPROFILE_URL = 'aliasbinman/microprofile'
    RIVE_MICROPROFILE_VERSION = 'rivebuild'
end

newoption({
    trigger = 'prof_level_max',
    value = '0..4',
    description = 'Compile-time max tier for RIVE_PROF_SCOPE_L / GPUNAME_L / SCOPENAME_L. Markers with level > N drop at preprocess time. 0 = frame markers only (cheapest), 4 = everything. Default 0.',
})
if _OPTIONS['prof_level_max'] then
    defines({ 'RIVE_PROF_LEVEL_MAX=' .. _OPTIONS['prof_level_max'] })
end

location(RIVE_BUILD_OUT)
targetdir(RIVE_BUILD_OUT)
objdir(RIVE_BUILD_OUT .. '/obj')
toolset(_OPTIONS['toolset'] or 'clang')
language('C++')
cppdialect('C++17')
configurations({ 'default' })
filter({ 'options:not with-rtti' })
rtti('Off')
filter({ 'options:with-rtti' })
rtti('On')
filter({ 'options:not with-exceptions' })
exceptionhandling('Off')
filter({ 'options:with-exceptions' })
exceptionhandling('On')

filter({ 'options:with-asan' })
do
    sanitize({ 'Address' })

    -- Edit & continue and incremental link are not compatible with ASAN in MSVC.
    editandcontinue('Off')
    flags({ 'NoIncrementalLink' })
end

filter({ 'options:with_ubsan', 'system:not windows' })
do
    buildoptions({
        '-fsanitize=undefined',
        '-fno-sanitize-recover=all'
    })
    linkoptions({
        '-fsanitize=undefined',
        '-fno-sanitize-recover=all'
    })
end

filter({ 'options:with-pic' })
do
    pic('on')
    buildoptions({ '-fPIC' })
    linkoptions({ '-fPIC' })
end

filter('options:config=debug')
do
    defines({ 'DEBUG' })
    symbols('On')
end

filter('options:config=release')
do
    defines({ 'RELEASE' })
    defines({ 'NDEBUG' })
    optimize('On')
end

-- Generate PDBs in Release builds on Windows for Sentry crash symbolication.
filter({ 'options:config=release', 'system:windows' })
do
    symbols('On')
end

filter({ 'options:config=release', 'options:not no-lto', 'system:not macosx', 'system:not ios' })
do
    if linktimeoptimization then
        linktimeoptimization('On')
    else
        -- Deprecated way of turning on LTO, for older versions of premake.
        flags({ 'LinkTimeOptimization' })
    end
end

filter({ 'options:config=release', 'options:not no-lto', 'system:macosx or ios' })
do
    -- The 'linktimeoptimization' command attempts to use llvm-ar, which doesn't always exist on macos.
    buildoptions({ '-flto=full' })
    linkoptions({ '-flto=full' })
end

newoption({
    trigger = 'windows_runtime',
    description = 'Choose whether to use staticruntime on/off/default',
    allowed = {
        { 'default', 'Use default runtime' },
        { 'static', 'Use static runtime' },
        { 'dynamic', 'Use dynamic runtime' },
        { 'dynamic_debug', 'Use dynamic runtime force debug' },
        { 'dynamic_release', 'Use dynamic runtime force release' },
    },
    default = 'default',
})

newoption({
    trigger = 'toolsversion',
    value = 'msvc_toolsversion',
    description = 'specify the version of the compiler tool. On windows thats the msvc version which affects both clang and msvc outputs.',
    default = 'latest',
})

-- This is just to match our old windows config. Rive Native specifically sets
-- static/dynamic and maybe we should do the same elsewhere.
filter({ 'system:windows', 'options:windows_runtime=default', 'options:not for_unreal' })
do
    staticruntime('on') -- Match Skia's /MT flag for link compatibility
    runtime('Release')
end

filter({ 'system:windows', 'options:windows_runtime=static', 'options:not for_unreal' })
do
    staticruntime('on') -- Match Skia's /MT flag for link compatibility
end

filter({ 'system:windows', 'options:windows_runtime=dynamic', 'options:not for_unreal' })
do
    staticruntime('off')
end

filter({
    'system:windows',
    'options:not windows_runtime=default',
    'options:config=debug',
    'options:not for_unreal',
})
do
    runtime('Debug')
end

filter({
    'system:windows',
    'options:not windows_runtime=default',
    'options:config=release',
    'options:not for_unreal',
})
do
    runtime('Release')
end

filter({ 'system:windows', 'options:windows_runtime=dynamic_debug', 'options:not for_unreal' })
do
    staticruntime('off')
    runtime('Debug')
end

filter({ 'system:windows', 'options:windows_runtime=dynamic_release', 'options:not for_unreal' })
do
    staticruntime('off')
    runtime('Release')
end

filter('system:windows')
do
    architecture('x64')
    defines({ '_USE_MATH_DEFINES', 'NOMINMAX' })
end

filter({ 'system:windows', 'options:for_unreal' })
do
    staticruntime('off')
    runtime('Release')
end

-- Opt in to Incredibuild-friendly MSVC settings by setting
-- $RIVE_USE_INCREDIBUILD. (See also the Incredibuild handling in
-- build_rive.sh.)
if os.getenv('RIVE_USE_INCREDIBUILD') then
    -- Debug only: release enables LTO (/LTCG) above, which is incompatible with
    -- /INCREMENTAL -- the linker warns (LNK4075) and drops one of them.
    -- Incremental linking is a debug-iteration feature anyway, so scope it (and
    -- the rest of these tweaks) to debug, where LTO is already disabled.
    filter({ 'system:windows', 'options:not for_unreal', 'options:config=debug' })
    do
        if type(incrementallink) == 'function' then
            incrementallink('On')
        else
            -- Older Premake automatically passes /INCREMENTAL to Visual Studio Debug configs.
        end
        if linktimeoptimization then
            linktimeoptimization('Off') -- Disables /LTCG.
        else
            removeflags({ 'LinkTimeOptimization' })
        end
        symbols('On') -- Turns on MSVC debug symbol generation.
        editandcontinue('Off') -- Disables /ZI (Edit & Continue) and forces /Zi (Program Database).
        -- Embeds the debug symbols directly into each individual .obj file
        -- instead of a single shared PDB (/Z7), which can create contention on
        -- a massively parallel build. (The final monolithic PDB is then
        -- generated normally during the link step).
        debugformat "c7"
    end
end

-- Unreal requires c++20 under most circumstances. However, some platforms require 17. So make it a seperate flag
newoption({ trigger = 'cpp20', description = 'use c++ 20 standard' })
filter({'options:cpp20'})
do
    cppdialect('C++20')
end

-- Unreal "prefers" certain msvc versions so we try to match it from the python build script by using "toolsversion" option
-- this defaults to "latest" which will just do the default behavior anyway. So no need for a check
toolsversion(_OPTIONS['toolsversion'])

filter({ 'system:windows', 'options:toolset=clang' })
do
    buildoptions({
        '-Wno-c++98-compat',
        '-Wno-c++20-compat',
        '-Wno-c++98-compat-pedantic',
        '-Wno-c99-extensions',
        '-Wno-ctad-maybe-unsupported',
        '-Wno-deprecated-copy-with-user-provided-dtor',
        '-Wno-deprecated-declarations',
        '-Wno-documentation',
        '-Wno-documentation-pedantic',
        '-Wno-documentation-unknown-command',
        '-Wno-double-promotion',
        '-Wno-exit-time-destructors',
        '-Wno-float-equal',
        '-Wno-global-constructors',
        '-Wno-implicit-float-conversion',
        '-Wno-newline-eof',
        '-Wno-old-style-cast',
        '-Wno-reserved-identifier',
        '-Wno-shadow',
        '-Wno-sign-compare',
        '-Wno-sign-conversion',
        '-Wno-unused-macros',
        '-Wno-unused-parameter',
        '-Wno-four-char-constants',
        '-Wno-unreachable-code',
        '-Wno-switch-enum',
        '-Wno-missing-field-initializers',
        '-Wno-unsafe-buffer-usage',
    })
end

filter({ 'system:windows', 'options:toolset=msc' })
do
    -- MSVC doesn't accept designated initializers in C++17.
    cppdialect('c++latest')
    defines({
        '_CRT_SECURE_NO_WARNINGS',
        '_SILENCE_CXX20_IS_POD_DEPRECATION_WARNING',
        '_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS',
    })

    -- We currently suppress several warnings for the MSVC build, some serious. Once this build
    -- is fully integrated into GitHub actions, we will definitely want to address these.
    disablewarnings({
        '4061', -- enumerator 'identifier' in switch of enum 'enumeration' is not explicitly
        -- handled by a case label
        '4100', -- 'identifier': unreferenced formal parameter
        '4201', -- nonstandard extension used: nameless struct/union
        '4244', -- 'conversion_type': conversion from 'type1' to 'type2', possible loss of data
        '4245', -- 'conversion_type': conversion from 'type1' to 'type2', signed/unsigned
        --  mismatch
        '4267', -- 'variable': conversion from 'size_t' to 'type', possible loss of data
        '4355', -- 'this': used in base member initializer list
        '4365', -- 'expression': conversion from 'type1' to 'type2', signed/unsigned mismatch
        '4388', -- 'expression': signed/unsigned mismatch
        '4389', -- 'operator': signed/unsigned mismatch
        '4458', -- declaration of 'identifier' hides class member
        '4514', -- 'function': unreferenced inline function has been removed
        '4583', -- 'Catch::clara::detail::ResultValueBase<T>::m_value': destructor is not
        -- implicitly called
        '4623', -- 'Catch::AssertionInfo': default constructor was implicitly defined as deleted
        '4625', -- 'derived class': copy constructor was implicitly defined as deleted because a
        -- base class copy constructor is inaccessible or deleted
        '4626', -- 'derived class': assignment operator was implicitly defined as deleted
        --  because a base class assignment operator is inaccessible or deleted
        '4820', -- 'bytes' bytes padding added after construct 'member_name'
        '4868', -- (catch.hpp) compiler may not enforce left-to-right evaluation order in braced
        -- initializer list
        '5026', -- 'type': move constructor was implicitly defined as deleted
        '5027', -- 'type': move assignment operator was implicitly defined as deleted
        '5039', -- (catch.hpp) 'AddVectoredExceptionHandler': pointer or reference to
        -- potentially throwing function passed to 'extern "C"' function under -EHc.
        -- Undefined behavior may occur if this function throws an exception.
        '5045', -- Compiler will insert Spectre mitigation for memory load if /Qspectre switch
        -- specified
        '5204', -- 'Catch::Matchers::Impl::MatcherMethod<T>': class has virtual functions, but
        -- its trivial destructor is not virtual; instances of objects derived from this
        -- class may not be destructed correctly
        '5219', -- implicit conversion from 'type-1' to 'type-2', possible loss of data
        '5262', -- MSVC\14.34.31933\include\atomic(917,9): implicit fall-through occurs here;
        -- are you missing a break statement?
        '5264', -- 'rive::math::PI': 'const' variable is not used
        '4647', -- behavior change: __is_pod(rive::Vec2D) has different value in previous versions
    })
end

filter({ 'action:vs2022' })
do
    flags({ 'MultiProcessorCompile' })
end

filter({})

-- os.target() does not seem to be getting updated when system( ) is changed (for instance, when
-- building on Windows, it stays 'windows' even after we do system('android') which means if we
-- use it directly, we will include more things than are strictly necessary.
--
-- Instead, make an alias that we can use instead that we set manually based on calls to system()
-- Additionally, premake deprecated `--os=android` which is why the custom system() call is 
-- needed in the first place (otherwise the build script would just be passing it in)
rive_target_os = os.target()

-- Native Windows targets only. Android and wasm happen to build through ninja
-- on a Windows host too, but they retarget to the android_ndk/emsdk toolsets
-- below and would choke on these flags.
if os.host() == 'windows'
    and _ACTION == 'ninja'
    and not _OPTIONS['for_android']
    and _OPTIONS['arch'] ~= 'wasm'
    and _OPTIONS['arch'] ~= 'js'
then
    if _OPTIONS['toolset'] ~= 'clang' then
        error('Unsupported toolset ' .. _OPTIONS['toolset'] .. '. Only clang is supported on windows/ninja')
    end
    -- The vstudio actions compile through clang-cl, but ninja invokes the clang
    -- toolset's binaries directly, and premake's clang toolset names the GNU
    -- archiver 'ar', which doesn't exist on Windows. Rename just that binary to
    -- the llvm-ar that ships with Visual Studio.
    --
    -- Patch gettoolname in place rather than cloning into a new toolset the way
    -- android_ndk and emsdk do below: those target a different system, but this
    -- is still the clang toolset, and renaming it would stop every
    -- 'toolset:clang' filter in the tree from matching (libwebp's -msse4.1
    -- flags, for two).
    local win_clang_tools = { ar = 'llvm-ar' }
    local base_gettoolname = premake.tools.clang.gettoolname
    function premake.tools.clang.gettoolname(cfg, tool)
        return win_clang_tools[tool] or base_gettoolname(cfg, tool)
    end

    local WINDOWS_TARGET_ARCHS = {
        host = 'x86_64', -- the system:windows filter above pins architecture('x64') regardless
        x64 = 'x86_64',
        x86 = 'i686',
        arm64 = 'aarch64',
        arm = 'armv7',
    }
    local target_arch = WINDOWS_TARGET_ARCHS[_OPTIONS['arch']]
    if not target_arch then
        error('Unsupported arch ' .. _OPTIONS['arch'] .. ' for windows/ninja')
    end
    local target = '--target=' .. target_arch .. '-pc-windows-msvc'
    buildoptions({ target })

    -- clang++ links through MSVC's link.exe by default, which can't read the
    -- GNU thin archives some of our prebuilt dependencies ship (Dawn's
    -- webgpu_dawn.lib -> LNK1107). lld-link reads them, and is already what the
    -- vstudio ClangCL builds link with.
    linkoptions({ target, '-fuse-ld=lld' })
end

-- Don't use filter() here because we don't want to generate the "android_ndk" toolset if not
-- building for android.
if _OPTIONS['for_android'] then
    system('android')
    rive_target_os = 'android'

    pic('on') -- Position-independent code is required for NDK libraries.

    -- Detect the NDK.
    local EXPECTED_NDK_VERSION = 'r27c'
    local NDK_LONG_VERSION_STRING = "27.2.12479018"
    if _OPTIONS['for_unreal'] then
        EXPECTED_NDK_VERSION = '25.1.8937393'
        NDK_LONG_VERSION_STRING = '25.1.8937393'
    end
    ndk = os.getenv('NDK_PATH') or os.getenv('ANDROID_NDK') or '<undefined>'
    local ndk_version = '<undetected>'
    local ndk_long_version = '<undetected>'
    local f = io.open(ndk .. '/source.properties', 'r')
    if f then
        for line in f:lines() do
            local match = line:match('^Pkg.ReleaseName = (.+)$')
            if match then
                ndk_version = match
                break
            end
            match = line:match('^Pkg.Revision = (.+)$')
            if match then
                ndk_long_version = match
                break
            end
        end
        f:close()
    end
    if ndk_version ~= EXPECTED_NDK_VERSION and ndk_long_version ~= NDK_LONG_VERSION_STRING then
        print()
        print('** Rive requires Android NDK version ' .. EXPECTED_NDK_VERSION .. ' **')
        print()
        print('To install via Android Studio:')
        print('  - Settings > SDK Manager > SDK Tools')
        print('  - Check "Show Package Details" at the bottom')
        print('  - Select '..NDK_LONG_VERSION_STRING..' under "NDK (Side by side)"')
        print('  - Note the value of "Android SDK Location"')
        print()
        print('Then set the ANDROID_NDK environment variable:')
        print('  - export ANDROID_NDK="<Android SDK Location>/ndk/'..NDK_LONG_VERSION_STRING..'"')
        print()
        error(
            'Unsupported Android NDK\n  ndk: '
                .. ndk
                .. '\n  version: '
                .. ndk_version
                .. '\n  expected: '
                .. EXPECTED_NDK_VERSION
        )
    end

    local ndk_toolchain = ndk .. '/toolchains/llvm/prebuilt'
    if os.host() == 'windows' then
        ndk_toolchain = ndk_toolchain .. '/windows-x86_64'
    elseif os.host() == 'macosx' then
        ndk_toolchain = ndk_toolchain .. '/darwin-x86_64'
    else
        ndk_toolchain = ndk_toolchain .. '/linux-x86_64'
    end

    local android_base_targets = {
        arm64 = 'aarch64-linux-android',
        arm = 'armv7a-linux-androideabi',
        x64 = 'x86_64-linux-android',
        x86 = 'i686-linux-android',
    }
    local android_target = android_base_targets[_OPTIONS['arch']] .. _OPTIONS['android_api']

    -- clone the clang toolset into a custom one called "android_ndk".
    premake.tools.android_ndk = {}
    for k, v in pairs(premake.tools.clang) do
        premake.tools.android_ndk[k] = v
    end

    -- update the android_ndk toolset to use the appropriate binaries.
    local android_ndk_tools = { ar = ndk_toolchain .. '/bin/llvm-ar' }
    if os.host() == 'windows' then
        -- Invoke clang directly instead of going through the .cmd wrappers,
        -- which only add '--target=' and add a process layer between the build
        -- system and the compiler.
        android_ndk_tools.cc = ndk_toolchain .. '/bin/clang.exe --target=' .. android_target
        android_ndk_tools.cxx = ndk_toolchain .. '/bin/clang++.exe --target=' .. android_target
    else
        android_ndk_tools.cc = ndk_toolchain .. '/bin/' .. android_target .. '-clang'
        android_ndk_tools.cxx = ndk_toolchain .. '/bin/' .. android_target .. '-clang++'
    end
    function premake.tools.android_ndk.gettoolname(cfg, tool)
        return android_ndk_tools[tool]
    end

    -- suppress "** Warning: Unsupported toolset 'android_ndk'".
    local premake_valid_tools = premake.action._list[_ACTION].valid_tools
    if premake_valid_tools ~= nil then
        premake_valid_tools['cc'][#premake_valid_tools['cc'] + 1] = 'android_ndk'
    end

    toolset('android_ndk')

    buildoptions({
        '--sysroot=' .. ndk_toolchain .. '/sysroot',
        '-fdata-sections',
        '-ffunction-sections',
        '-funwind-tables',
        '-fstack-protector-strong',
        '-no-canonical-prefixes',
    })

    linkoptions({
        '--sysroot=' .. ndk_toolchain .. '/sysroot',
        '-fdata-sections',
        '-ffunction-sections',
        '-funwind-tables',
        '-fstack-protector-strong',
        '-no-canonical-prefixes',
        '-Wl,--fatal-warnings',
        '-Wl,--gc-sections',
        '-Wl,--no-rosegment',
        '-Wl,--no-undefined',
        '-static-libstdc++',
    })

    filter({})
end

filter('system:linux', 'options:arch=x64')
do
    architecture('x64')
end

filter('system:linux', 'options:arch=arm')
do
    architecture('arm')
end

filter('system:linux', 'options:arch=arm64')
do
    architecture('arm64')
end

filter({})

filter('system:macosx')
do
    defines({ 'RIVE_MACOSX' })
end

filter('system:windows')
do
    defines({ 'RIVE_WINDOWS' })
end

filter({})

if _OPTIONS['os'] == 'ios' then
    if _OPTIONS['variant'] == 'system' then
        iphoneos_sysroot = os.outputof('xcrun --sdk iphoneos --show-sdk-path')
        if iphoneos_sysroot == nil then
            error(
                'Unable to locate iPhoneOS SDK. Please ensure Xcode and its iOS component are installed. Additionally, ensure Xcode Command Line Tools are pointing to that Xcode location with `xcode-select -p`.'
            )
        end

        defines({ 'RIVE_IOS' })
        buildoptions({
            '--target=arm64-apple-ios13.0.0',
            '-mios-version-min=13.0.0',
            '-isysroot ' .. iphoneos_sysroot,
        })
    elseif _OPTIONS['variant'] == 'emulator' then
        iphonesimulator_sysroot = os.outputof('xcrun --sdk iphonesimulator --show-sdk-path')
        if iphonesimulator_sysroot == nil then
            error(
                'Unable to locate iPhone simulator SDK. Please ensure Xcode and its iOS component are installed.  Additionally, ensure Xcode Command Line Tools are pointing to that Xcode location with `xcode-select -p`.'
            )
        end

        defines({ 'RIVE_IOS_SIMULATOR' })
        buildoptions({
            '--target=arm64-apple-ios13.0.0-simulator',
            '-mios-version-min=13.0.0',
            '-isysroot ' .. iphonesimulator_sysroot,
        })
    elseif _OPTIONS['variant'] == 'xros' then
        xros_sysroot = os.outputof('xcrun --sdk xros --show-sdk-path')
        if xros_sysroot == nil then
            error(
                'Unable to locate xros sdk. Please ensure Xcode Command Line Tools are installed, as well as the visionOS SDK.'
            )
        end

        defines({ 'RIVE_XROS' })
        buildoptions({
            '--target=arm64-apple-xros1.0',
            '-isysroot ' .. xros_sysroot,
        })
    elseif _OPTIONS['variant'] == 'xrsimulator' then
        xrsimulator_sysroot = os.outputof('xcrun --sdk xrsimulator --show-sdk-path')
        if xrsimulator_sysroot == nil then
            error(
                'Unable to locate xrsimulator sdk. Please ensure Xcode Command Line Tools are installed, as well as the visionOS SDK.'
            )
        end

        defines({ 'RIVE_XROS_SIMULATOR' })
        buildoptions({
            '--target=arm64-apple-xros1.0-simulator',
            '-isysroot ' .. xrsimulator_sysroot,
        })
    elseif _OPTIONS['variant'] == 'appletvos' then
        appletvos_sysroot = os.outputof('xcrun --sdk appletvos --show-sdk-path')
        if appletvos_sysroot == nil then
            error(
                'Unable to locate appletvos sdk. Please ensure Xcode Command Line Tools are installed, as well as the tvOS SDK.'
            )
        end

        defines({ 'RIVE_APPLETVOS' })
        buildoptions({
            '--target=arm64-apple-tvos',
            '-mappletvos-version-min=16.0',
            '-isysroot ' .. appletvos_sysroot,
        })
    elseif _OPTIONS['variant'] == 'appletvsimulator' then
        appletvsimulator_sysroot = os.outputof('xcrun --sdk appletvsimulator --show-sdk-path')
        if appletvsimulator_sysroot == nil then
            error(
                'Unable to locate appletvsimulator sdk. Please ensure Xcode Command Line Tools are installed, as well as the tvOS SDK.'
            )
        end

        defines({ 'RIVE_APPLETVOS_SIMULATOR' })
        buildoptions({
            '--target=arm64-apple-tvos-simulator',
            '-mappletvsimulator-version-min=16.0',
            '-isysroot ' .. appletvsimulator_sysroot,
        })
    end

    filter({})
end

if os.host() == 'macosx' then
    filter('system:ios')
    do
        buildoptions({ '-fembed-bitcode ' })
    end

    filter('system:macosx or system:ios')
    do
        buildoptions({ '-fobjc-arc' })
    end

    filter({ 'system:macosx', 'options:not variant=maccatalyst' })
    do
        buildoptions({
            '-mmacosx-version-min=11.0',
        })
        -- Pass the deployment target at LINK time too. Without this, the linker
        -- stamps LC_BUILD_VERSION.minos from the build host's SDK, so a dylib
        -- built against a newer SDK can advertise a higher min OS version and
        -- fail to load on older macOS versions.
        --
        -- Note: buildoptions affects compilation only (e.g., availability macros)
        -- and does not influence the link step that stamps the final dylib.
        linkoptions({
            '-mmacosx-version-min=11.0',
        })
    end

    filter({ 'system:macosx', 'options:arch=host', 'action:xcode4' })
    do
        -- xcode tries to specify a target...
        buildoptions({
            '--target=' .. os.outputof('uname -m') .. '-apple-macos11.0',
        })
    end

    filter({ 'system:macosx', 'options:arch=arm64 or arch=universal' })
    do
        buildoptions({ '-arch arm64' })
        linkoptions({ '-arch arm64' })
    end

    filter({ 'system:macosx', 'options:arch=x64 or arch=universal' })
    do
        buildoptions({ '-arch x86_64' })
        linkoptions({ '-arch x86_64' })
    end

    filter({
        'system:ios',
        'options:variant=system',
        'options:arch=arm64 or arch=universal',
    })
    do
        buildoptions({ '-arch arm64' })
    end

    filter({
        'system:ios',
        'options:variant=emulator or variant=xrsimulator or variant=appletvsimulator',
        'options:arch=x64 or arch=universal',
    })
    do
        buildoptions({ '-arch x86_64' })
    end

    filter({
        'system:ios',
        'options:variant=emulator or variant=xrsimulator or variant=appletvsimulator',
        'options:arch=arm64 or arch=universal',
    })
    do
        buildoptions({ '-arch arm64' })
    end

    filter({
        'system:macosx',
        'options:variant=maccatalyst',
        'options:arch=arm64',
    })
    do
        buildoptions({ '-target arm64-apple-ios14.0-macabi' })
    end

    filter({
        'system:macosx',
        'options:variant=maccatalyst',
        'options:arch=x64',
    })
    do
        buildoptions({ '-target x86_64-apple-ios14.0-macabi' })
    end

    filter({})
end

if _OPTIONS['arch'] == 'wasm' or _OPTIONS['arch'] == 'js' then
    -- make a new system called "emscripten" so we don't try including host-os-specific files in the
    -- web build.
    premake.api.addAllowed('system', 'emscripten')

    -- clone the clang toolset into a custom one called "emsdk".
    premake.tools.emsdk = {}
    for k, v in pairs(premake.tools.clang) do
        premake.tools.emsdk[k] = v
    end

    -- update the emsdk toolset to use the appropriate binaries.
    local emsdk_tools = {
        cc = 'emcc',
        cxx = 'em++',
        ar = 'emar',
    }
    if os.host() == 'windows' then
        -- $PATH doesn't propogate to CreateProcess() on Windows. Resolve the
        -- paths and execute them explicitly as shell scripts.
        local emsdk_dir = os.getenv('EMSDK'):gsub("/", "\\")
        local emsdk_tools_dir = emsdk_dir .. "\\upstream\\emscripten\\"
        for key, value in pairs(emsdk_tools) do
            emsdk_tools[key] = "python3 " .. emsdk_tools_dir .. value .. ".py"
        end
    end
    function premake.tools.emsdk.gettoolname(cfg, tool)
        return emsdk_tools[tool]
    end

    -- suppress "** Warning: Unsupported toolset 'emsdk'".
    local premake_valid_tools = premake.action._list[_ACTION].valid_tools
    if premake_valid_tools ~= nil then
        premake_valid_tools['cc'][#premake_valid_tools['cc'] + 1] = 'emsdk'
    end

    system('emscripten')
    rive_target_os = 'emscripten'

    toolset('emsdk')

    linkoptions({ '-sALLOW_MEMORY_GROWTH=1', '-sDYNAMIC_EXECUTION=0' })

    filter('options:arch=wasm')
    do
        linkoptions({ '-sWASM=1' })
    end

    filter({ 'options:arch=wasm', 'options:not no-wasm-simd' })
    do
        buildoptions({ '-msimd128' })
    end

    filter({ 'options:arch=wasm', 'options:no-wasm-simd' })
    do
        linkoptions({ '-s MIN_SAFARI_VERSION=120000' })
    end

    filter('options:arch=js')
    do
        linkoptions({ '-sWASM=0' })
    end

    filter('options:wasm_single')
    do
        linkoptions({ '-sSINGLE_FILE=1' })
    end

    filter('options:config=release')
    do
        buildoptions({ '-Oz' })
    end

    filter({})
end

filter({})