cmake_minimum_required(VERSION 3.22)
project(App C)

find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM AND EXISTS "${CCACHE_PROGRAM}")
    set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
else()
    set(CMAKE_C_COMPILER_LAUNCHER "")
    set(CMAKE_C_COMPILER_LAUNCHER "" CACHE STRING "" FORCE)
endif()

get_filename_component(REPO_ROOT "${CMAKE_CURRENT_LIST_DIR}/../../../../.." ABSOLUTE)
set(SRC_DIR "${REPO_ROOT}/src")
if(NOT EXISTS "${REPO_ROOT}/build/packages/.complete")
    message(FATAL_ERROR "Run sh scripts/packages.sh to fetch the dependencies pinned in ziran.lock")
endif()
set(MONOCYPHER_DIR "${REPO_ROOT}/build/packages/monocypher/src")
if(NOT DEFINED KRYON_DIR)
    set(KRYON_DIR "${REPO_ROOT}/build/packages/kryon")
endif()
get_filename_component(KRYON_DIR "${KRYON_DIR}" ABSOLUTE BASE_DIR "${REPO_ROOT}")
set(WEBP_DIR "${REPO_ROOT}/build/packages/libwebp")
set(AVIF_DIR "${REPO_ROOT}/build/packages/libavif")
set(AOM_DIR "${REPO_ROOT}/build/packages/libaom")
# Ogg Opus narration is decoded through the audio package's static libopus.
set(AUDIO_DIR "${REPO_ROOT}/build/packages/audio")
set(OPUS_DIR "${REPO_ROOT}/build/packages/libopus")
set(SAMPLERATE_DIR "${REPO_ROOT}/build/packages/libsamplerate")
# Kryon's codec recipes come from the codec packages in this app's lock.
set(KRYON_WEBP_PACKAGE_DIR "${REPO_ROOT}/build/packages/webp")
set(KRYON_AVIF_PACKAGE_DIR "${REPO_ROOT}/build/packages/avif")
set(SQLITE_DIR "${REPO_ROOT}/build/packages/sqlite")
set(SQLITE_BUILD_DIR "${CMAKE_BINARY_DIR}/sqlite")
set(SQLITE_AMALGAMATION_C "${SQLITE_BUILD_DIR}/sqlite3.c")
set(SQLITE_AMALGAMATION_H "${SQLITE_BUILD_DIR}/sqlite3.h")
include("${KRYON_DIR}/cmake/KryonAndroid.cmake")
kryon_android_reproducible_paths("${REPO_ROOT}")
# Size-optimize static dependencies in release builds. Kryon compiles its
# host for speed, after this option, because it draws every frame.
add_compile_options("$<$<NOT:$<CONFIG:Debug>>:-Oz>")
set(OQS_BUILD_ONLY_LIB ON CACHE BOOL "" FORCE)
set(OQS_USE_OPENSSL OFF CACHE BOOL "" FORCE)
set(OQS_MINIMAL_BUILD "SIG_ml_dsa_44;KEM_ml_kem_768" CACHE STRING "" FORCE)
set(OQS_DIST_BUILD OFF CACHE BOOL "" FORCE)
set(OQS_OPT_TARGET generic CACHE STRING "" FORCE)
foreach(oqs_x86_feature
        ADX AES AVX AVX2 AVX512 AVX512BW AVX512DQ AVX512F
        BMI1 BMI2 FMA PCLMULQDQ POPCNT SSE SSE2 SSE3 VPCLMULQDQ)
    set(OQS_USE_${oqs_x86_feature}_INSTRUCTIONS OFF CACHE BOOL "" FORCE)
endforeach()
add_subdirectory("${REPO_ROOT}/build/packages/liboqs" "${CMAKE_BINARY_DIR}/liboqs")
if(NOT TARGET oqs)
    message(FATAL_ERROR "Android builds require liboqs for sync account crypto")
endif()
set(ZIRAN_DIR "${REPO_ROOT}/build/packages/ziran")
# The pinned toolchain's own build, which `make` shares. Its checkout is
# per commit, so a pin change never reuses objects from an older Ziran.
set(ZIRAN_BUILD_DIR "${ZIRAN_DIR}/build")
set(ZI2C_BIN "${ZIRAN_BUILD_DIR}/bin/zi2c")
set(ZI2ZIR_BIN "${ZIRAN_BUILD_DIR}/bin/zi2zir")
file(GLOB ZIRAN_SOURCES CONFIGURE_DEPENDS
    "${ZIRAN_DIR}/cmd/zir/*.c" "${ZIRAN_DIR}/cmd/zir/*.h"
    "${ZIRAN_DIR}/cmd/zir-c/*.c" "${ZIRAN_DIR}/cmd/zir-c/*.h"
    "${ZIRAN_DIR}/cmd/zir-ir/*.c" "${ZIRAN_DIR}/cmd/zir-ir/*.h")
find_program(HOST_MAKE NAMES make gmake REQUIRED)
find_program(HOST_PYTHON NAMES python3 REQUIRED)
find_program(HOST_CC NAMES cc gcc REQUIRED NO_CMAKE_FIND_ROOT_PATH)
set(ZIRAN_BIN "${ZIRAN_BUILD_DIR}/bin/ziran")
add_custom_target(app_build_laws
    COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/scripts/check-version.py"
    COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/tests/font_glyph_coverage_test.py"
    COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/tests/locale_translated_test.py"
    COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/tests/locale_used_keys_test.py"
    COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/app/sync_retry_laws.zi"
    COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/app/practice_lifecycle_laws.zi"
    COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/app/sync_recovery_policy_laws.zi"
    COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/storage/habit_merge_laws.zi"
    COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/storage/sync_restore_laws.zi"
    COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/app/modal_rules_laws.zi"
    COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" "${SRC_DIR}/storage/storage_layout_laws.zi"
    COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}" --module-path "${KRYON_DIR}/src/ui" --module-path "${ZIRAN_DIR}/std" "${SRC_DIR}/guide_laws.zi"
    DEPENDS "${ZI2C_BIN}"
    WORKING_DIRECTORY "${REPO_ROOT}"
    COMMENT "Checking release consistency and proving app laws"
    VERBATIM
)
add_custom_command(
    OUTPUT "${ZI2C_BIN}"
    BYPRODUCTS "${ZI2ZIR_BIN}"
    COMMAND "${HOST_MAKE}" -j1 -C "${ZIRAN_DIR}"
        "CC=${HOST_CC}" "HOST_CC=${HOST_CC}"
        "BUILD_DIR=${ZIRAN_BUILD_DIR}" all
    DEPENDS ${ZIRAN_SOURCES} "${ZIRAN_DIR}/Makefile"
    VERBATIM
)
set(APP_ZIRAN_GEN_DIR "${CMAKE_BINARY_DIR}/ziran/generated")
set(APP_ZIRAN_MANIFEST "${CMAKE_BINARY_DIR}/ziran/generated-sources.cmake")
file(GLOB_RECURSE APP_ZIRAN_SOURCES CONFIGURE_DEPENDS "${SRC_DIR}/*.zi")
list(APPEND APP_ZIRAN_SOURCES "${REPO_ROOT}/apps/practice/hold_reminder.zi")
file(GLOB_RECURSE APP_LIBRARY_ZIRAN_SOURCES CONFIGURE_DEPENDS
    "${KRYON_DIR}/src/ui/*.zi" "${KRYON_DIR}/src/backend/*.zi"
    "${REPO_ROOT}/build/packages/css/src/*.zi" "${REPO_ROOT}/build/packages/oqs/src/*.zi" "${REPO_ROOT}/build/packages/game2d/src/*.zi"
    "${REPO_ROOT}/build/packages/qrcode/src/*.zi"
    "${REPO_ROOT}/build/packages/entity/src/*.zi"
    "${REPO_ROOT}/build/packages/webp/src/*.zi"
    "${REPO_ROOT}/build/packages/image-codec/src/*.zi"
    "${REPO_ROOT}/build/packages/avif/src/*.zi"
    "${REPO_ROOT}/build/packages/audio/src/*.zi"
    "${ZIRAN_DIR}/std/*.zi" "${REPO_ROOT}/build/packages/mesh-client/*.zi")
set(APP_ZIRAN_DEFINES --define ANDROID_BUILD --define KRYON_ANDROID_HOST)
set(APP_ZIRAN_CHECK_DEFINES "ANDROID_BUILD KRYON_ANDROID_HOST")
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
    list(APPEND APP_ZIRAN_DEFINES --define ANDROID_DEBUG)
    string(APPEND APP_ZIRAN_CHECK_DEFINES " ANDROID_DEBUG")
    # The frame sampler is optional while the pinned Kryon predates it.
    file(GLOB KRYON_ANDROID_FRAME_WATCH CONFIGURE_DEPENDS
        "${KRYON_DIR}/src/backend/android_frame_watch.zi")
    if(KRYON_ANDROID_FRAME_WATCH)
        list(APPEND APP_ZIRAN_DEFINES --define LUMI_ANDROID_FRAME_WATCH)
        string(APPEND APP_ZIRAN_CHECK_DEFINES " LUMI_ANDROID_FRAME_WATCH")
    endif()
endif()
# The Google Play edition (build.gradle's gplay type) buys Dew through Play
# Billing (entity/dew_play).
if(APP_EDITION STREQUAL "gplay")
    list(APPEND APP_ZIRAN_DEFINES --define GOOGLE_PLAY)
    string(APPEND APP_ZIRAN_CHECK_DEFINES " GOOGLE_PLAY")
endif()
if(ANDROID_ABI STREQUAL "arm64-v8a")
    set(APP_ZIRAN_ARCH __aarch64__)
elseif(ANDROID_ABI STREQUAL "armeabi-v7a")
    set(APP_ZIRAN_ARCH __arm__)
elseif(ANDROID_ABI STREQUAL "x86_64")
    set(APP_ZIRAN_ARCH __x86_64__)
elseif(ANDROID_ABI STREQUAL "x86")
    set(APP_ZIRAN_ARCH __i386__)
else()
    message(FATAL_ERROR "Unsupported Android ABI: ${ANDROID_ABI}")
endif()
list(APPEND APP_ZIRAN_DEFINES --define ${APP_ZIRAN_ARCH})
string(APPEND APP_ZIRAN_CHECK_DEFINES " ${APP_ZIRAN_ARCH}")

# CMake needs the complete emitted import graph before it creates build rules.
# Run the same required law gates before this initial source generation.
execute_process(COMMAND "${HOST_MAKE}" -j1 -C "${ZIRAN_DIR}"
    "CC=${HOST_CC}" "HOST_CC=${HOST_CC}"
    "BUILD_DIR=${ZIRAN_BUILD_DIR}" all COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/scripts/check-version.py"
    WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/tests/font_glyph_coverage_test.py"
    WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/tests/locale_translated_test.py"
    WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/tests/locale_used_keys_test.py"
    WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
    "${SRC_DIR}/app/sync_retry_laws.zi"
    WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
    "${SRC_DIR}/app/practice_lifecycle_laws.zi"
    WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
    "${SRC_DIR}/app/sync_recovery_policy_laws.zi"
    WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
    "${SRC_DIR}/storage/habit_merge_laws.zi"
    WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
    "${SRC_DIR}/storage/sync_restore_laws.zi"
    WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
    "${SRC_DIR}/app/modal_rules_laws.zi"
    WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
    "${SRC_DIR}/storage/storage_layout_laws.zi"
    WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
execute_process(COMMAND "${ZIRAN_BIN}" check --root "${SRC_DIR}"
    --module-path "${KRYON_DIR}/src/ui" --module-path "${ZIRAN_DIR}/std"
    "${SRC_DIR}/guide_laws.zi"
    WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
set(APP_GENERATE_ZIRAN_COMMAND "${HOST_PYTHON}"
    "${REPO_ROOT}/scripts/generate-android-sources.py"
    --compiler "${ZIRAN_BIN}" --root "${REPO_ROOT}" --kryon "${KRYON_DIR}"
    --output "${APP_ZIRAN_GEN_DIR}" --manifest "${APP_ZIRAN_MANIFEST}"
    ${APP_ZIRAN_DEFINES})
set(APP_ZIRAN_STAMP "${CMAKE_BINARY_DIR}/ziran/generated.stamp")
set(APP_ZIRAN_INPUTS_FILE "${CMAKE_BINARY_DIR}/ziran/generation-inputs.txt")
set(APP_ZIRAN_INPUTS "${APP_GENERATE_ZIRAN_COMMAND};${APP_ZIRAN_SOURCES};${APP_LIBRARY_ZIRAN_SOURCES}")
set(APP_ZIRAN_GENERATE TRUE)
if(EXISTS "${APP_ZIRAN_MANIFEST}" AND EXISTS "${APP_ZIRAN_STAMP}" AND
        EXISTS "${APP_ZIRAN_INPUTS_FILE}")
    file(READ "${APP_ZIRAN_INPUTS_FILE}" APP_ZIRAN_OLD_INPUTS)
    if(APP_ZIRAN_OLD_INPUTS STREQUAL APP_ZIRAN_INPUTS)
        set(APP_ZIRAN_GENERATE FALSE)
        include("${APP_ZIRAN_MANIFEST}")
        foreach(input ${APP_ZIRAN_SOURCES} ${APP_LIBRARY_ZIRAN_SOURCES}
                "${ZIRAN_BIN}" "${REPO_ROOT}/scripts/generate-android-sources.py")
            if("${input}" IS_NEWER_THAN "${APP_ZIRAN_STAMP}")
                set(APP_ZIRAN_GENERATE TRUE)
            endif()
        endforeach()
        foreach(output ${APP_ZIRAN_GENERATED_SOURCES} ${APP_ZIRAN_GENERATED_HEADERS})
            if(NOT EXISTS "${output}")
                set(APP_ZIRAN_GENERATE TRUE)
            endif()
        endforeach()
    endif()
endif()
if(APP_ZIRAN_GENERATE)
    execute_process(COMMAND ${APP_GENERATE_ZIRAN_COMMAND}
        WORKING_DIRECTORY "${REPO_ROOT}" COMMAND_ERROR_IS_FATAL ANY)
    file(WRITE "${APP_ZIRAN_INPUTS_FILE}" "${APP_ZIRAN_INPUTS}")
    file(TOUCH "${APP_ZIRAN_STAMP}")
endif()
include("${APP_ZIRAN_MANIFEST}")
add_custom_command(
    OUTPUT "${APP_ZIRAN_STAMP}"
    BYPRODUCTS ${APP_ZIRAN_GENERATED_SOURCES} ${APP_ZIRAN_GENERATED_HEADERS}
    COMMAND ${APP_GENERATE_ZIRAN_COMMAND}
    COMMAND ${CMAKE_COMMAND} -E touch "${APP_ZIRAN_STAMP}"
    DEPENDS ${APP_ZIRAN_SOURCES} ${APP_LIBRARY_ZIRAN_SOURCES} "${ZIRAN_BIN}"
        "${REPO_ROOT}/scripts/generate-android-sources.py"
        "${REPO_ROOT}/scripts/run-ziran.sh"
    WORKING_DIRECTORY "${REPO_ROOT}" VERBATIM)
add_custom_target(app_ziran_generated DEPENDS "${APP_ZIRAN_STAMP}")
set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
    ${APP_ZIRAN_SOURCES} ${APP_LIBRARY_ZIRAN_SOURCES}
    "${REPO_ROOT}/scripts/generate-android-sources.py")
set_source_files_properties(${APP_ZIRAN_GENERATED_SOURCES}
    ${APP_ZIRAN_GENERATED_HEADERS} PROPERTIES GENERATED TRUE)
add_custom_target(app_clean_runtime_api
    COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/scripts/check-clean-text-api.py" "${SRC_DIR}"
    WORKING_DIRECTORY "${REPO_ROOT}" VERBATIM)
add_custom_target(app_zi_check
    COMMAND ${CMAKE_COMMAND} -E env "ZI_CHECK_DEFINES=${APP_ZIRAN_CHECK_DEFINES}"
        "${HOST_PYTHON}" "${REPO_ROOT}/scripts/check-zi-sources.py" "${ZIRAN_BIN}"
    DEPENDS "${ZIRAN_BIN}" WORKING_DIRECTORY "${REPO_ROOT}" VERBATIM)
add_dependencies(app_zi_check app_build_laws)
add_dependencies(app_ziran_generated app_build_laws app_clean_runtime_api app_zi_check)

foreach(mode light dark)
    file(SHA256 "${REPO_ROOT}/themes/catalog_${mode}.css" APP_CATALOG_HASH)
    file(SHA256 "${KRYON_DIR}/themes/catalog_${mode}.css" KRYON_CATALOG_HASH)
    if(NOT APP_CATALOG_HASH STREQUAL KRYON_CATALOG_HASH)
        message(FATAL_ERROR "Packaged ${mode} theme catalog differs from Kryon")
    endif()
endforeach()
# Gradle builds and stages the portable package independently of ABI-specific
# native compilation. Artwork changes must not reconfigure every native host.
set(APP_BUNDLE_RUNTIME_DIR "${CMAKE_BINARY_DIR}/bundle-runtime")
set(APP_BUNDLE_RUNTIME "${APP_BUNDLE_RUNTIME_DIR}/libziran.a")
# Let Ziran's make check its complete runtime dependency graph on every build.
# A configure-time build leaves this archive stale after local runtime edits.
add_custom_target(app_bundle_runtime
    BYPRODUCTS "${APP_BUNDLE_RUNTIME}"
    COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/scripts/build-bundle-runtime.py"
        --source "${ZIRAN_DIR}" --output "${APP_BUNDLE_RUNTIME_DIR}"
        --cc "${CMAKE_C_COMPILER} --target=${CMAKE_C_COMPILER_TARGET} --sysroot=${CMAKE_SYSROOT}"
        --ar "${CMAKE_AR}" --objcopy "${CMAKE_OBJCOPY}"
        "--flags=-O2 -fPIC -ffunction-sections -fdata-sections"
    DEPENDS "${ZI2C_BIN}" "${REPO_ROOT}/scripts/build-bundle-runtime.py"
    WORKING_DIRECTORY "${REPO_ROOT}" VERBATIM)

set(APP_EMBEDDED_INPUTS
    apps/publishers.json
    assets/app/icon.webp
)
set(APP_EMBEDDED_DEPS)
foreach(asset ${APP_EMBEDDED_INPUTS})
    list(APPEND APP_EMBEDDED_DEPS "${REPO_ROOT}/${asset}")
endforeach()
set(APP_EMBEDDED_ASSETS_C "${CMAKE_BINARY_DIR}/app_embedded_assets.c")

add_custom_command(
    OUTPUT "${APP_EMBEDDED_ASSETS_C}"
    COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/scripts/embed-app-assets.py"
        "${APP_EMBEDDED_ASSETS_C}" ${APP_EMBEDDED_INPUTS}
    DEPENDS "${REPO_ROOT}/scripts/embed-app-assets.py" ${APP_EMBEDDED_DEPS}
    WORKING_DIRECTORY "${REPO_ROOT}"
    VERBATIM
)

add_custom_command(
    OUTPUT "${SQLITE_AMALGAMATION_C}" "${SQLITE_AMALGAMATION_H}"
    COMMAND ${CMAKE_COMMAND} -E make_directory "${SQLITE_BUILD_DIR}"
    COMMAND sh -c "cd '${SQLITE_BUILD_DIR}' && '${SQLITE_DIR}/configure'"
    COMMAND make -C "${SQLITE_BUILD_DIR}" sqlite3.c sqlite3.h
    DEPENDS "${SQLITE_DIR}/configure" "${SQLITE_DIR}/manifest"
    VERBATIM
)

kryon_android_codecs("${WEBP_DIR}" "${AVIF_DIR}" "${AOM_DIR}")
# Picture decoding runs during startup. Match the host's speed optimization in
# debug builds while retaining symbols; the decoder's object libraries carry
# the hot loops, so optimizing only the aggregate archive would miss them.
foreach(decoder_target kryonwebp webpdecode webpdspdecode webputilsdecode)
    target_compile_options(${decoder_target} PRIVATE "$<$<CONFIG:Debug>:-O2>")
endforeach()
# Kryon's Android host draws with Pixmap on the activity's surface; its helper
# supplies the platform glue and picture codecs. Ziran's mixer decodes Ogg
# Opus with the audio package's libopus, MP3 with dr_mp3 and Ogg Vorbis with
# libvorbisfile, and plays through AAudio or OpenSL ES, opened at run time.
include("${AUDIO_DIR}/native/AudioCodecs.cmake")
ziran_audio_codecs("${OPUS_DIR}" "${SAMPLERATE_DIR}")
target_compile_options(opus PRIVATE -O2)
include("${ZIRAN_DIR}/std/native/AudioCodecs.cmake")
ziran_audio_mp3()
ziran_audio_vorbis()

add_library(main SHARED
    "${MONOCYPHER_DIR}/monocypher.c"
    "${MONOCYPHER_DIR}/optional/monocypher-ed25519.c"
    "${SQLITE_AMALGAMATION_C}"
    "${APP_EMBEDDED_ASSETS_C}"
    ${APP_ZIRAN_GENERATED_SOURCES}
)
kryon_android_app(main)
# Optimize across generated modules while retaining the Android export map.
# Use the NDK's ThinLTO directly: older CMake IPO selects the retired gold
# linker, whereas Android's Clang already uses lld. Keep debug builds separate.
target_compile_options(main PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-flto=thin>")
target_link_options(main PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-flto=thin>")
# Prefix maps do not normalize the source filename in LLVM bitcode. Keep
# compiler inputs relative so ThinLTO's symbol hashes and build IDs match
# across the release runner and F-Droid, while retaining native crash symbols.
set(APP_COMPILER_LAUNCHER "${HOST_PYTHON}" "${REPO_ROOT}/scripts/relative-compile.py")
list(APPEND APP_COMPILER_LAUNCHER ${CMAKE_C_COMPILER_LAUNCHER})
set_property(TARGET main PROPERTY C_COMPILER_LAUNCHER "${APP_COMPILER_LAUNCHER}")
add_dependencies(main app_ziran_generated app_clean_runtime_api app_build_laws app_zi_check app_bundle_runtime)

target_include_directories(main PRIVATE
    "${ZIRAN_DIR}/include"
    "${MONOCYPHER_DIR}"
    "${MONOCYPHER_DIR}/optional"
    "${SRC_DIR}/app"
    "${SQLITE_BUILD_DIR}"
)
# Generated module names such as math.h must not shadow libc's <math.h>
# in SQLite and other native dependencies. Zi imports use quoted includes.
foreach(directory ${APP_ZIRAN_INCLUDE_DIRS})
    target_compile_options(main PRIVATE "-iquote${directory}")
endforeach()

target_compile_definitions(main PRIVATE
    UTF8PROC_STATIC
    MG_TLS=MG_TLS_BUILTIN
    MG_ENABLE_EPOLL=0
    MG_ENABLE_POLL=1
    MG_ENABLE_POSIX_FS=0
    UI_EMBEDDED_ONLY=1
    HAS_LIBOQS=1
    KRYON_WITH_SYNC=1
    KRYON_WITH_PHYSICS=0
)

# The VM locates this exported entry before native methods are registered.
foreach(source ${APP_ZIRAN_GENERATED_SOURCES})
    get_filename_component(source_name "${source}" NAME)
    if(source_name STREQUAL "android_insets.c" OR
       source_name MATCHES "(^|_)(android_notifications|notification_push)\\.c$")
        set_source_files_properties("${source}"
            PROPERTIES COMPILE_OPTIONS "-fvisibility=default")
    elseif(source_name STREQUAL "main.c")
        # Kryon's NativeActivity host calls this entry itself; its Zi argv is
        # byte pointers, so hosted C's spelling rule for main does not apply.
        set_source_files_properties("${source}"
            PROPERTIES COMPILE_OPTIONS "-ffreestanding")
    endif()
endforeach()

target_link_libraries(main PRIVATE kryon_android_codecs opus ziran_mp3 vorbisfile
    jnigraphics oqs z "${APP_BUNDLE_RUNTIME}")

# Keep the Android entry points public and let the linker discard unreachable
# functions from the statically linked runtime and graphics dependencies.
set(APP_EXPORT_MAP "${KRYON_DIR}/cmake/libmain.map.txt")
target_link_options(main PRIVATE
    "$<$<NOT:$<CONFIG:Debug>>:-Wl,-O2,--icf=safe>"
    "-Wl,--version-script,${APP_EXPORT_MAP}"
    "-Wl,--no-undefined-version")
set_property(TARGET main APPEND PROPERTY LINK_DEPENDS "${APP_EXPORT_MAP}")
