CMakeLists.txt

cmake_minimum_required(VERSION 3.16)

# ----------------------------------------------------------------------------
# Project
# ----------------------------------------------------------------------------
set(RAG_QT_VERSION "0.0.1")

project(rag-qt VERSION ${RAG_QT_VERSION} LANGUAGES C CXX)

set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

option(BUILD_RELEASE_LITE "Build release lite model" OFF)

# ----------------------------------------------------------------------------
# CMake Policies
# ----------------------------------------------------------------------------
if(POLICY CMP0168)
    cmake_policy(SET CMP0168 NEW)
    set(CMAKE_POLICY_DEFAULT_CMP0168 NEW)
endif()

if(POLICY CMP0141)
    cmake_policy(SET CMP0141 NEW)
    set(CMAKE_POLICY_DEFAULT_CMP0141 NEW)
endif()

if(POLICY CMP0075)
    cmake_policy(SET CMP0075 NEW)
    set(CMAKE_POLICY_DEFAULT_CMP0075 NEW)
endif()

if(POLICY CMP0194)
    cmake_policy(SET CMP0194 NEW)
    set(CMAKE_POLICY_DEFAULT_CMP0194 NEW)
endif()

if(MSVC)
    add_compile_options(/wd4996)
endif()

# ----------------------------------------------------------------------------
# Build Type Configuration
# ----------------------------------------------------------------------------
if(NOT CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "")
    set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Build type config" FORCE)
endif()

if(CMAKE_BUILD_TYPE STREQUAL "Debug")
    add_compile_definitions(DEBUG)
endif()

if(BUILD_RELEASE_LITE)
    add_compile_definitions(LITE_APP)
    set(CONFIG_FILES_PATH ${CMAKE_CURRENT_SOURCE_DIR}/res/configs/Release-Lite)
    set(OUTPUT_BASE_NAME "Release-Lite")
    message(STATUS "Build Release-Lite")
else()
    set(CONFIG_FILES_PATH ${CMAKE_CURRENT_SOURCE_DIR}/res/configs/${CMAKE_BUILD_TYPE})
    set(OUTPUT_BASE_NAME ${CMAKE_BUILD_TYPE})
endif()

# ----------------------------------------------------------------------------
# Platform Detection and Output Directory Configuration
# ----------------------------------------------------------------------------
set(OUTPUT_DIR_BASE "${CMAKE_CURRENT_SOURCE_DIR}/bin")

if(WIN32)
    # Windows: Standard layout - all files in same directory
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")
    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}/plugins")
    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")
    
    # Multi-configuration support
    if(CMAKE_CONFIGURATION_TYPES)
        foreach(CFG DEBUG RELEASE RELWITHDEBINFO MINSIZEREL)
            string(TOUPPER ${CFG} CFG_UPPER)
            set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFG_UPPER} "${OUTPUT_DIR_BASE}/${CFG}")
            set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CFG_UPPER} "${OUTPUT_DIR_BASE}/${CFG}/plugins")
            set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CFG_UPPER} "${OUTPUT_DIR_BASE}/${CFG}")
        endforeach()
    endif()
    
    set(EXECUTABLE_OUTPUT_PATH "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")
    set(LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}/plugins")
    set(RUNTIME_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")
    set(RESOURCE_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}/res")
    set(CONFIG_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}/configs")
    set(PLUGIN_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}/plugins")
    
elseif(APPLE)
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")
    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")
    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")

    set(APP_BUNDLE_NAME "${CMAKE_PROJECT_NAME}.app")
    set(APP_BUNDLE_PATH "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}/${APP_BUNDLE_NAME}")
    set(APP_CONTENTS_PATH "${APP_BUNDLE_PATH}/Contents")
    set(APP_MACOS_PATH "${APP_CONTENTS_PATH}/MacOS")
    set(APP_RESOURCES_PATH "${APP_CONTENTS_PATH}/Resources")
    set(APP_PLUGINS_PATH "${APP_CONTENTS_PATH}/PlugIns")
    
    set(EXECUTABLE_OUTPUT_PATH "${APP_MACOS_PATH}")
    set(LIBRARY_OUTPUT_DIRECTORY "${APP_PLUGINS_PATH}/plugins") 
    set(RUNTIME_OUTPUT_DIRECTORY "${APP_MACOS_PATH}")
    
    set(RESOURCE_OUTPUT_DIRECTORY "${APP_RESOURCES_PATH}")
    set(CONFIG_OUTPUT_DIRECTORY "${APP_RESOURCES_PATH}/configs") # 变更此行，配合代码中的 configs/ 前缀
    set(PLUGIN_OUTPUT_DIRECTORY "${APP_PLUGINS_PATH}/plugins") # for our plugins
    
elseif(UNIX)
    # Linux: Standard FHS-like layout with prefix
    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")
    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}/plugins")
    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")
    
    if(CMAKE_CONFIGURATION_TYPES)
        foreach(CFG DEBUG RELEASE RELWITHDEBINFO MINSIZEREL)
            string(TOUPPER ${CFG} CFG_UPPER)
            set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFG_UPPER} "${OUTPUT_DIR_BASE}/${CFG}")
            set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CFG_UPPER} "${OUTPUT_DIR_BASE}/${CFG}/plugins")
            set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CFG_UPPER} "${OUTPUT_DIR_BASE}/${CFG}")
        endforeach()
    endif()
    
    set(EXECUTABLE_OUTPUT_PATH "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")
    set(LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}/plugins")
    set(RUNTIME_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")
    set(RESOURCE_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}/share/rag-qt/res")
    set(CONFIG_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}/share/rag-qt/configs")
    set(PLUGIN_OUTPUT_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}/plugins")
endif()

# Export variables for submodules
set(EXECUTABLE_OUTPUT_PATH "${EXECUTABLE_OUTPUT_PATH}" CACHE STRING "Executable output path" FORCE)
set(LIBRARY_OUTPUT_DIRECTORY "${LIBRARY_OUTPUT_DIRECTORY}" CACHE STRING "Library output directory" FORCE)
set(RUNTIME_OUTPUT_DIRECTORY "${RUNTIME_OUTPUT_DIRECTORY}" CACHE STRING "Runtime output directory" FORCE)
set(RESOURCE_OUTPUT_DIRECTORY "${RESOURCE_OUTPUT_DIRECTORY}" CACHE STRING "Resource output directory" FORCE)
set(CONFIG_OUTPUT_DIRECTORY "${CONFIG_OUTPUT_DIRECTORY}" CACHE STRING "Config output directory" FORCE)
set(PLUGIN_OUTPUT_DIRECTORY "${PLUGIN_OUTPUT_DIRECTORY}" CACHE STRING "Plugin output directory" FORCE)

message(STATUS "Platform: ${CMAKE_SYSTEM_NAME}")
message(STATUS "Output directory: ${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")
if(APPLE)
    message(STATUS "App bundle: ${APP_BUNDLE_PATH}")
    message(STATUS "  MacOS: ${APP_MACOS_PATH}")
    message(STATUS "  Resources: ${APP_RESOURCES_PATH}")
    message(STATUS "  PlugIns: ${APP_PLUGINS_PATH}")
else()
    message(STATUS "Plugin output directory: ${PLUGIN_OUTPUT_DIRECTORY}")
    message(STATUS "Resource output directory: ${RESOURCE_OUTPUT_DIRECTORY}")
    message(STATUS "Config output directory: ${CONFIG_OUTPUT_DIRECTORY}")
endif()

# ----------------------------------------------------------------------------
# Qt
# ----------------------------------------------------------------------------
find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Core Gui Widgets LinguistTools Network Multimedia)
find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core Gui Widgets LinguistTools Network Multimedia)

# Qt private includes (for zip, etc.)
set(Qt_PRIVATE_INCLUDES 
    ${Qt${QT_VERSION_MAJOR}Core_PRIVATE_INCLUDE_DIRS}
    ${Qt${QT_VERSION_MAJOR}Gui_PRIVATE_INCLUDE_DIRS}
)

# Get Qt bin directory for deployment
get_target_property(QT_QMAKE_EXECUTABLE Qt${QT_VERSION_MAJOR}::qmake IMPORTED_LOCATION)
if(QT_QMAKE_EXECUTABLE)
    get_filename_component(QT_BIN_DIR "${QT_QMAKE_EXECUTABLE}" DIRECTORY)
else()
    find_program(QT_QMAKE_EXECUTABLE NAMES qmake-qt6 qmake6 qmake)
    if(QT_QMAKE_EXECUTABLE)
        get_filename_component(QT_BIN_DIR "${QT_QMAKE_EXECUTABLE}" DIRECTORY)
    endif()
endif()

# ----------------------------------------------------------------------------
# 3rd Party Libraries
# ----------------------------------------------------------------------------

# OpenMP
find_package(OpenMP QUIET COMPONENTS CXX)
find_package(hj REQUIRED)

# ----------------------------------------------------------------------------
# Include Directories
# ----------------------------------------------------------------------------
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/3rd/high-jump)

# ----------------------------------------------------------------------------
# Translations
# ----------------------------------------------------------------------------
file(GLOB TS_FILES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/res/languages/*.ts")

if(TARGET Qt${QT_VERSION_MAJOR}::lrelease)
    set(LRELEASE_EXECUTABLE "$<TARGET_FILE:Qt${QT_VERSION_MAJOR}::lrelease>")
else()
    find_program(LRELEASE_EXECUTABLE NAMES lrelease-qt6 lrelease-qt5 lrelease)
    if(NOT LRELEASE_EXECUTABLE)
        message(FATAL_ERROR "Could not find Qt lrelease executable")
    endif()
endif()

set(QM_FILES)
foreach(TS_FILE IN LISTS TS_FILES)
    get_filename_component(TS_DIR "${TS_FILE}" DIRECTORY)
    get_filename_component(TS_NAME_WE "${TS_FILE}" NAME_WE)
    set(QM_BUILD_FILE "${CMAKE_CURRENT_BINARY_DIR}/res/languages/${TS_NAME_WE}.qm")
    set(QM_FILE "${CMAKE_CURRENT_SOURCE_DIR}/res/languages/${TS_NAME_WE}.qm")

    add_custom_command(
        OUTPUT "${QM_FILE}"
        COMMAND "${CMAKE_COMMAND}" -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/res/languages"
        COMMAND "${CMAKE_COMMAND}" -E make_directory "${CMAKE_CURRENT_SOURCE_DIR}/res/languages"
        COMMAND "${LRELEASE_EXECUTABLE}" "${TS_FILE}" -qm "${QM_BUILD_FILE}"
        COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${QM_BUILD_FILE}" "${QM_FILE}"
        DEPENDS "${TS_FILE}"
        COMMENT "Generating ${TS_NAME_WE}.qm"
        BYPRODUCTS "${QM_BUILD_FILE}"
        VERBATIM
    )

    list(APPEND QM_FILES "${QM_FILE}")
endforeach()

add_custom_target(release_translations ALL DEPENDS ${QM_FILES})
message(STATUS "Translation files: ${QM_FILES}")

# ----------------------------------------------------------------------------
# Platform-Specific Configuration
# ----------------------------------------------------------------------------
if(WIN32)
    set(logo_resource "${CMAKE_CURRENT_SOURCE_DIR}/res/icons/logo.rc")
else()
    set(logo_resource "")
endif()

# ----------------------------------------------------------------------------
# Submodules
# ----------------------------------------------------------------------------
add_subdirectory(3rd/libqt)

if(NOT BUILD_RELEASE_LITE)
    if(APPLE)
        set(ORIGINAL_RUNTIME_DIR "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
        set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${APP_MACOS_PATH}")
        set(EXECUTABLE_OUTPUT_PATH "${APP_MACOS_PATH}" CACHE STRING "" FORCE)

        set(RAG_CORE_CONFIG_OUTPUT_DIRECTORY "${APP_RESOURCES_PATH}/configs" CACHE STRING "" FORCE)

        if(CMAKE_CONFIGURATION_TYPES)
            foreach(CFG DEBUG RELEASE RELWITHDEBINFO MINSIZEREL)
                string(TOUPPER ${CFG} CFG_UPPER)
                set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFG_UPPER} "${OUTPUT_DIR_BASE}/${CFG}/${CMAKE_PROJECT_NAME}.app/Contents/MacOS")
            endforeach()
        endif()
    endif()

    add_subdirectory(3rd/rag-core)

    if(APPLE)
        set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${ORIGINAL_RUNTIME_DIR}")
        set(EXECUTABLE_OUTPUT_PATH "${APP_MACOS_PATH}" CACHE STRING "" FORCE) # 主轴保留指向
        
        unset(RAG_CORE_CONFIG_OUTPUT_DIRECTORY CACHE)

        if(CMAKE_CONFIGURATION_TYPES)
            foreach(CFG DEBUG RELEASE RELWITHDEBINFO MINSIZEREL)
                string(TOUPPER ${CFG} CFG_UPPER)
                set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CFG_UPPER} "${OUTPUT_DIR_BASE}/${CFG}")
            endforeach()
        endif()
    endif()
endif()

# ----------------------------------------------------------------------------
# Source Code
# ----------------------------------------------------------------------------
list(APPEND PROJECT_SOURCES
    ${CMAKE_CURRENT_SOURCE_DIR}/res/res.qrc
)

add_subdirectory(src)

# ----------------------------------------------------------------------------
# Executable / Library
# ----------------------------------------------------------------------------
if(${QT_VERSION_MAJOR} GREATER_EQUAL 6)
    qt_add_executable(${CMAKE_PROJECT_NAME}
        MANUAL_FINALIZATION
        ${PROJECT_SOURCES}
        ${logo_resource}
    )
else()
    if(ANDROID)
        add_library(${CMAKE_PROJECT_NAME} SHARED
            ${PROJECT_SOURCES}
        )
    else()
        add_executable(${CMAKE_PROJECT_NAME}
            ${PROJECT_SOURCES}
        )
    endif()
endif()

# Add protobuf generated files if they exist
set(PROTO_GEN_DIR "${CMAKE_CURRENT_SOURCE_DIR}/3rd/rag-core/src")
if(EXISTS "${PROTO_GEN_DIR}/api.grpc.pb.cc" AND EXISTS "${PROTO_GEN_DIR}/api.pb.cc")
    target_sources(${CMAKE_PROJECT_NAME} PRIVATE
        "${PROTO_GEN_DIR}/api.grpc.pb.cc"
        "${PROTO_GEN_DIR}/api.pb.cc"
    )
    target_include_directories(${CMAKE_PROJECT_NAME} PRIVATE "${PROTO_GEN_DIR}")
endif()

# Link libraries
target_link_libraries(${CMAKE_PROJECT_NAME} PRIVATE 
    Qt${QT_VERSION_MAJOR}::Core
    Qt${QT_VERSION_MAJOR}::Gui
    Qt${QT_VERSION_MAJOR}::Widgets
    Qt${QT_VERSION_MAJOR}::Network
    Qt${QT_VERSION_MAJOR}::Multimedia
    
    ${hj_LIBRARIES}
)

# Compile definitions
target_compile_definitions(${CMAKE_PROJECT_NAME} PRIVATE
    RAG_QT_VERSION="${RAG_QT_VERSION}"
)

# Include directories
target_include_directories(${CMAKE_PROJECT_NAME} PRIVATE
    ${PROJECT_INCLUDE_DIRS}
    ${Qt_PRIVATE_INCLUDES}
    ${hj_INCLUDE_DIRS}
    ${CMAKE_CURRENT_SOURCE_DIR}/3rd/rag-core
    ${CMAKE_CURRENT_SOURCE_DIR}/3rd/libqt
    ${CMAKE_CURRENT_SOURCE_DIR}/3rd/high-jump
)

# Set target properties
set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES
    MACOSX_BUNDLE_GUI_IDENTIFIER com.example.rag-qt
    MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION}
    MACOSX_BUNDLE_SHORT_VERSION_STRING ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}
    MACOSX_BUNDLE TRUE
    WIN32_EXECUTABLE TRUE
)

if(APPLE)
    set_target_properties(${CMAKE_PROJECT_NAME} PROPERTIES
        MACOSX_BUNDLE_INFO_PLIST ${CMAKE_CURRENT_SOURCE_DIR}/res/Info.plist.in
    )

    # icon file
    add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy_if_different
            "${CMAKE_CURRENT_SOURCE_DIR}/res/icons/logo.icns"
            "${APP_RESOURCES_PATH}/logo.icns"
        COMMENT "Copying logo.icns to app bundle Resources"
    )
endif()

add_dependencies(${CMAKE_PROJECT_NAME} release_translations)

# ----------------------------------------------------------------------------
# Install
# ----------------------------------------------------------------------------
install(TARGETS ${CMAKE_PROJECT_NAME}
    RUNTIME DESTINATION bin
    LIBRARY DESTINATION lib
    BUNDLE DESTINATION .
    COMPONENT Applications
)

# ----------------------------------------------------------------------------
# Copy Config Files
# ----------------------------------------------------------------------------
file(GLOB RAG_QT_CONFIG_FILES CONFIGURE_DEPENDS
    "${CONFIG_FILES_PATH}/*.json"
)

if(RAG_QT_CONFIG_FILES)
    add_custom_target(copy_config_files ALL
        COMMAND ${CMAKE_COMMAND} -E make_directory "${CONFIG_OUTPUT_DIRECTORY}"
        COMMAND ${CMAKE_COMMAND} -E copy_if_different
            ${RAG_QT_CONFIG_FILES}
            "${CONFIG_OUTPUT_DIRECTORY}"
        DEPENDS ${RAG_QT_CONFIG_FILES}
        COMMENT "Copying config files to ${CONFIG_OUTPUT_DIRECTORY}"
    )
    add_dependencies(${CMAKE_PROJECT_NAME} copy_config_files)
else()
    message(STATUS "No config files to copy")
endif()

# ----------------------------------------------------------------------------
# Copy Resource Files (translations, etc.)
# ----------------------------------------------------------------------------
add_custom_target(copy_resources ALL
    COMMAND ${CMAKE_COMMAND} -E make_directory "${RESOURCE_OUTPUT_DIRECTORY}/languages"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
        ${QM_FILES}
        "${RESOURCE_OUTPUT_DIRECTORY}/languages"
    DEPENDS ${QM_FILES}
    COMMENT "Copying resource files to ${RESOURCE_OUTPUT_DIRECTORY}/languages"
)
add_dependencies(${CMAKE_PROJECT_NAME} copy_resources)

# ----------------------------------------------------------------------------
# Deploy Qt and Dependencies
# ----------------------------------------------------------------------------
include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/deploy.cmake)

if(CMAKE_BUILD_TYPE STREQUAL "Release" AND NOT ANDROID)
    if(WIN32)
        find_program(WINDEPLOYQT_EXECUTABLE 
            NAMES windeployqt6 windeployqt-qt6 windeployqt
            HINTS ${QT_BIN_DIR}
            PATHS "${QT_BIN_DIR}"
        )
        
        if(WINDEPLOYQT_EXECUTABLE)
            execute_process(
                COMMAND "${WINDEPLOYQT_EXECUTABLE}" --help
                OUTPUT_VARIABLE WINDEPLOYQT_HELP
                ERROR_QUIET
            )
            
            set(WINDEPLOYQT_ARGS --no-compiler-runtime --no-system-d3d-compiler --verbose 0)
            
            if(WINDEPLOYQT_HELP MATCHES "--no-angle")
                list(APPEND WINDEPLOYQT_ARGS --no-angle)
            endif()
            
            if(WINDEPLOYQT_HELP MATCHES "--no-opengl-sw")
                list(APPEND WINDEPLOYQT_ARGS --no-opengl-sw)
            endif()
            
            set(WIN_DEPLOY_DIR "${EXECUTABLE_OUTPUT_PATH}")
            
            add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
                COMMAND "${CMAKE_COMMAND}" -E make_directory "${WIN_DEPLOY_DIR}"
                COMMAND "${WINDEPLOYQT_EXECUTABLE}"
                    ${WINDEPLOYQT_ARGS}
                    "$<TARGET_FILE:${CMAKE_PROJECT_NAME}>"
                COMMENT "Deploying Qt libraries to ${WIN_DEPLOY_DIR}"
                WORKING_DIRECTORY "${WIN_DEPLOY_DIR}"
            )
            
            if(COMMAND win_deploy)
                win_deploy(${CMAKE_PROJECT_NAME} ${hj_LIBRARIES})
            endif()
        endif()
        
    elseif(APPLE)
        find_program(MACDEPLOYQT_EXECUTABLE macdeployqt)
        if(MACDEPLOYQT_EXECUTABLE)
            add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
                COMMAND "${MACDEPLOYQT_EXECUTABLE}"
                    "${APP_BUNDLE_PATH}"
                    -always-overwrite
                    -verbose=0
                    -executable="${APP_MACOS_PATH}/${CMAKE_PROJECT_NAME}"
                COMMENT "Deploying Qt frameworks to ${APP_BUNDLE_PATH}"
                WORKING_DIRECTORY "${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}"
            )

            mac_deploy(${CMAKE_PROJECT_NAME} ${hj_LIBRARIES})

            # signup
            add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
                COMMAND codesign --force --deep --sign - "${APP_MACOS_PATH}/../.."
                COMMENT "Fixing Apple Silicon code signature"
            )
        endif()
        
    elseif(LINUX)
        find_program(LINUXDEPLOYQT_EXECUTABLE linuxdeployqt)
        if(LINUXDEPLOYQT_EXECUTABLE AND EXISTS "${EXECUTABLE_OUTPUT_PATH}/${CMAKE_PROJECT_NAME}")
            add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
                COMMAND "${LINUXDEPLOYQT_EXECUTABLE}"
                    "${EXECUTABLE_OUTPUT_PATH}/${CMAKE_PROJECT_NAME}"
                    -bundle-non-qt-libs
                    -verbose=0
                COMMENT "Deploying Qt libraries using linuxdeployqt"
                WORKING_DIRECTORY "${EXECUTABLE_OUTPUT_PATH}"
            )
        endif()
        
        if(COMMAND linux_deploy)
            linux_deploy(${CMAKE_PROJECT_NAME} ${hj_LIBRARIES})
        endif()
    endif()
endif()

if(QT_VERSION_MAJOR EQUAL 6)
    qt_finalize_executable(${CMAKE_PROJECT_NAME})
endif()

# ============================================================================
# CPack Configuration - Cross-Platform Packaging
# ============================================================================
set(CPACK_PACKAGE_NAME "${CMAKE_PROJECT_NAME}")
set(CPACK_PACKAGE_VENDOR "hehehunanchina@live.com")
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "RAG-Qt Application")
set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
set(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
set(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
set(CPACK_PACKAGE_INSTALL_DIRECTORY "${CMAKE_PROJECT_NAME}")
set(CPACK_PACKAGE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/bin/packages")
set(CPACK_VERBATIM_VARIABLES YES)

if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
    set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
endif()

if(APPLE)
    set(CPACK_GENERATOR "DragNDrop")
    
    set(CPACK_MONOLITHIC_INSTALL OFF)
    set(CPACK_COMPONENTS_ALL Applications)

    set(CPACK_DMG_SKIP_RPATH OFF) 

    set(CPACK_DMG_VOLUME_NAME "${CMAKE_PROJECT_NAME} ${PROJECT_VERSION}")
    set(CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}-${PROJECT_VERSION}-macOS")
    set(CPACK_BUNDLE_NAME "${CMAKE_PROJECT_NAME}")
    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/res/icons/logo.icns")
        set(CPACK_BUNDLE_ICON "${CMAKE_CURRENT_SOURCE_DIR}/res/icons/logo.icns")
    endif()

    set(CPACK_DMG_DS_STORE_SETTINGS "")

elseif(WIN32)
    set(CPACK_GENERATOR "NSIS")
    
    set(CPACK_MONOLITHIC_INSTALL OFF) 
    if(BUILD_RELEASE_LITE)
        set(ABS_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/bin/Release-Lite")
        set(CPACK_NSIS_INSTALL_ROOT "C:") 
        set(CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}-lite-${PROJECT_VERSION}-setup")
    else()
        set(ABS_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/bin/Release")
        set(CPACK_NSIS_INSTALL_ROOT "$PROGRAMFILES64")
        set(CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}-${PROJECT_VERSION}-setup")
    endif()
    
    set(CPACK_PACKAGE_INSTALL_DIRECTORY "${CMAKE_PROJECT_NAME}")
    set(CPACK_COMPONENTS_ALL Applications)
    set(CPACK_INSTALL_CMAKE_PROJECTS "${CMAKE_BINARY_DIR};${CMAKE_PROJECT_NAME};ALL;/")
    install(DIRECTORY "${ABS_SOURCE_DIR}/" 
            DESTINATION "."
            COMPONENT Applications
    )

    set(CPACK_NSIS_DISPLAY_NAME "${CMAKE_PROJECT_NAME}")
    set(CPACK_NSIS_PACKAGE_NAME "${CMAKE_PROJECT_NAME}")
    set(CPACK_NSIS_MODIFY_PATH OFF)
    set(CPACK_NSIS_COMPRESSOR "/SOLID lzma")
    
    if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/res/icons/logo.ico")
        set(CPACK_NSIS_MUI_ICON "${CMAKE_CURRENT_SOURCE_DIR}/res/icons/logo.ico")
        set(CPACK_NSIS_MUI_UNIICON "${CMAKE_CURRENT_SOURCE_DIR}/res/icons/logo.ico")
    endif()

    set(CPACK_NSIS_CREATE_ICONS 
        "CreateShortCut '$DESKTOP\\\\${CMAKE_PROJECT_NAME}.lnk' '$INSTDIR\\\\${CMAKE_PROJECT_NAME}.exe'"
        "CreateShortCut '$SMPROGRAMS\\\\${CMAKE_PROJECT_NAME}\\\\${CMAKE_PROJECT_NAME}.lnk' '$INSTDIR\\\\${CMAKE_PROJECT_NAME}.exe'"
        "CreateShortCut '$SMPROGRAMS\\\\${CMAKE_PROJECT_NAME}\\\\Uninstall ${CMAKE_PROJECT_NAME}.lnk' '$INSTDIR\\\\Uninstall.exe'"
    )
    set(CPACK_NSIS_DELETE_ICONS 
        "Delete '$DESKTOP\\\\${CMAKE_PROJECT_NAME}.lnk'"
        "Delete '$SMPROGRAMS\\\\${CMAKE_PROJECT_NAME}\\\\${CMAKE_PROJECT_NAME}.lnk'"
        "Delete '$SMPROGRAMS\\\\${CMAKE_PROJECT_NAME}\\\\Uninstall ${CMAKE_PROJECT_NAME}.lnk'"
    )

    set(CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS "
        Delete '$DESKTOP\\\\${CMAKE_PROJECT_NAME}.lnk'
        Delete '$SMPROGRAMS\\\\${CMAKE_PROJECT_NAME}\\\\${CMAKE_PROJECT_NAME}.lnk'
        Delete '$SMPROGRAMS\\\\${CMAKE_PROJECT_NAME}\\\\Uninstall ${CMAKE_PROJECT_NAME}.lnk'
        RMDir '$SMPROGRAMS\\\\${CMAKE_PROJECT_NAME}'
        Delete '$INSTDIR\\\\Uninstall.exe'
        
        FindFirst $0 $1 '$INSTDIR\\\\*'
        loop:
            StrCmp $1 '' done
            StrCmp $1 '.' next
            StrCmp $1 '..' next
            StrCmp $1 'configs' next
            StrCmp $1 'log' next
            StrCmp $1 'crash' next
            StrCmp $1 'models' next
            
            IfFileExists '$INSTDIR\\\\$1\\\\*.*' 0 is_file
                RMDir /r '$INSTDIR\\\\$1'
                Goto next
            is_file:
                Delete '$INSTDIR\\\\$1'
        next:
            FindNext $0 $1
            Goto loop
        done:
            FindClose $0
            
        RMDir '$INSTDIR'
        
        MessageBox MB_ICONINFORMATION|MB_OK '${CMAKE_PROJECT_NAME} was successfully removed. (User data, configs, models and log directories preserved)'

        Quit
    ")

    set(CPACK_NSIS_LANGUAGE "SimpChinese" "English")

elseif(UNIX)
    set(CPACK_GENERATOR "DEB;TGZ")
    set(CPACK_DEBIAN_PACKAGE_NAME "${CMAKE_PROJECT_NAME}")
    set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "amd64")
    set(CPACK_DEBIAN_PACKAGE_MAINTAINER "hehehunanchina@live.com")
    set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "RAG Qt Application")
    set(CPACK_DEBIAN_PACKAGE_SECTION "utils")
    set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
    set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6, libstdc++6, qt6-base, qt6-gui, qt6-widgets")
    set(CPACK_PACKAGE_EXECUTABLES "${CMAKE_PROJECT_NAME}" "${CMAKE_PROJECT_NAME}")
endif()

include(CPack)

# ----------------------------------------------------------------------------
# Print Build Information
# ----------------------------------------------------------------------------
message(STATUS "")
message(STATUS "==================== Build Configuration ====================")
message(STATUS "Platform:              ${CMAKE_SYSTEM_NAME}")
message(STATUS "Build type:            ${OUTPUT_BASE_NAME}")
message(STATUS "C++ Standard:          ${CMAKE_CXX_STANDARD}")
message(STATUS "Qt Version:            ${QT_VERSION_MAJOR}")
message(STATUS "Output directory:      ${OUTPUT_DIR_BASE}/${OUTPUT_BASE_NAME}")
if(APPLE)
    message(STATUS "App bundle:            ${APP_BUNDLE_PATH}")
    message(STATUS "  MacOS:               ${APP_MACOS_PATH}")
    message(STATUS "  Resources:           ${APP_RESOURCES_PATH}")
    message(STATUS "  PlugIns:             ${APP_PLUGINS_PATH}")
else()
    message(STATUS "Plugins:               ${PLUGIN_OUTPUT_DIRECTORY}")
    message(STATUS "Resources:             ${RESOURCE_OUTPUT_DIRECTORY}")
    message(STATUS "Configs:               ${CONFIG_OUTPUT_DIRECTORY}")
endif()
message(STATUS "=============================================================")
message(STATUS "")