# Adapted from obsproject/obs-plugintemplate (cmake/common/buildspec_common.cmake,
# master as of 2026-09-06). Deliberate changes from upstream, all recorded here
# so a future re-sync knows what to keep:
#
#   1. _setup_obs_studio builds and installs the `libobs` target, not
#      `obs-frontend-api`. This plugin's properties UI is plain
#      obs_properties_* and it never touches the frontend API, so building it
#      would only drag Qt back in -- which is the whole point of dropping qt6
#      from dependencies_list.
#   2. It passes -DENABLE_UI:BOOL=OFF and -DENABLE_SCRIPTING:BOOL=OFF as well
#      as upstream's -DENABLE_FRONTEND:BOOL=OFF. The pinned OBS (30.0.2)
#      predates the ENABLE_FRONTEND option and gates its Qt-dependent UI on
#      ENABLE_UI instead; without this the sub-build configures the whole
#      OBS UI and demands Qt.
#   3. Only the Release configuration is built and installed. Upstream builds
#      Debug as well; nothing here consumes a debug libobs, and it doubles the
#      slowest step in CI.
#   4. macOS uses the Ninja generator and a single architecture, not upstream's
#      Xcode generator and forced universal build. See the comment at that
#      branch: a runner with only the Command Line Tools has no xcodebuild.
#   5. Generator flags are built as CMake lists so each becomes its own argv
#      entry, rather than upstream's space-separated strings passed unquoted.
#   6. The install step targets the libobs subdirectory rather than the whole
#      build tree, so it does not trip over the install rules of targets that
#      were deliberately never built.
#   7. _resolve_versioned_macos_sdk exists at all -- see its own comment.
#   8. _patch_obs_studio_w32_pthreads exists at all -- see its own comment.
#

include_guard(GLOBAL)

# _check_deps_version: Checks for obs-deps VERSION file in prefix paths
function(_check_deps_version version)
  set(found FALSE)

  foreach(path IN LISTS CMAKE_PREFIX_PATH)
    if(EXISTS "${path}/share/obs-deps/VERSION")
      if(dependency STREQUAL qt6 AND NOT EXISTS "${path}/lib/cmake/Qt6/Qt6Config.cmake")
        set(found FALSE)
        continue()
      endif()

      file(READ "${path}/share/obs-deps/VERSION" _check_version)
      string(REPLACE "\n" "" _check_version "${_check_version}")
      string(REPLACE "-" "." _check_version "${_check_version}")
      string(REPLACE "-" "." version "${version}")

      if(_check_version VERSION_EQUAL version)
        set(found TRUE)
        break()
      elseif(_check_version VERSION_LESS version)
        message(
          AUTHOR_WARNING
          "Older ${label} version detected in ${path}: \n"
          "Found ${_check_version}, require ${version}"
        )
        list(REMOVE_ITEM CMAKE_PREFIX_PATH "${path}")
        list(APPEND CMAKE_PREFIX_PATH "${path}")
        set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH})
        continue()
      else()
        message(
          AUTHOR_WARNING
          "Newer ${label} version detected in ${path}: \n"
          "Found ${_check_version}, require ${version}"
        )
        set(found TRUE)
        break()
      endif()
    endif()
  endforeach()

  return(PROPAGATE found CMAKE_PREFIX_PATH)
endfunction()

# _resolve_versioned_macos_sdk: return an SDK path that satisfies OBS's own
# macOS SDK version check.
#
# Not upstream. OBS 30.0.2's cmake/macos/compilerconfig.cmake reads the SDK
# version straight out of CMAKE_OSX_SYSROOT with this regex:
#
#   ".+/MacOSX.platform/Developer/SDKs/MacOSX([0-9]+\\.[0-9])+\\.sdk$"
#
# and hard-fails if it does not match ("Your macOS SDK version () is too low",
# with an empty version, which is the tell). That pattern only ever matches a
# full-Xcode SDK path; a Command-Line-Tools-only install has its SDK at
# /Library/Developer/CommandLineTools/SDKs/MacOSX<ver>.sdk, with no
# MacOSX.platform/Developer/SDKs segment at all, and can never match.
#
# Upstream never hits this because it uses the Xcode generator, where
# CMAKE_OSX_SYSROOT stays the literal string "macosx" and Xcode resolves it
# late. This project uses Ninja (the CI runner has no xcodebuild), so CMake
# resolves the sysroot eagerly and the regex runs against a real path.
#
# So: if the toolchain's own SDK path already matches, use it untouched.
# Otherwise build a symlink tree under the build directory whose shape matches
# the regex and which points at exactly the same SDK. Nothing about the
# compilation changes -- only the spelling of the path, which is all the check
# reads.
function(_resolve_versioned_macos_sdk out_path)
  set(${out_path} "" PARENT_SCOPE)

  execute_process(
    COMMAND xcrun --show-sdk-path
    OUTPUT_VARIABLE _sdk
    OUTPUT_STRIP_TRAILING_WHITESPACE
    RESULT_VARIABLE _rc
    ERROR_QUIET
  )
  if(NOT _rc EQUAL 0 OR NOT _sdk)
    message(WARNING "Could not determine the macOS SDK path via xcrun; leaving CMAKE_OSX_SYSROOT alone.")
    return()
  endif()

  if(_sdk MATCHES "/MacOSX\\.platform/Developer/SDKs/MacOSX[0-9]+\\.[0-9]+\\.sdk$")
    set(${out_path} "${_sdk}" PARENT_SCOPE)
    return()
  endif()

  execute_process(
    COMMAND xcrun --show-sdk-version
    OUTPUT_VARIABLE _sdk_version
    OUTPUT_STRIP_TRAILING_WHITESPACE
    RESULT_VARIABLE _rc
    ERROR_QUIET
  )
  if(NOT _rc EQUAL 0 OR NOT _sdk_version MATCHES "^([0-9]+)\\.([0-9]+)")
    message(WARNING "Could not determine the macOS SDK version via xcrun (got '${_sdk_version}').")
    return()
  endif()
  set(_short "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}")

  # Deliberately under the BUILD directory, not .deps/: cmake/macos/
  # buildspec.cmake runs `xattr -r -d com.apple.quarantine` over the whole
  # dependency directory, which would follow this symlink into the read-only
  # system SDK and fail with "Permission denied".
  set(_link_dir "${CMAKE_BINARY_DIR}/macos-sdk/MacOSX.platform/Developer/SDKs")
  set(_link "${_link_dir}/MacOSX${_short}.sdk")
  file(MAKE_DIRECTORY "${_link_dir}")
  if(NOT EXISTS "${_link}")
    file(CREATE_LINK "${_sdk}" "${_link}" SYMBOLIC)
  endif()
  if(EXISTS "${_link}")
    message(STATUS "macOS SDK ${_short} at ${_sdk}; presenting it to OBS as ${_link}")
    set(${out_path} "${_link}" PARENT_SCOPE)
  else()
    message(WARNING "Could not create the versioned macOS SDK symlink at ${_link}.")
  endif()
endfunction()

# _patch_obs_studio_w32_pthreads: Windows-only. Confirmed at every obs-studio
# tag from 30.0.2 through 31.1.1 (checked directly against
# libobs/cmake/os-windows.cmake and the top-level CMakeLists.txt at each tag):
# libobs/cmake/os-windows.cmake unconditionally links `OBS::w32-pthreads`, but
# that target is defined only by deps/w32-pthreads/CMakeLists.txt, and nothing
# in the OBS_CMAKE_VERSION>=3.0.0 ("modern") top-level CMakeLists.txt branch --
# the one -DOBS_CMAKE_VERSION=3.0.0 selects -- ever adds deps/w32-pthreads.
# libobs/CMakeLists.txt itself only adds deps/libcaption and deps/uthash.
#
# Upstream obs-studio's own CI never hits this because it builds with
# ENABLE_UI left ON: UI/cmake/os-windows.cmake happens to add
# deps/w32-pthreads too (guarded by `if(NOT TARGET OBS::w32-pthreads)`), which
# satisfies libobs's link by the time CMake generates -- purely as a side
# effect of Qt still being in the build, not because anything wires
# w32-pthreads to libobs on purpose. This bootstrap deliberately builds with
# ENABLE_UI:BOOL=OFF (see the file header) specifically to avoid pulling in
# Qt6, so that side effect never happens here, and the gap is exposed.
#
# Rather than re-enable ENABLE_UI (and pay for a ~100 MB Qt6 download this
# plugin's plain obs_properties_* UI does not need) or vendor a full copy of
# deps/CMakeLists.txt, patch libobs/CMakeLists.txt to add the one missing
# subdirectory itself, using the exact same existence guard
# UI/cmake/os-windows.cmake already relies on. Idempotent: running this again
# against an already-patched tree is a no-op (the search text no longer
# matches), so it is safe to call on every configure regardless of whether
# .deps/ was freshly extracted or reused from a previous run.
function(_patch_obs_studio_w32_pthreads)
  set(_cmakelists "${dependencies_dir}/${_obs_destination}/libobs/CMakeLists.txt")
  if(NOT EXISTS "${_cmakelists}")
    message(FATAL_ERROR "Cannot apply the w32-pthreads workaround: ${_cmakelists} does not exist.")
  endif()

  file(READ "${_cmakelists}" _contents)

  string(FIND "${_contents}" "deps/w32-pthreads" _already_patched)
  if(NOT _already_patched EQUAL -1)
    message(STATUS "libobs/CMakeLists.txt already carries the w32-pthreads workaround - skipping")
    return()
  endif()

  set(_needle "if(OS_WINDOWS)\n  include(cmake/os-windows.cmake)")
  set(_replacement
      "if(OS_WINDOWS)\n  if(NOT TARGET OBS::w32-pthreads)\n    add_subdirectory(\"\${CMAKE_SOURCE_DIR}/deps/w32-pthreads\" \"\${CMAKE_BINARY_DIR}/deps/w32-pthreads\")\n  endif()\n  include(cmake/os-windows.cmake)"
  )

  string(FIND "${_contents}" "${_needle}" _pos)
  if(_pos EQUAL -1)
    message(
      FATAL_ERROR
      "Could not find the expected 'if(OS_WINDOWS) / include(cmake/os-windows.cmake)' block in "
      "${_cmakelists} to apply the w32-pthreads workaround. obs-studio's libobs/CMakeLists.txt "
      "layout may have changed since this was written against 30.0.2."
    )
  endif()

  string(REPLACE "${_needle}" "${_replacement}" _patched "${_contents}")
  file(WRITE "${_cmakelists}" "${_patched}")
  message(
    STATUS
    "Patched ${_cmakelists}: added deps/w32-pthreads so OBS::w32-pthreads exists "
    "(obs-studio's modern Windows CMake path never defines it with ENABLE_UI=OFF)."
  )
endfunction()

# _setup_obs_studio: Create obs-studio build project, then build libobs and obs-frontend-api
function(_setup_obs_studio)
  if(NOT libobs_DIR)
    set(_is_fresh --fresh)
  endif()

  # Every generator-specific flag is built as a proper CMake list, so each
  # element becomes its own argv entry. Upstream packs several flags into one
  # space-separated string and passes it unquoted, which execute_process hands
  # to cmake as a single argument -- it happens not to matter there because
  # those flags are optional, but -DCMAKE_BUILD_TYPE is not.
  set(_cmake_arch "")
  set(_cmake_extra "")

  if(OS_WINDOWS)
    set(_cmake_generator "${CMAKE_GENERATOR}")
    # Plain "-A x64", NOT upstream's "-A x64,version=<Windows SDK>". With a
    # current CMake the ",version=" suffix comes back out verbatim in the
    # sub-build's CMAKE_VS_PLATFORM_NAME, and obs-studio's OWN dependency
    # downloader keys its release assets off that value -- so the sub-configure
    # goes looking for a file that cannot exist:
    #
    #   string sub-command JSON member 'hashes windows-x64,version=10.0.26100.0'
    #     not found
    #   Unable to download .../windows-deps-2023-11-03-x64,version=10.0.26100.0.zip
    #
    # The Windows SDK is selected automatically anyway ("Selecting Windows SDK
    # version 10.0.26100.0"), and CMAKE_SYSTEM_VERSION is passed below.
    list(APPEND _cmake_arch -A "${arch}")
    list(APPEND _cmake_extra "-DCMAKE_SYSTEM_VERSION=${CMAKE_SYSTEM_VERSION}")
  elseif(OS_MACOS)
    # Ninja, not upstream's Xcode generator. A runner with only the Command
    # Line Tools installed has no xcodebuild, and the Xcode generator then
    # fails the OBS sub-configure outright with "No CMAKE_C_COMPILER could be
    # found" -- observed on the `home-mac` CI runner. Ninja is single-config,
    # hence the explicit CMAKE_BUILD_TYPE below.
    set(_cmake_generator "Ninja")
    # Single-architecture, not upstream's forced universal build: this plugin
    # is built for one architecture anyway (client-sdk-cpp ships single-arch
    # dylibs), so building libobs universal would double the slowest step in
    # CI for a slice nothing links against.
    if(CMAKE_OSX_ARCHITECTURES)
      list(APPEND _cmake_arch "-DCMAKE_OSX_ARCHITECTURES:STRING=${CMAKE_OSX_ARCHITECTURES}")
    endif()
    list(APPEND _cmake_extra "-DCMAKE_BUILD_TYPE=Release")
    if(CMAKE_OSX_DEPLOYMENT_TARGET)
      list(APPEND _cmake_extra "-DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}")
    endif()
    _resolve_versioned_macos_sdk(_sdk_path)
    if(_sdk_path)
      list(APPEND _cmake_extra "-DCMAKE_OSX_SYSROOT=${_sdk_path}")
    endif()
  endif()

  message(STATUS "Configure ${label} (${arch})")
  execute_process(
    COMMAND
      "${CMAKE_COMMAND}" -S "${dependencies_dir}/${_obs_destination}" -B
      "${dependencies_dir}/${_obs_destination}/build_${arch}" -G ${_cmake_generator} ${_cmake_arch}
      -DOBS_CMAKE_VERSION:STRING=3.0.0 -DENABLE_PLUGINS:BOOL=OFF -DENABLE_FRONTEND:BOOL=OFF
      -DENABLE_UI:BOOL=OFF -DENABLE_SCRIPTING:BOOL=OFF -DENABLE_BROWSER:BOOL=OFF
      -DOBS_VERSION_OVERRIDE:STRING=${_obs_version} "-DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH}" ${_is_fresh}
      ${_cmake_extra}
    RESULT_VARIABLE _process_result
    COMMAND_ERROR_IS_FATAL ANY
  )
  message(STATUS "Configure ${label} (${arch}) - done")

  message(STATUS "Build ${label} (Release - ${arch})")
  execute_process(
    COMMAND "${CMAKE_COMMAND}" --build build_${arch} --target libobs --config Release --parallel
    WORKING_DIRECTORY "${dependencies_dir}/${_obs_destination}"
    RESULT_VARIABLE _process_result
    COMMAND_ERROR_IS_FATAL ANY
  )
  message(STATUS "Build ${label} (Release - ${arch}) - done")

  # Install the whole build tree, and tolerate a non-zero exit.
  #
  # Installing from the top-level build directory walks every subproject's
  # cmake_install.cmake, including UI/obs-frontend-api's, which fails on a
  # binary this build deliberately never produced (that is the whole point of
  # dropping Qt):
  #
  #   file INSTALL cannot find ".../obs-frontend-api.dylib": No such file
  #
  # Restricting --install to the libobs subdirectory avoids that error, but
  # then the per-configuration export file (libobsTargets-release.cmake) never
  # lands, and every consumer fails with "IMPORTED_LOCATION or IMPORTED_IMPLIB
  # not set for imported target OBS::libobs configuration Release". So run the
  # full install exactly as upstream does, let it get through libobs, and
  # ignore the error it hits afterwards. If libobs really did not install, the
  # find_package(libobs) in the top-level CMakeLists is where that surfaces --
  # loudly, and with a far more useful message than a half-installed tree.
  message(STATUS "Install ${label} (${arch})")
  execute_process(
    COMMAND
      "${CMAKE_COMMAND}" --install build_${arch} --component Development --config Release --prefix "${dependencies_dir}"
    WORKING_DIRECTORY "${dependencies_dir}/${_obs_destination}"
    RESULT_VARIABLE _install_result
    OUTPUT_QUIET
  )
  if(NOT _install_result EQUAL 0)
    message(
      STATUS
      "Install ${label} (${arch}) reported errors; expected, because install rules exist for "
      "targets this build skips. Continuing -- find_package(libobs) is the real check."
    )
  endif()
  message(STATUS "Install ${label} (${arch}) - done")
endfunction()

# _check_dependencies: Fetch and extract pre-built OBS build dependencies
function(_check_dependencies)
  file(READ "${CMAKE_CURRENT_SOURCE_DIR}/buildspec.json" buildspec)

  string(JSON dependency_data GET ${buildspec} dependencies)

  foreach(dependency IN LISTS dependencies_list)
    string(JSON data GET ${dependency_data} ${dependency})
    string(JSON version GET ${data} version)
    string(JSON hash GET ${data} hashes ${platform})
    string(JSON url GET ${data} baseUrl)
    string(JSON label GET ${data} label)
    string(JSON revision ERROR_VARIABLE error GET ${data} revision ${platform})

    message(STATUS "Setting up ${label} (${arch})")

    set(file "${${dependency}_filename}")
    set(destination "${${dependency}_destination}")
    string(REPLACE "VERSION" "${version}" file "${file}")
    string(REPLACE "VERSION" "${version}" destination "${destination}")
    string(REPLACE "ARCH" "${arch}" file "${file}")
    string(REPLACE "ARCH" "${arch}" destination "${destination}")
    if(revision)
      string(REPLACE "_REVISION" "_v${revision}" file "${file}")
      string(REPLACE "-REVISION" "-v${revision}" file "${file}")
    else()
      string(REPLACE "_REVISION" "" file "${file}")
      string(REPLACE "-REVISION" "" file "${file}")
    endif()

    if(EXISTS "${dependencies_dir}/.dependency_${dependency}_${arch}.sha256")
      file(
        READ
        "${dependencies_dir}/.dependency_${dependency}_${arch}.sha256"
        OBS_DEPENDENCY_${dependency}_${arch}_HASH
      )
    endif()

    set(skip FALSE)
    if(dependency STREQUAL prebuilt OR dependency STREQUAL qt6)
      if(OBS_DEPENDENCY_${dependency}_${arch}_HASH STREQUAL ${hash})
        _check_deps_version(${version})

        if(found)
          set(skip TRUE)
        endif()
      endif()
    endif()

    if(skip)
      message(STATUS "Setting up ${label} (${arch}) - skipped")
      continue()
    endif()

    if(dependency STREQUAL obs-studio)
      set(url ${url}/${file})
    else()
      set(url ${url}/${version}/${file})
    endif()

    if(NOT EXISTS "${dependencies_dir}/${file}")
      message(STATUS "Downloading ${url}")
      file(DOWNLOAD "${url}" "${dependencies_dir}/${file}" STATUS download_status EXPECTED_HASH SHA256=${hash})

      list(GET download_status 0 error_code)
      list(GET download_status 1 error_message)
      if(error_code GREATER 0)
        message(STATUS "Downloading ${url} - Failure")
        message(FATAL_ERROR "Unable to download ${url}, failed with error: ${error_message}")
        file(REMOVE "${dependencies_dir}/${file}")
      else()
        message(STATUS "Downloading ${url} - done")
      endif()
    endif()

    if(NOT OBS_DEPENDENCY_${dependency}_${arch}_HASH STREQUAL ${hash})
      file(REMOVE_RECURSE "${dependencies_dir}/${destination}")
    endif()

    if(NOT EXISTS "${dependencies_dir}/${destination}")
      file(MAKE_DIRECTORY "${dependencies_dir}/${destination}")
      if(dependency STREQUAL obs-studio)
        file(ARCHIVE_EXTRACT INPUT "${dependencies_dir}/${file}" DESTINATION "${dependencies_dir}")
      else()
        file(ARCHIVE_EXTRACT INPUT "${dependencies_dir}/${file}" DESTINATION "${dependencies_dir}/${destination}")
      endif()
    endif()

    file(WRITE "${dependencies_dir}/.dependency_${dependency}_${arch}.sha256" "${hash}")

    if(dependency STREQUAL prebuilt)
      list(APPEND CMAKE_PREFIX_PATH "${dependencies_dir}/${destination}")
    elseif(dependency STREQUAL qt6)
      list(APPEND CMAKE_PREFIX_PATH "${dependencies_dir}/${destination}")
    elseif(dependency STREQUAL obs-studio)
      set(_obs_version ${version})
      set(_obs_destination "${destination}")
      list(APPEND CMAKE_PREFIX_PATH "${dependencies_dir}")
    endif()

    message(STATUS "Setting up ${label} (${arch}) - done")
  endforeach()

  list(REMOVE_DUPLICATES CMAKE_PREFIX_PATH)

  set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} CACHE PATH "CMake prefix search path" FORCE)

  if(OS_WINDOWS)
    _patch_obs_studio_w32_pthreads()
  endif()

  _setup_obs_studio()
endfunction()