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()

set(REPO_ROOT "${CMAKE_CURRENT_LIST_DIR}/../../../../..")
set(SRC_DIR "${REPO_ROOT}/src")
if(NOT DEFINED KRYON_DIR)
    set(KRYON_DIR "${REPO_ROOT}/vendor/kryon")
endif()
get_filename_component(KRYON_DIR "${KRYON_DIR}" ABSOLUTE BASE_DIR "${REPO_ROOT}")
set(RAYLIB_DIR "${KRYON_DIR}/vendor/raylib/src")
set(KRYON_RAYLIB_GENERATED_DIR "${CMAKE_BINARY_DIR}/kryon/raylib_generated")
set(KRYON_COMPAT_GENERATED_HEADER "${KRYON_RAYLIB_GENERATED_DIR}/kryon_compat.generated.h")
set(KRYON_RAYLIB_BACKEND_RENAME_HEADER "${KRYON_RAYLIB_GENERATED_DIR}/raylib_backend_rename.h")
set(KRYON_RAYLIB_WRAPPERS_C "${KRYON_RAYLIB_GENERATED_DIR}/kryon_raylib_wrappers.c")
set(KRYON_NULL_BACKEND_C "${KRYON_RAYLIB_GENERATED_DIR}/kryon_null_backend.c")
# Icon outputs must live outside kryon/generated: the k2c regeneration step
# wipes that whole directory, which would delete these mid-build.
set(KRYON_ICON_GENERATED_INCLUDE_DIR "${CMAKE_BINARY_DIR}/kryon/generated-icons/include")
set(KRYON_ICON_GENERATED_SRC_DIR "${CMAKE_BINARY_DIR}/kryon/generated-icons/src")
set(KRYON_ICON_ASSETS_C "${KRYON_ICON_GENERATED_SRC_DIR}/ui/ui_icon_assets.c")
set(KRYON_ICON_NAMES_C "${KRYON_ICON_GENERATED_SRC_DIR}/ui/ui_icon_names.c")
set(KRYON_ICON_TYPES_H "${KRYON_ICON_GENERATED_INCLUDE_DIR}/ui_icon_types.h")
set(SQLITE_DIR "${REPO_ROOT}/vendor/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")
set(NATIVE_APP_GLUE_DIR "${ANDROID_NDK}/sources/android/native_app_glue")
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" 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("${KRYON_DIR}/vendor/liboqs" "${CMAKE_BINARY_DIR}/liboqs")
if(NOT TARGET oqs)
    message(FATAL_ERROR "Android builds require liboqs for sync account crypto")
endif()
file(GLOB_RECURSE KRYON_SOURCES CONFIGURE_DEPENDS "${KRYON_DIR}/src/*.c")
list(REMOVE_ITEM KRYON_SOURCES "${KRYON_DIR}/src/file_dialog/file_dialog.c")
list(REMOVE_ITEM KRYON_SOURCES "${KRYON_DIR}/src/ui/ui_icon_assets.c")
list(REMOVE_ITEM KRYON_SOURCES "${KRYON_DIR}/src/ui/ui_icon_names.c")
# The src/backend/ canvas/software renderers implement raylib-named functions
# for no-raylib hosts; Android links real raylib, so compiling those is a
# duplicate-symbol link error. Keep Kryon's shared front-end backend glue.
list(FILTER KRYON_SOURCES EXCLUDE REGEX "${KRYON_DIR}/src/backend/.*")
list(FILTER KRYON_SOURCES EXCLUDE REGEX "${KRYON_DIR}/src/platform/plan9/.*")
list(APPEND KRYON_SOURCES
    "${KRYON_DIR}/src/backend/kry_event_wait.c"
    "${KRYON_DIR}/src/backend/kry_image.c"
    "${KRYON_DIR}/src/backend/kry_image_decode.c"
    "${KRYON_DIR}/src/backend/kry_input.c"
    "${KRYON_DIR}/src/backend/kry_instance.c"
    "${KRYON_DIR}/src/backend/kry_screenshot.c"
    "${KRYON_DIR}/src/backend/kry_sw_png.c"
    "${KRYON_DIR}/src/backend/kry_surface_math.c"
    "${KRYON_ICON_ASSETS_C}"
    "${KRYON_ICON_NAMES_C}")
# this app is UI-only: drop the 2D physics subsystem (Box2D). Mirror the
# KRYON_PHYSICS_SRCS filter the desktop Makefile applies via vendor.mk.
list(REMOVE_ITEM KRYON_SOURCES
    "${KRYON_DIR}/src/scene/physics_world.c"
    "${KRYON_DIR}/src/scene/node_body2d.c"
    "${KRYON_DIR}/src/scene/node_area2d.c"
    "${KRYON_DIR}/src/scene/node_collision_shape2d.c")
file(GLOB KRYON_K2C_SOURCES CONFIGURE_DEPENDS "${KRYON_DIR}/cmd/k2c/*.c")
file(GLOB KRYON_KIR_SOURCES CONFIGURE_DEPENDS "${KRYON_DIR}/cmd/kir/*.c")
file(GLOB KRYON_K2C_HEADERS CONFIGURE_DEPENDS
    "${KRYON_DIR}/cmd/k2c/*.h" "${KRYON_DIR}/cmd/kir/*.h")
list(APPEND KRYON_K2C_SOURCES ${KRYON_KIR_SOURCES}
    "${KRYON_DIR}/src/kry_std/kry_json.c")
list(SORT KRYON_K2C_SOURCES)
find_program(HOST_CC NAMES cc clang gcc REQUIRED)
find_program(HOST_PYTHON NAMES python3 REQUIRED)
find_program(HOST_NODE NAMES node REQUIRED)
set(APP_PROOF_DIR "${CMAKE_BINARY_DIR}/proofs")
add_custom_target(app_build_laws
    COMMAND "${HOST_PYTHON}" "${REPO_ROOT}/scripts/check-version.py"
    COMMAND "${HOST_NODE}" "${REPO_ROOT}/scripts/generate-sync-retry.mjs"
        "${APP_PROOF_DIR}/sync_retry_table.h"
    COMMAND "${HOST_NODE}" "${REPO_ROOT}/scripts/generate-storage-layout.mjs"
        "${APP_PROOF_DIR}/storage_layout.h"
    BYPRODUCTS "${APP_PROOF_DIR}/sync_retry_table.h"
        "${APP_PROOF_DIR}/storage_layout.h"
    WORKING_DIRECTORY "${REPO_ROOT}"
    COMMENT "Checking release consistency and proving app laws"
    VERBATIM
)
set(KRYON_K2C "${CMAKE_BINARY_DIR}/host-tools/k2c")
# needs the kir headers on the include path
set(APP_KRY_GEN_DIR "${CMAKE_BINARY_DIR}/kryon/generated")
file(GLOB_RECURSE APP_KRY_SOURCES CONFIGURE_DEPENDS "${SRC_DIR}/*.kry")
list(SORT APP_KRY_SOURCES)
# App-layer sources are cross-platform modules that belong in every build.
# Glob them so adding an app .c file needs no edit here -- this list had
# drifted out of sync with the Makefile APP_SRCS more than once.
file(GLOB APP_C_SOURCES CONFIGURE_DEPENDS "${SRC_DIR}/app/*.c")
list(SORT APP_C_SOURCES)
set(APP_KRY_GENERATED_SOURCES)
set(APP_KRY_GENERATED_HEADERS)
set(APP_KRY_COMMAND_SOURCES)
foreach(kry_source ${APP_KRY_SOURCES})
    file(RELATIVE_PATH kry_rel "${REPO_ROOT}" "${kry_source}")
    list(APPEND APP_KRY_COMMAND_SOURCES "${kry_rel}")
    get_filename_component(kry_rel_dir "${kry_rel}" DIRECTORY)
    get_filename_component(kry_name "${kry_rel}" NAME_WE)
    set(kry_output_c "${APP_KRY_GEN_DIR}/${kry_rel_dir}/${kry_name}.c")
    set(kry_output_h "${APP_KRY_GEN_DIR}/${kry_rel_dir}/${kry_name}.h")
    list(APPEND APP_KRY_GENERATED_SOURCES "${kry_output_c}")
    list(APPEND APP_KRY_GENERATED_HEADERS "${kry_output_h}")
endforeach()
set(APP_KRY_PROJECT_HEADER "${APP_KRY_GEN_DIR}/kryon_project.h")
add_custom_command(
    OUTPUT ${APP_KRY_GENERATED_SOURCES} ${APP_KRY_GENERATED_HEADERS} "${APP_KRY_PROJECT_HEADER}"
    COMMAND ${CMAKE_COMMAND} -E remove_directory "${APP_KRY_GEN_DIR}"
    COMMAND ${CMAKE_COMMAND} -E make_directory "${APP_KRY_GEN_DIR}"
    COMMAND "${KRYON_K2C}" --root "${REPO_ROOT}" -o "${APP_KRY_GEN_DIR}" ${APP_KRY_COMMAND_SOURCES}
    DEPENDS ${APP_KRY_SOURCES} "${KRYON_K2C}"
    WORKING_DIRECTORY "${REPO_ROOT}"
    VERBATIM
)
add_custom_command(
    OUTPUT "${KRYON_K2C}"
    COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/host-tools"
    # VERBATIM escapes embedded quotes, so unquoted -I paths (no spaces here)
    COMMAND "${HOST_CC}" -Wall -Wextra -O2 -I${KRYON_DIR}/include -I${KRYON_DIR}/cmd/kir -I${KRYON_DIR}/cmd/k2c -o "${KRYON_K2C}" ${KRYON_K2C_SOURCES}
    DEPENDS ${KRYON_K2C_SOURCES} ${KRYON_K2C_HEADERS}
    VERBATIM
)
# Kryon ships part of its runtime as Kry modules transpiled at build time
# (runtime/*.kry -> generated/src/runtime/*.c). Downstream C builds compile
# the generated sources and put their directory on the include path so
# kryon's own C files can #include "runtime/*.h".
set(KRYON_RUNTIME_GEN_DIR "${CMAKE_BINARY_DIR}/kryon/generated-runtime")
file(GLOB KRYON_RUNTIME_MODULE_FILES CONFIGURE_DEPENDS
    "${KRYON_DIR}/runtime/*.kry")
set(KRYON_RUNTIME_KRY_MODULES)
foreach(kryon_module_file ${KRYON_RUNTIME_MODULE_FILES})
    file(RELATIVE_PATH kryon_module "${KRYON_DIR}" "${kryon_module_file}")
    list(APPEND KRYON_RUNTIME_KRY_MODULES "${kryon_module}")
endforeach()
set(KRYON_RUNTIME_KRY_FILES)
set(KRYON_RUNTIME_GENERATED_C)
foreach(kryon_module ${KRYON_RUNTIME_KRY_MODULES})
    list(APPEND KRYON_RUNTIME_KRY_FILES "${KRYON_DIR}/${kryon_module}")
    string(REGEX REPLACE "\\.kry$" ".c" kryon_module_c "${kryon_module}")
    list(APPEND KRYON_RUNTIME_GENERATED_C "${KRYON_RUNTIME_GEN_DIR}/${kryon_module_c}")
endforeach()
add_custom_command(
    OUTPUT ${KRYON_RUNTIME_GENERATED_C}
    COMMAND "${KRYON_K2C}" --strict --no-main --root "${KRYON_DIR}" -o "${KRYON_RUNTIME_GEN_DIR}" ${KRYON_RUNTIME_KRY_MODULES}
    DEPENDS "${KRYON_K2C}" ${KRYON_RUNTIME_KRY_FILES}
    WORKING_DIRECTORY "${KRYON_DIR}"
    VERBATIM
)
add_custom_target(kryon_runtime_generated DEPENDS ${KRYON_RUNTIME_GENERATED_C})
list(APPEND KRYON_SOURCES ${KRYON_RUNTIME_GENERATED_C})
add_custom_target(app_kry_generated DEPENDS
    ${APP_KRY_GENERATED_SOURCES}
    ${APP_KRY_GENERATED_HEADERS}
    "${APP_KRY_PROJECT_HEADER}"
)
add_custom_target(app_clean_runtime_api
    COMMAND "${HOST_PYTHON}"
        "${KRYON_DIR}/scripts/check-clean-text-api.py"
        "${SRC_DIR}"
    WORKING_DIRECTORY "${REPO_ROOT}"
    COMMENT "Rejecting stale or duplicate Kryon runtime API usage"
    VERBATIM
)
add_dependencies(app_kry_generated app_clean_runtime_api app_build_laws)

add_custom_command(
    OUTPUT
        "${KRYON_COMPAT_GENERATED_HEADER}"
        "${KRYON_RAYLIB_BACKEND_RENAME_HEADER}"
        "${KRYON_RAYLIB_WRAPPERS_C}"
        "${KRYON_NULL_BACKEND_C}"
    COMMAND ${CMAKE_COMMAND} -E make_directory "${KRYON_RAYLIB_GENERATED_DIR}"
    COMMAND ${CMAKE_COMMAND} -E env KRYON_COMPAT_AUDIO=0
        sh "${KRYON_DIR}/tools/generate-kryon-compat.sh"
        "${RAYLIB_DIR}/raylib.h"
        "${KRYON_COMPAT_GENERATED_HEADER}"
        "${KRYON_RAYLIB_BACKEND_RENAME_HEADER}"
        "${KRYON_RAYLIB_WRAPPERS_C}"
        "${KRYON_NULL_BACKEND_C}"
    DEPENDS "${KRYON_DIR}/tools/generate-kryon-compat.sh" "${RAYLIB_DIR}/raylib.h"
    VERBATIM
)
add_custom_target(kryon_raylib_generated DEPENDS
    "${KRYON_COMPAT_GENERATED_HEADER}"
    "${KRYON_RAYLIB_BACKEND_RENAME_HEADER}"
    "${KRYON_RAYLIB_WRAPPERS_C}"
    "${KRYON_NULL_BACKEND_C}"
)
file(GLOB APP_LOCALE_ASSETS RELATIVE "${REPO_ROOT}" CONFIGURE_DEPENDS "${REPO_ROOT}/locales/*.txt")
file(GLOB APP_SOUND_ASSETS RELATIVE "${REPO_ROOT}" CONFIGURE_DEPENDS "${REPO_ROOT}/assets/sounds/*.ogg")
file(GLOB APP_PRACTICE_BANNER_ASSETS RELATIVE "${REPO_ROOT}" CONFIGURE_DEPENDS "${REPO_ROOT}/assets/practices/*/banner*.png")
file(GLOB APP_STYLE_ASSETS RELATIVE "${REPO_ROOT}"
    "${KRYON_DIR}/styles/kryon/*.kss" "${REPO_ROOT}/assets/styles/*.kss")
set(APP_EMBEDDED_INPUTS
    ${APP_STYLE_ASSETS}
    ${APP_LOCALE_ASSETS}
    assets/app/icon-sky-cradle.png
    assets/app/icon-ink-and-air.png
    assets/easteregg/art.png
    assets/easteregg/waozi.png
    assets/practices/whm/1.png
    assets/practices/whm/2.png
    assets/practices/meditation/1.png
    assets/pet/egg1.png
    ${APP_PRACTICE_BANNER_ASSETS}
    assets/practices/sunsalutation/poses_man_sheet.png
    assets/practices/sunsalutation/poses_woman_sheet.png
    assets/fonts/subset/NotoSans-App-Regular.ttf
    assets/fonts/subset/NotoSansSC-App-Regular.otf
    assets/fonts/subset/NotoSansJP-App-Regular.otf
    assets/fonts/subset/NotoSansKR-App-Regular.otf
    assets/fonts/subset/NotoSansTC-App-Regular.otf
    ${APP_SOUND_ASSETS}
)
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 sh "${KRYON_DIR}/scripts/embed-assets.sh" "${APP_EMBEDDED_ASSETS_C}" ${APP_EMBEDDED_INPUTS}
    DEPENDS "${KRYON_DIR}/scripts/embed-assets.sh" ${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
)

add_library(raylib STATIC
    "${RAYLIB_DIR}/rcore.c"
    "${RAYLIB_DIR}/rshapes.c"
    "${RAYLIB_DIR}/rtextures.c"
    "${RAYLIB_DIR}/rtext.c"
    "${RAYLIB_DIR}/raudio.c"
)
add_dependencies(raylib kryon_raylib_generated)

target_compile_definitions(raylib PRIVATE
    PLATFORM_ANDROID
    GRAPHICS_API_OPENGL_ES2
    SUPPORT_SCREEN_CAPTURE=0
    SUPPORT_COMPRESSION_API=0
    SUPPORT_AUTOMATION_EVENTS=0
    SUPPORT_CLIPBOARD_IMAGE=0
    SUPPORT_FILEFORMAT_BMP=0
    SUPPORT_FILEFORMAT_GIF=0
    SUPPORT_FILEFORMAT_QOI=0
    SUPPORT_FILEFORMAT_DDS=0
    SUPPORT_FILEFORMAT_TTF=1
    SUPPORT_FILEFORMAT_JPG=1
    SUPPORT_FILEFORMAT_PNG=1
    SUPPORT_FILEFORMAT_OGG=1
    SUPPORT_MODULE_RAUDIO=1
)

target_compile_options(raylib PRIVATE
    -include "${KRYON_RAYLIB_BACKEND_RENAME_HEADER}"
    -Oz
    -ffunction-sections
    -fdata-sections
)

target_include_directories(raylib PUBLIC
    "${RAYLIB_DIR}"
    "${NATIVE_APP_GLUE_DIR}"
)

add_library(main SHARED
    "${SRC_DIR}/platform/main_host.c"
    ${APP_C_SOURCES}
    "${SRC_DIR}/storage/storage_json_builder.c"
    "${SQLITE_AMALGAMATION_C}"
    "${SRC_DIR}/platform/android/android_device.c"
    "${SRC_DIR}/platform/android/android_share.c"
    "${APP_EMBEDDED_ASSETS_C}"
    ${APP_KRY_GENERATED_SOURCES}
    ${KRYON_SOURCES}
    "${KRYON_RAYLIB_WRAPPERS_C}"
    "${SRC_DIR}/platform/android/android_insets.c"
    "${NATIVE_APP_GLUE_DIR}/android_native_app_glue.c"
)
add_dependencies(main app_kry_generated kryon_raylib_generated
    kryon_runtime_generated app_build_laws)

file(GLOB_RECURSE KRYON_ICON_FILES CONFIGURE_DEPENDS "${KRYON_DIR}/icons/*.png" "${KRYON_DIR}/icons/*.json")
add_custom_command(
    OUTPUT "${KRYON_ICON_ASSETS_C}" "${KRYON_ICON_NAMES_C}" "${KRYON_ICON_TYPES_H}"
    COMMAND "${HOST_PYTHON}" "${KRYON_DIR}/scripts/embed-icon-sheets.py"
            icons
            "${KRYON_ICON_ASSETS_C}"
            --types-output "${KRYON_ICON_TYPES_H}"
            --names-output "${KRYON_ICON_NAMES_C}"
    DEPENDS "${KRYON_DIR}/scripts/embed-icon-sheets.py" "${KRYON_DIR}/include/ui_icons.h" ${KRYON_ICON_FILES}
    WORKING_DIRECTORY "${KRYON_DIR}"
    VERBATIM)
add_custom_target(kryon_icon_assets_generated DEPENDS "${KRYON_ICON_ASSETS_C}" "${KRYON_ICON_NAMES_C}" "${KRYON_ICON_TYPES_H}")
add_dependencies(main kryon_icon_assets_generated)

target_include_directories(main PRIVATE
    "${APP_PROOF_DIR}"
    "${KRYON_ICON_GENERATED_INCLUDE_DIR}"
    "${KRYON_DIR}/include"
    "${KRYON_DIR}/src"
    "${KRYON_DIR}/vendor/monocypher/src"
    "${KRYON_DIR}/vendor/monocypher/src/optional"
    "${SRC_DIR}"
    "${SRC_DIR}/app"
    "${SRC_DIR}/core"
    "${SRC_DIR}/screens"
    "${SRC_DIR}/screens/settings"
    "${SRC_DIR}/practices"
    "${SRC_DIR}/practices/whm"
    "${SRC_DIR}/practices/meditation"
    "${SRC_DIR}/practices/sun_salutation"
    "${SRC_DIR}/storage"
    "${SRC_DIR}/platform/android"
    "${SRC_DIR}/third_party"
    "${APP_KRY_GEN_DIR}"
    "${APP_KRY_GEN_DIR}/src"
    "${KRYON_RUNTIME_GEN_DIR}"
    "${NATIVE_APP_GLUE_DIR}"
    "${SQLITE_BUILD_DIR}"
)

target_compile_definitions(main PRIVATE
    PLATFORM_ANDROID
    ANDROID_BUILD=1
    _DEFAULT_SOURCE
    _GNU_SOURCE
    _FILE_OFFSET_BITS=64
    MG_TLS=MG_TLS_BUILTIN
    MG_ENABLE_EPOLL=0
    MG_ENABLE_POLL=1
    MG_ENABLE_POSIX_FS=0
    SUPPORT_MODULE_RAUDIO=1
    SUPPORT_FILEFORMAT_OGG=1
    UI_EMBEDDED_ONLY=1
    HAS_LIBOQS=1
    KRYON_WITH_SYNC=1
    KRYON_WITH_PHYSICS=0
)

target_compile_options(main PRIVATE
    -Oz
    -ffunction-sections
    -fdata-sections
    -fvisibility=hidden
)

target_link_options(main PRIVATE
    -Wl,--gc-sections
    -Wl,-z,max-page-size=16384
    -Wl,-z,common-page-size=16384
    -Wl,--wrap=fopen
)
if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
    target_link_options(main PRIVATE -Wl,--strip-all)
endif()

target_link_libraries(main
    raylib
    oqs
    android
    log
    OpenSLES
    EGL
    GLESv2
    z
    m
)
