cmake_minimum_required(VERSION 3.10)

project(nekobox VERSION 5.11.28.2)

option(GENERATE_VERSION_AND_CHANGELOG "Generate only changelog and version" OFF)

if (GENERATE_VERSION_AND_CHANGELOG)

# Write current version to version.txt
configure_file("${CMAKE_SOURCE_DIR}/res/version.txt.in" "${CMAKE_BINARY_DIR}/version.txt" @ONLY)

# Write current changelog to changelog.txt
configure_file("${CMAKE_SOURCE_DIR}/changelogs/${PROJECT_VERSION}.txt" "${CMAKE_BINARY_DIR}/changelog.txt" @ONLY)

else()

# Use this snippet *after* PROJECT(xxx):
if(UNIX)
    if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
        set(CMAKE_INSTALL_PREFIX /usr CACHE PATH "default prefix" FORCE)
    endif(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
    include(GNUInstallDirs)
endif()

include(ExternalProject)

set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_SUPPRESS_REGENERATION ON)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
cmake_policy(SET CMP0069 NEW) #find package policy
if(POLICY CMP0167)
    cmake_policy(SET CMP0167 NEW) #boost config policy
endif()
set(CMAKE_CXX_EXTENSIONS OFF)

# Default to an optimized Release build when no build type is specified.
# Without this, a plain `cmake` configure compiles with no optimization (-O0),
# which makes the resulting binary noticeably slower at runtime.
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type" FORCE)
    message(STATUS "No build type specified, defaulting to Release")
endif()

find_program(CCACHE_FOUND ccache)
if(CCACHE_FOUND)
   set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
endif()

option(ENABLE_INTERPROCEDURAL_OPTIMIZATION "Enable IPO/LTO" OFF)

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
# Enable Link-Time Optimization (IPO/LTO) for optimized builds when the
# toolchain supports it. Pure runtime perf win with no behavior change; only
# applied to Release / RelWithDebInfo so Debug builds stay fast to link.
if (ENABLE_INTERPROCEDURAL_OPTIMIZATION)
    include(CheckIPOSupported)
    check_ipo_supported(RESULT NKR_IPO_SUPPORTED OUTPUT NKR_IPO_ERROR)
    if(NKR_IPO_SUPPORTED)
        set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)
        set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO ON)
        message(STATUS "IPO/LTO enabled for optimized builds")
    else()
        set(CMAKE_INTERPROCEDURAL_OPTIMIZATION OFF)
        message(WARNING "IPO/LTO not supported: ${NKR_IPO_ERROR}")
    endif()
else ()
    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION OFF)
    message(STATUS "IPO/LTO not enabled")
endif ()

set(NYXARIA "src/nekobox")
set(GHARQAD "src/gharqad")
set(ONPARTY "src/3rdparty")


# Target Source Translations

file(GLOB TS_FILES CONFIGURE_DEPENDS "res/translations/*.ts")

foreach(TS_FILE ${TS_FILES})
    # Get the base name of the file without the extension
    get_filename_component(QM_FILE ${TS_FILE} NAME_WE)
    # Define the output path for .qm files
    set(QM_FILE_PATH "${CMAKE_BINARY_DIR}/${QM_FILE}.qm")
    # Add the generated .qm file to the list
    list(APPEND QM_FILES ${QM_FILE_PATH})
    # Add the generated .qm filename to the list
    list(APPEND QM_FILENAMES ${QM_FILE})
endforeach()

find_package(Qt6 REQUIRED COMPONENTS Widgets LinguistTools Concurrent)

if (NKR_CROSS)
    set_property(TARGET Qt6::moc PROPERTY IMPORTED_LOCATION /usr/bin/moc)
    set_property(TARGET Qt6::uic PROPERTY IMPORTED_LOCATION /usr/bin/uic)
    set_property(TARGET Qt6::rcc PROPERTY IMPORTED_LOCATION /usr/bin/rcc)
    set_property(TARGET Qt6::lrelease PROPERTY IMPORTED_LOCATION /usr/bin/lrelease)
    set_property(TARGET Qt6::lupdate PROPERTY IMPORTED_LOCATION /usr/bin/lupdate)
endif ()

include("cmake/print.cmake")
include("cmake/nkr.cmake")

#### Platform Variables ####
if (WIN32)
    include("cmake/windows/windows.cmake")
else ()
    include("cmake/unix/unix.cmake")
endif ()

#### default prefix path ####

message("[CMAKE_PREFIX_PATH] ${CMAKE_PREFIX_PATH}")

# for some cross toolchain
list(APPEND CMAKE_FIND_ROOT_PATH ${CMAKE_PREFIX_PATH})
message("[CMAKE_FIND_ROOT_PATH] ${CMAKE_FIND_ROOT_PATH}")

#### NKR ####
option(SKIP_UPDATER "Always hide update button" ON)

if(UNIX)
set(ENABLE_EMOJI_EMBEEDING_DEFAULT OFF)
else()
set(ENABLE_EMOJI_EMBEEDING_DEFAULT ON)
endif()

option(MIGRATE_LMDB "Migrate from lmdb" OFF)
option(SKIP_LEVELDB "Do not use rocksdb" OFF)
option(SKIP_JS_UPDATER "Skip JS update checker" OFF)
option(USE_HOTKEYS "Skip HotKeys" ON)
option(BUILD_GO_PARTS "Build go parts" ON)
option(CPR_USE_SYSTEM_CURL "Use system cpr" ON)
option(CPR_ENABLE_INSTALL "Use cpr as bundled dependency" OFF)
option(ENABLE_EMOJI_EMBEEDING "Enable profile filtering on subscription update" ${ENABLE_EMOJI_EMBEEDING_DEFAULT})
set(QJS_ENABLE_INSTALL OFF CACHE BOOL "Enable quickjs-ng install")

find_package(Threads)

if (NKR_PACKAGE)
    nkr_add_compile_definitions(NKR_CPP_USE_APPDATA)
endif()

set(BUILD_SHARED_LIBS OFF)

if (ENABLE_EMOJI_EMBEEDING)
  if (Qt6Core_VERSION VERSION_GREATER "6.9.0")
    set(PLATFORM_SOURCES ${PLATFORM_SOURCES} "res/fonts/twe.qrc")
  else()
    set(PLATFORM_SOURCES ${PLATFORM_SOURCES} "res/fonts/noto.qrc")
  endif()
endif()

if (USE_HOTKEYS)
  set(QHOTKEY_INSTALL OFF CACHE BOOL "Disable install QHotkey library")
  set(QHOTKEY_EXAMPLES OFF CACHE BOOL "Enable compiling examples")
  add_subdirectory("${ONPARTY}/QHotkey")
  nkr_add_compile_definitions(USE_HOTKEYS)
  list(APPEND NKR_EXTERNAL_TARGETS qhotkey)
endif()


find_program(THRIFT_COMPILER thrift REQUIRED)

if(EXISTS "${THRIFT_COMPILER}/tools/thrift/thrift.exe" AND NOT IS_DIRECTORY "${THRIFT_COMPILER}/tools/thrift/thrift.exe")
     set(THRIFT_COMPILER "${THRIFT_COMPILER}/tools/thrift/thrift.exe")
     set(ENV{THRIFT_COMPILER} "${THRIFT_COMPILER}")
endif()

message(STATUS "Found Thrift " ${THRIFT_COMPILER})

set(THRIFT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/core/server/gen/libcore.thrift")
set(THRIFT_GEN_DIR "${CMAKE_CURRENT_BINARY_DIR}/gen-cpp")
file(MAKE_DIRECTORY "${THRIFT_GEN_DIR}")

execute_process(
#    OUTPUT "${THRIFT_GEN_DIR}/LibcoreService.h" "${THRIFT_GEN_DIR}/LibcoreService.cpp"
    COMMAND ${THRIFT_COMPILER} --gen cpp --out "${THRIFT_GEN_DIR}" "${THRIFT_FILE}"
    WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
)

# Add a custom target to ensure the code generation runs
add_custom_target(generate_thrift_code ALL DEPENDS "${THRIFT_GEN_DIR}/LibcoreService.h")

# Include the generated files in your project
include_directories("${THRIFT_GEN_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/src")
set(THRIFT_GENERATED_SOURCES
    "${GHARQAD}/libcore.cpp"
)

# Check if the directory exists
if(EXISTS "${CMAKE_SOURCE_DIR}/core/server/vendor")
    message(STATUS "Directory core/server/vendor exists.")
else()
    message(STATUS "Directory core/server/vendor does not exist.")
endif()

file(GLOB_RECURSE PROJECT_SOURCES_GLOB
        CONFIGURE_DEPENDS
        ${GHARQAD}/configs/proxy/*.cpp
        ${NYXARIA}/configs/proxy/*.hpp
        ${NYXARIA}/configs/proxy/*.h

        ${NYXARIA}/dataStore/*.hpp
        ${NYXARIA}/dataStore/*.h
        ${GHARQAD}/dataStore/*.cpp

        ${NYXARIA}/global/*.hpp
        ${NYXARIA}/global/*.h
        ${GHARQAD}/global/*.cpp

        ${NYXARIA}/ui/info/*.ui
        ${NYXARIA}/ui/info/*.h
        ${NYXARIA}/ui/info/*.hpp

        ${NYXARIA}/ui/profile/*.h
        ${NYXARIA}/ui/profile/*.hpp
        ${NYXARIA}/ui/profile/*.ui
        ${GHARQAD}/ui/profile/*.cpp

        ${GHARQAD}/ui/setting/*.cpp
        ${NYXARIA}/ui/setting/*.h
        ${NYXARIA}/ui/setting/*.hpp
        ${NYXARIA}/ui/setting/*.ui

        ${GHARQAD}/ui/group/*.cpp
        ${NYXARIA}/ui/group/*.h
        ${NYXARIA}/ui/group/*.hpp
        ${NYXARIA}/ui/group/*.ui

        ${NYXARIA}/ui/utils/*.hpp
        ${NYXARIA}/ui/utils/*.h
        ${GHARQAD}/ui/utils/*.cpp
)

# Sources
set(PROJECT_SOURCES
        ${PLATFORM_SOURCES}
        ${THRIFT_GENERATED_SOURCES}
        ${SECURITY_SOURCES}
        ${PROJECT_SOURCES_GLOB}
        ${GHARQAD}/main.cpp

        ${ONPARTY}/qrcodegen/qrcodegen.cpp
        ${ONPARTY}/qv2ray/v2/ui/LogHighlighter.cpp
        ${ONPARTY}/qv2ray/v2/ui/QvAutoCompleteTextEdit.cpp
        ${ONPARTY}/qv2ray/v2/ui/widgets/common/QJsonModel.cpp
        ${ONPARTY}/qv2ray/v2/ui/widgets/editors/w_JsonEditor.cpp
        ${ONPARTY}/qv2ray/v2/ui/widgets/editors/w_JsonEditor.hpp
        ${ONPARTY}/qv2ray/v2/ui/widgets/editors/w_JsonEditor.ui
        ${ONPARTY}/qv2ray/v2/ui/widgets/speedchart/SpeedWidget.cpp
        ${ONPARTY}/qv2ray/v2/ui/widgets/speedchart/SpeedWidget.hpp
        ${ONPARTY}/qv2ray/v2/proxy/QvProxyConfigurator.cpp
        ${ONPARTY}/quirc/lib/decode.c
        ${ONPARTY}/quirc/lib/identify.c
        ${ONPARTY}/quirc/lib/quirc.c
        ${ONPARTY}/quirc/lib/version_db.c

        ${GHARQAD}/api/RPC.cpp
        ${GHARQAD}/stats/traffic/TrafficLooper.cpp

        ${GHARQAD}/configs/ConfigBuilder.cpp


        ${NYXARIA}/configs/sub/GroupUpdater.hpp
        ${NYXARIA}/configs/sub/HappDecrypt.hpp
        ${NYXARIA}/configs/ConfigBuilder.hpp
        ${NYXARIA}/api/RPC.h

        ${NYXARIA}/stats/traffic/TrafficLooper.hpp

        ${GHARQAD}/configs/sub/GroupUpdater.cpp
        ${GHARQAD}/configs/sub/HappDecrypt.cpp
        ${GHARQAD}/configs/warp/warp.cpp
        ${NYXARIA}/configs/warp/warp.hpp
        ${NYXARIA}/sys/AutoRun.hpp
        ${NYXARIA}/sys/Process.hpp
        ${NYXARIA}/sys/Settings.h

        ${GHARQAD}/sys/Process.cpp
        ${GHARQAD}/sys/AutoRun.cpp

        ${GHARQAD}/ui/mainwindow_rpc.cpp
        ${GHARQAD}/ui/mainwindow.cpp
        ${GHARQAD}/ui/mainwindow_table.cpp
        ${NYXARIA}/ui/mainwindow.h
        ${NYXARIA}/ui/mainwindow_table.h
        ${NYXARIA}/ui/mainwindow.ui

        res/nekobox.qrc
        ${QV2RAY_RC}
        res/darkstyle.qrc
        res/qss/feiyangqingyun/qss.qrc

        ${GHARQAD}/sys/Settings.cpp
        ${GHARQAD}/sys/AutoRun.cpp
        ${GHARQAD}/sys/Process.cpp
        ${NYXARIA}/ui/mainwindow_interface.h
        ${NYXARIA}/stats/connections/connectionLister.hpp
        ${GHARQAD}/stats/connectionLister/connectionLister.cpp
        ${GHARQAD}/configs/proxy/Json2Bean.cpp

        ${GHARQAD}/stats/autotester/ProxyAutoTester.cpp
        ${NYXARIA}/stats/autotester/ProxyAutoTester.hpp

)

# Qt exe
qt_add_executable(nekobox
        MANUAL_FINALIZATION
        ${PROJECT_SOURCES}
)

# Target
set_property(TARGET nekobox PROPERTY AUTOUIC ON)
set_property(TARGET nekobox PROPERTY AUTOMOC ON)
set_property(TARGET nekobox PROPERTY AUTORCC ON)

nkr_add_compile_definitions(UNICODE=yes)
nkr_add_compile_definitions(_UNICODE=yes)
nkr_add_compile_definitions(NOMINMAX=yes)
nkr_add_compile_definitions(WIN32_LEAN_AND_MEAN=yes) 
nkr_add_compile_definitions(_SCL_SECURE_NO_WARNINGS=yes)
nkr_add_compile_definitions(_CRT_SECURE_NO_WARNINGS=yes)

if(SKIP_UPDATER)
    nkr_add_compile_definitions(SKIP_UPDATE_BUTTON=yes)
endif()


if (NOT SKIP_LEVELDB)
    find_package(leveldb)
    if (leveldb_FOUND)
        target_link_libraries(nekobox PRIVATE leveldb::leveldb)
    else()
        nkr_add_compile_definitions(SKIP_LEVELDB=yes)
    endif()
else()
    nkr_add_compile_definitions(SKIP_LEVELDB=yes)
endif()

if(SKIP_JS_UPDATER)
    nkr_add_compile_definitions(SKIP_JS_UPDATER=yes)
else()
    find_package(qjs CONFIG QUIET)
    if(qjs_FOUND)
        message(STATUS "Using system QuickJS-NG")
    else()
        message(STATUS "System QuickJS-NG not found, using bundled version")
        add_subdirectory("${ONPARTY}/qjs")
    endif()

    target_link_libraries(nekobox PRIVATE qjs)

    target_sources(nekobox
            PRIVATE
            ${GHARQAD}/js/js_updater.cpp
            ${NYXARIA}/js/js_updater.h
            ${NYXARIA}/js/blocking_queue.h
            ${NYXARIA}/js/js_updater.h
            ${NYXARIA}/js/message_queue.h
            ${NYXARIA}/js/version.h

            res/nekobox_updater.qrc
    )
endif()


target_include_directories(nekobox PRIVATE
    ${Qt6Protobuf_PRIVATE_INCLUDE_DIRS}
)

set_target_properties(nekobox PROPERTIES
        WIN32_EXECUTABLE TRUE
)

set(EXECUTABLE_NAME "nekobox" CACHE STRING "Executable name")
set_target_properties(nekobox PROPERTIES OUTPUT_NAME "${EXECUTABLE_NAME}")

add_custom_command(TARGET nekobox POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E make_directory
        "$<TARGET_FILE_DIR:nekobox>/public"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/res/public/expanded_rsa_keys.json"
        "$<TARGET_FILE_DIR:nekobox>/expanded_rsa_keys.json"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/res/languages.txt"
        "$<TARGET_FILE_DIR:nekobox>/languages.txt"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/res/public/about.html"
        "$<TARGET_FILE_DIR:nekobox>/about.html"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/res/public/check_new_release.js"
        "$<TARGET_FILE_DIR:nekobox>/check_new_release.js"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/res/public/announcement_message.js"
        "$<TARGET_FILE_DIR:nekobox>/announcement_message.js"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_SOURCE_DIR}/res/public/check_routeprofiles.js"
        "$<TARGET_FILE_DIR:nekobox>/check_routeprofiles.js"
    COMMENT "Copying happ crypt5 key data, scripts, about.html and languages.txt"
)

set(LUPDATE_OPTIONS
        -locations none -no-obsolete
)
qt_add_lupdate(nekobox TS_FILES ${TS_FILES} OPTIONS ${LUPDATE_OPTIONS})
qt_add_lrelease(nekobox TS_FILES ${TS_FILES} QM_FILES_OUTPUT_VARIABLE QM_FILES)

# configure_file(res/translations/translations.qrc ${CMAKE_BINARY_DIR} COPYONLY)
# target_sources(nekobox PRIVATE ${CMAKE_BINARY_DIR}/translations.qrc)

find_package(Thrift QUIET)

if (Thrift_FOUND)
    set(THRIFT_LIBRARIES thrift::thrift)
else()
    find_package(PkgConfig REQUIRED)
    pkg_check_modules(THRIFT thrift REQUIRED)
endif()

target_include_directories(nekobox PRIVATE ${THRIFT_INCLUDE_DIRS})
target_link_libraries(nekobox PRIVATE ${THRIFT_LIBRARIES})


# Try system-installed CPR first
find_package(cpr CONFIG QUIET)

if(cpr_FOUND)
    message(STATUS "Using system CPR")
else()
    message(STATUS "System CPR not found, using bundled version")
    add_subdirectory("${ONPARTY}/cpr")
endif()

target_link_libraries(nekobox PRIVATE cpr::cpr)

#if (MSVC)
#    include(FindBoost)
#    set(Boost_USE_STATIC_LIBS ON)
#    set(Boost_USE_MULTITHREADED ON)
#    set(Boost_USE_STATIC_RUNTIME ON)
#endif()

find_package(Boost REQUIRED COMPONENTS filesystem)
target_include_directories(nekobox PRIVATE ${Boost_INCLUDE_DIRS})
target_link_libraries(nekobox PRIVATE Boost::filesystem)

find_package(OpenSSL REQUIRED)
target_include_directories(nekobox PRIVATE ${OPENSSL_INCLUDE_DIR})
target_link_libraries(nekobox PRIVATE OpenSSL::SSL OpenSSL::Crypto)
if (UNIX)
find_library(ACL_LIB acl)

if(NOT ACL_LIB)
    if(NOT CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
        message(FATAL_ERROR "libacl not found. Install libacl-devel.")
    else()
        message(STATUS "libacl not found on FreeBSD, continuing without it")
    endif()
endif()

if(ACL_LIB)
    target_link_libraries(nekobox PRIVATE ${ACL_LIB})
endif()
endif()

# Target Link

target_link_libraries(nekobox PRIVATE
        Qt6::Widgets Qt6::Concurrent
        Threads::Threads
        ${NKR_EXTERNAL_TARGETS}
        ${PLATFORM_LIBRARIES}
)

#find_package(leveldb REQUIRED)
#target_link_libraries(nekobox PRIVATE leveldb::leveldb)

if (MSVC)
    target_compile_options(nekobox PRIVATE "/std:c++20")       # add c++20 feature
    if(CMAKE_SIZEOF_VOID_P EQUAL 4)
        set_target_properties(nekobox PROPERTIES
            MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
        )
    endif()
endif()

# force suppress unused warnings
if (MSVC)
    target_compile_options(nekobox PRIVATE /wd4101 /wd4189)
else()
    target_compile_options(nekobox PRIVATE -Wno-unused-value)
endif()

if (BUILD_GO_PARTS)
    find_program(GO_EXECUTABLE go)


# Check if the vendor directory exists
    if(EXISTS "${CMAKE_SOURCE_DIR}/core/server/vendor")
        message(STATUS "Directory core/server/vendor exists.")
        set(GO_MOD_TIDY_FLAG OFF CACHE STRING "Run go mod tidy before build")
    else()
        message(STATUS "Directory core/server/vendor does not exist.")
        set(GO_MOD_TIDY_FLAG ON CACHE STRING "Run go mod tidy before build")
    endif()

    set(GO_SOURCE_DIR ${CMAKE_SOURCE_DIR}/core)

    if(EXISTS ${GO_SOURCE_DIR}/CMakeLists.txt AND GO_EXECUTABLE)
        add_subdirectory(${GO_SOURCE_DIR})
    else()
        message(STATUS "Go server not found, skipping")
    endif()
endif()



if (MIGRATE_LMDB)
    # Track if dependency resolution succeeds
    set(LMDB_SUCCESS FALSE)

    if (MSVC)
        # Find package with REQUIRED omitted to simulate "try"
        find_package(unofficial-lmdb CONFIG)
        if(unofficial-lmdb_FOUND)
            target_link_libraries(nekobox PRIVATE unofficial::lmdb::lmdb)
            set(LMDB_SUCCESS TRUE)
        endif()
    else()
        pkg_check_modules(LMDB lmdb)
        if(LMDB_FOUND)
            message(STATUS "LMDB found via pkg-config")
            target_include_directories(nekobox PRIVATE ${LMDB_INCLUDE_DIRS})
            target_link_libraries(nekobox PRIVATE ${LMDB_LIBRARIES})
            target_compile_options(nekobox PRIVATE ${LMDB_CFLAGS_OTHER})
            set(LMDB_SUCCESS TRUE)
        else()
            message(STATUS "LMDB not found via pkg-config, trying manual search")
            find_path(LMDB_INCLUDE_DIR lmdb.h)
            find_library(LMDB_LIBRARY lmdb)
            if(LMDB_INCLUDE_DIR AND LMDB_LIBRARY)
                target_include_directories(nekobox PRIVATE ${LMDB_INCLUDE_DIR})
                target_link_libraries(nekobox PRIVATE ${LMDB_LIBRARY})
                set(LMDB_SUCCESS TRUE)
            endif()
        endif()
    endif()
    # The "catch" block behavior: executes only if search succeeded
    if(LMDB_SUCCESS)
        nkr_add_compile_definitions(MIGRATE_LMDB=yes)
        nkr_add_compile_definitions(LMDB_ENABLE_MUTEX=yes)
        nkr_add_compile_definitions(LMDB_ENABLE_MAPSIZE_METRICS=yes)
    else()
        # Handle failure gracefully here
        message(WARNING "LMDB was requested but could not be found. Disabling MIGRATE_LMDB.")
    endif()
endif()

find_package(yaml-cpp CONFIG QUIET)

if (TARGET yaml-cpp::yaml-cpp)
    set(YAML_CPP_TARGET yaml-cpp::yaml-cpp)
else()
    find_package(yaml-cpp REQUIRED)
    set(YAML_CPP_TARGET yaml-cpp)
endif()

target_link_libraries(nekobox PRIVATE ${YAML_CPP_TARGET})

#qt_finalize_executable(nekobox)
if (UNIX)
download_srslist()

if(NOT CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
    remove_rpath(nekobox)
endif()

set(PROGRAMPREFIX "${CMAKE_INSTALL_LIBEXECDIR}/Iblis" CACHE STRING "Installation Directory")

get_filename_component(START "${CMAKE_INSTALL_BINDIR}/nekobox" REALPATH BASE_DIR "${CMAKE_INSTALL_PREFIX}")
get_filename_component(MAIN "${PROGRAMPREFIX}/${EXECUTABLE_NAME}" REALPATH BASE_DIR "${CMAKE_INSTALL_PREFIX}")
get_filename_component(ICON "${CMAKE_INSTALL_DATADIR}/icons/hicolor/256x256/apps/nekobox.png" REALPATH BASE_DIR "${CMAKE_INSTALL_PREFIX}")

# Configure the desktop file
configure_file(
    "${CMAKE_SOURCE_DIR}/script/nekobox.desktop.in"
    "${CMAKE_BINARY_DIR}/nekobox.desktop"
    @ONLY
)

# Configure the desktop file
configure_file(
    "${CMAKE_SOURCE_DIR}/script/start.sh.in"
    "${CMAKE_BINARY_DIR}/start.sh"
    @ONLY
)

install(
    FILES "${CMAKE_SOURCE_DIR}/res/public/icon.png"
    RENAME "nekobox.png"
    DESTINATION "${CMAKE_INSTALL_DATADIR}/icons/hicolor/256x256/apps"
    COMPONENT gui
)

install(
    FILES "${CMAKE_BINARY_DIR}/nekobox.desktop"
    DESTINATION "${CMAKE_INSTALL_DATADIR}/applications"
    COMPONENT gui
)

install(
    PROGRAMS "${CMAKE_BINARY_DIR}/start.sh"
    RENAME "nekobox"
    DESTINATION "${CMAKE_INSTALL_BINDIR}"
    COMPONENT gui
)

if(EXISTS "${CMAKE_SOURCE_DIR}/global.ini")
    install(FILES ${CMAKE_SOURCE_DIR}/global.ini DESTINATION "${PROGRAMPREFIX}/public" COMPONENT gui)
endif()

if(NOT SKIP_UPDATER AND NOT SKIP_JS_UPDATER)
    install(FILES ${CMAKE_SOURCE_DIR}/res/public/check_new_release.js DESTINATION "${PROGRAMPREFIX}/public" COMPONENT gui)
endif()

install(FILES ${QM_FILES} DESTINATION "${PROGRAMPREFIX}/public" COMPONENT gui)
install(TARGETS nekobox DESTINATION "${PROGRAMPREFIX}" COMPONENT gui)
install(FILES 
    "${CMAKE_SOURCE_DIR}/srslist.json"
    "${CMAKE_SOURCE_DIR}/res/public/announcement_message.js"
    "${CMAKE_SOURCE_DIR}/res/public/check_routeprofiles.js"
    "${CMAKE_SOURCE_DIR}/res/public/expanded_rsa_keys.json"
    "${CMAKE_SOURCE_DIR}/res/languages.txt" DESTINATION "${PROGRAMPREFIX}/public"
    COMPONENT gui)

#install_if_exists(${CMAKE_SOURCE_DIR}/res/public/emoji.ttf "${PROGRAMPREFIX}/public")
install_if_exists(${CMAKE_SOURCE_DIR}/res/public/about.html "${PROGRAMPREFIX}/public")

endif()



endif()
