cmake_minimum_required(VERSION 3.22)
project(lektra VERSION 0.7.5 LANGUAGES C CXX)

include(GNUInstallDirs)

option(WITH_SYNCTEX "Enable synctex support" ON)
option(WITH_LUA     "Enable lua scripting support" OFF)


# ---------------------------------------------------------------------------
# Build type default
# ---------------------------------------------------------------------------
if(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type")
endif()

message(STATUS "Build type:          ${CMAKE_BUILD_TYPE}")
message(STATUS "Installation prefix: ${CMAKE_INSTALL_PREFIX}")

# ---------------------------------------------------------------------------
# Compiler / language settings
# ---------------------------------------------------------------------------
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_COLOR_DIAGNOSTICS ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

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

if(MSVC)
    add_compile_options(/Zc:__cplusplus /Zc:preprocessor)
    set(DEBUG_FLAGS          /Od;/Zi;/RTC1;/W4;/fsanitize=address)
    set(RELEASE_FLAGS        /O2;/DNDEBUG;/GR-;/W4)
    set(REL_WITH_DEB_INFO_FLAGS /O2;/Zi;/DNDEBUG;/W4)
else()
    set(DEBUG_FLAGS          -fno-omit-frame-pointer;-ggdb3;-O0;-fsanitize=address;-Wall;-Wextra)
    set(RELEASE_FLAGS        -O3;-DNDEBUG;-fno-rtti)
    set(REL_WITH_DEB_INFO_FLAGS -O2;-g;-fno-omit-frame-pointer;-DNDEBUG)
endif()

# ---------------------------------------------------------------------------
# Platform helpers  (CMake does not define LINUX; derive it)
# ---------------------------------------------------------------------------
if(UNIX AND NOT APPLE)
    set(PLATFORM_LINUX TRUE)
endif()

# ---------------------------------------------------------------------------
# Compile-time definitions
# ---------------------------------------------------------------------------
add_compile_definitions(
    APP_BUILD_TYPE="${CMAKE_BUILD_TYPE}"
    APP_INSTALL_PREFIX="${CMAKE_INSTALL_PREFIX}"
    APP_VERSION="${PROJECT_VERSION}"
    APP_NAME="${PROJECT_NAME}"
    APP_VERSION_MAJOR="${PROJECT_VERSION_MAJOR}"
    APP_VERSION_MINOR="${PROJECT_VERSION_MINOR}"
    APP_VERSION_PATCH="${PROJECT_VERSION_PATCH}"
)

# ---------------------------------------------------------------------------
# MuPDF (ExternalProject)
# ---------------------------------------------------------------------------
include(ExternalProject)
set(MUPDF_INSTALL_DIR "${CMAKE_BINARY_DIR}/mupdf-install")
set(MUPDF_SOURCE_DIR  "${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/mupdf")

# Detect MuPDF version from source header
set(MUPDF_VERSION_HEADER "${MUPDF_SOURCE_DIR}/include/mupdf/fitz/version.h")
if(EXISTS "${MUPDF_VERSION_HEADER}")
    file(READ "${MUPDF_VERSION_HEADER}" _mupdf_ver_contents)
    string(REGEX MATCH "#define FZ_VERSION \"([^\"]+)\"" _ "${_mupdf_ver_contents}")
    if(CMAKE_MATCH_1)
        set(MUPDF_VERSION "${CMAKE_MATCH_1}")
        message(STATUS "MuPDF version: ${MUPDF_VERSION}")
    else()
        message(FATAL_ERROR
            "Could not parse MuPDF version from ${MUPDF_VERSION_HEADER}. "
            "Ensure the mupdf submodule is initialised (git submodule update --init).")
    endif()
    set(MUPDF_FOUND TRUE)
    set(MUPDF_INCLUDE_DIRS "${MUPDF_SOURCE_DIR}/include")
else()
    message(FATAL_ERROR
        "MuPDF source not found at ${MUPDF_SOURCE_DIR}. "
        "Initialise the submodule: git submodule update --init thirdparty/mupdf")
endif()


if(MSVC)
    set(MUPDF_SLN "${MUPDF_SOURCE_DIR}/platform/win32/mupdf.sln")
    set(MUPDF_LIB_FILE "${MUPDF_INSTALL_DIR}/lib/libmupdf.lib")

    ExternalProject_Add(mupdf_external
        SOURCE_DIR "${MUPDF_SOURCE_DIR}"
        CONFIGURE_COMMAND ""

        BUILD_COMMAND
        MSBuild "${MUPDF_SLN}"
        /p:Configuration=$<CONFIG>
        /p:Platform=x64
        /m

        INSTALL_COMMAND
        ${CMAKE_COMMAND} -E make_directory "${MUPDF_INSTALL_DIR}/lib"
        COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${MUPDF_SOURCE_DIR}/platform/win32/x64/Release/libmupdf.lib"
        MUPDF_LIB_FILE

        BUILD_BYPRODUCTS "${MUPDF_LIB_FILE}"
        UPDATE_COMMAND ""
    )
else()
    set(MUPDF_LIB_FILE "${MUPDF_INSTALL_DIR}/lib/libmupdf.a")
    set(MUPDF_LIB_THIRD_FILE "${MUPDF_INSTALL_DIR}/lib/libmupdf-third.a")

    ExternalProject_Add(mupdf_external
        SOURCE_DIR "${MUPDF_SOURCE_DIR}"
        CONFIGURE_COMMAND ""
        BUILD_COMMAND
        make -C <SOURCE_DIR> build=release shared=no
        HAVE_TESSERACT=no HAVE_CURL=no HAVE_X11=no HAVE_GLUT=no HAVE_LIBCRYPTO=no USE_SYSTEM_LIBS=no
        LIB_CFLAGS=-fPIC libs
        INSTALL_COMMAND
        make -C <SOURCE_DIR> build=release shared=no
        HAVE_TESSERACT=no HAVE_CURL=no HAVE_X11=no HAVE_GLUT=no HAVE_LIBCRYPTO=no USE_SYSTEM_LIBS=no
        prefix="${MUPDF_INSTALL_DIR}" install-libs
        BUILD_BYPRODUCTS "${MUPDF_LIB_FILE}" "${MUPDF_LIB_THIRD_FILE}"
        UPDATE_COMMAND ""
    )
endif()

# ---------------------------------------------------------------------------
# Qt6 + optional system libraries
# ---------------------------------------------------------------------------
find_package(Qt6 REQUIRED COMPONENTS
    Core Gui Widgets Concurrent LinguistTools OpenGLWidgets Network Svg)


if (WITH_LUA)
    find_package(Lua QUIET)
    if (Lua_FOUND)
        message(STATUS "Lua support: enabled (Lua version: ${Lua_VERSION})")
    else()
        message(WARNING "Lua not found – Lua scripting support disabled")
        set(WITH_LUA OFF)
    endif()
endif()

message(STATUS "librsvg support: runtime probe (uses librsvg-2.so.2 + libcairo.so.2 if installed)")


# ---------------------------------------------------------------------------
# Source files
# ---------------------------------------------------------------------------
file(GLOB LEKTRA_CORE_HEADERS       CONFIGURE_DEPENDS include/*.hpp)
file(GLOB LEKTRA_ANNOTATION_HEADERS CONFIGURE_DEPENDS include/Annotations/*.hpp)
file(GLOB LEKTRA_COMMAND_HEADERS    CONFIGURE_DEPENDS include/Commands/*.hpp)

if (WITH_LUA)
    file(GLOB LEKTRA_LUA_HEADERS        CONFIGURE_DEPENDS include/lua/*.hpp)
endif()

set(app_icon_resource_windows "")
if(WIN32)
    set(app_icon_resource_windows "${CMAKE_CURRENT_SOURCE_DIR}/resources/lektra.rc")
endif()

add_executable(${PROJECT_NAME}
    ${app_icon_resource_windows}
    src/main.cpp
    src/Lektra.cpp
    src/Statusbar.cpp
    src/Model.cpp
    src/PropertiesWidget.cpp
    src/AboutDialog.cpp
    src/GraphicsView.cpp
    src/GraphicsScene.cpp
    src/DocumentView.cpp
    src/StartupWidget.cpp
    src/MessageBar.cpp
    src/Annotation.cpp
    src/EditLastPagesWidget.cpp
    src/RecentFilesStore.cpp
    src/RecentFilesModel.cpp
    src/SearchBar.cpp
    src/SaveSessionDialog.cpp
    src/FloatingOverlayWidget.cpp
    src/HighlightSearchPicker.cpp
    src/utils.cpp
    src/WaitingSpinnerWidget.cpp
    src/CommandPicker.cpp
    src/TabWidget.cpp
    src/DocumentContainer.cpp
    src/ThumbnailView.cpp
    src/TabBar.cpp
    src/Picker.cpp
    src/RecentFilesPicker.cpp
    src/FilePicker.cpp
    src/OutlinePicker.cpp
    src/CommentSearchPicker.cpp
    src/ScrollBar.cpp
    src/ColorDialog.cpp
    src/Bookmark.cpp
    src/BookmarkManager.cpp
    src/BookmarkPicker.cpp

    ${LEKTRA_CORE_HEADERS}
    ${LEKTRA_ANNOTATION_HEADERS}
    ${LEKTRA_COMMAND_HEADERS}
)

if (WITH_LUA)
    # Glob for lua source files in the src/lua directory
    file(GLOB LEKTRA_LUA_SOURCES CONFIGURE_DEPENDS src/lua/*.cpp)
    target_sources(${PROJECT_NAME} PRIVATE
        ${LEKTRA_LUA_SOURCES}
        ${LEKTRA_LUA_HEADERS}
    )
    target_include_directories(${PROJECT_NAME} PRIVATE include/lua)
endif()

target_include_directories(${PROJECT_NAME} PRIVATE
    include
    ${CMAKE_CURRENT_BINARY_DIR}/include   # generated headers (TranslationsDir.hpp etc.)
    ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty
)

# ---------------------------------------------------------------------------
# ---------------------------------------------------------------------------
# Windows executable properties
# ---------------------------------------------------------------------------
if(WIN32)
    set_target_properties(${PROJECT_NAME} PROPERTIES
        WIN32_EXECUTABLE TRUE   # use Windows subsystem (no console window)
    )
    # Qt6::EntryPoint provides the WinMain -> main shim required by the
    # Windows subsystem. Without it the linker can't find `main`.
endif()

# ---------------------------------------------------------------------------
# macOS bundle properties
# ---------------------------------------------------------------------------
if(APPLE)
    set(LEKTRA_BUNDLE_NAME "Lektra")
    set(LEKTRA_BUNDLE_IDENTIFIER "org.lektra.lektra")
    set(LEKTRA_BUNDLE_ICON_FILE "lektra.icns")
    set(LEKTRA_BUNDLE_INFO_STRING "${PROJECT_NAME} ${PROJECT_VERSION}")
    set(LEKTRA_BUNDLE_COPYRIGHT "Copyright 2026 Lektra contributors")
    set(LEKTRA_BUNDLE_INFO_PLIST "${CMAKE_CURRENT_BINARY_DIR}/Info.plist")

    set(MACOSX_BUNDLE_EXECUTABLE_NAME "${PROJECT_NAME}")
    set(MACOSX_BUNDLE_BUNDLE_NAME "${LEKTRA_BUNDLE_NAME}")
    set(MACOSX_BUNDLE_BUNDLE_VERSION "${PROJECT_VERSION}")
    set(MACOSX_BUNDLE_COPYRIGHT "${LEKTRA_BUNDLE_COPYRIGHT}")
    set(MACOSX_BUNDLE_GUI_IDENTIFIER "${LEKTRA_BUNDLE_IDENTIFIER}")
    set(MACOSX_BUNDLE_ICON_FILE "${LEKTRA_BUNDLE_ICON_FILE}")
    set(MACOSX_BUNDLE_INFO_STRING "${LEKTRA_BUNDLE_INFO_STRING}")
    set(MACOSX_BUNDLE_LONG_VERSION_STRING "${LEKTRA_BUNDLE_INFO_STRING}")
    set(MACOSX_BUNDLE_SHORT_VERSION_STRING "${PROJECT_VERSION}")
    configure_file(
        "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Info.plist.in"
        "${LEKTRA_BUNDLE_INFO_PLIST}"
    )

    set_target_properties(${PROJECT_NAME} PROPERTIES
        MACOSX_BUNDLE                    TRUE
        MACOSX_BUNDLE_BUNDLE_NAME        "${LEKTRA_BUNDLE_NAME}"
        MACOSX_BUNDLE_BUNDLE_VERSION     "${PROJECT_VERSION}"
        MACOSX_BUNDLE_COPYRIGHT          "${LEKTRA_BUNDLE_COPYRIGHT}"
        MACOSX_BUNDLE_GUI_IDENTIFIER     "${LEKTRA_BUNDLE_IDENTIFIER}"
        MACOSX_BUNDLE_ICON_FILE          "${LEKTRA_BUNDLE_ICON_FILE}"
        MACOSX_BUNDLE_INFO_PLIST         "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Info.plist.in"
        MACOSX_BUNDLE_INFO_STRING        "${LEKTRA_BUNDLE_INFO_STRING}"
        MACOSX_BUNDLE_LONG_VERSION_STRING "${LEKTRA_BUNDLE_INFO_STRING}"
        MACOSX_BUNDLE_SHORT_VERSION_STRING "${PROJECT_VERSION}"
    )

    add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E make_directory
        "$<TARGET_BUNDLE_DIR:${PROJECT_NAME}>/Contents"
        COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${LEKTRA_BUNDLE_INFO_PLIST}"
        "$<TARGET_BUNDLE_DIR:${PROJECT_NAME}>/Contents/Info.plist"
        VERBATIM
    )
endif()

# ---------------------------------------------------------------------------
# Qt resources
# ---------------------------------------------------------------------------
qt_add_resources(RESOURCES resources.qrc)
target_sources(${PROJECT_NAME} PRIVATE ${RESOURCES})

# ---------------------------------------------------------------------------
# Link libraries
# ---------------------------------------------------------------------------

add_dependencies(${PROJECT_NAME} mupdf_external)

# --- Qt ---
target_link_libraries(${PROJECT_NAME} PRIVATE
    Qt6::Core Qt6::Gui Qt6::Widgets
    Qt6::Concurrent Qt6::OpenGLWidgets Qt6::Network Qt6::Svg
)

# Qt6Network on Arch/Qt 6.11+ has an undeclared dep on libbrotlidec.
# Link it explicitly on Linux to avoid "DSO missing from command line".
if(PLATFORM_LINUX)
    find_library(BROTLIDEC_LIB  brotlidec)
    find_library(BROTLICOMMON_LIB brotlicommon)
    if(BROTLIDEC_LIB AND BROTLICOMMON_LIB)
        target_link_libraries(${PROJECT_NAME} PRIVATE
            ${BROTLIDEC_LIB} ${BROTLICOMMON_LIB})
    endif()
endif()

# --- MuPDF ---
target_include_directories(${PROJECT_NAME} PRIVATE ${MUPDF_INCLUDE_DIRS})
target_compile_definitions(${PROJECT_NAME} PRIVATE HAS_MUPDF=1)

if(MSVC)
    target_link_libraries(${PROJECT_NAME} PRIVATE
        "${MUPDF_SOURCE_DIR}/platform/win32/x64/Release/libmupdf.lib"
    )
else()
    target_link_libraries(${PROJECT_NAME} PRIVATE
        "${MUPDF_INSTALL_DIR}/lib/libmupdf.a"
        "${MUPDF_INSTALL_DIR}/lib/libmupdf-third.a"
        z       # zlib
        m       # libm
        dl      # libdl
    )
endif()

# ----------------------------------------------------------------------------
# Synctex
# ----------------------------------------------------------------------------

if (WITH_SYNCTEX)
    # Define the source files
    set(SYNCTEX_SOURCES
        ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/synctex/synctex_parser.c
        ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/synctex/synctex_parser_utils.c
    )
    add_library(synctex STATIC ${SYNCTEX_SOURCES})

    target_include_directories(synctex
        PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/synctex)

    target_link_libraries(${PROJECT_NAME} PRIVATE synctex)
    target_compile_definitions(${PROJECT_NAME} PRIVATE WITH_SYNCTEX=1)
endif()

if (WITH_LUA AND Lua_FOUND)
    target_include_directories(${PROJECT_NAME} PRIVATE ${LUA_INCLUDE_DIR})
    target_compile_definitions(${PROJECT_NAME} PRIVATE WITH_LUA=1)
    target_link_libraries(${PROJECT_NAME} PRIVATE ${LUA_LIBRARIES})
endif()



# ---------------------------------------------------------------------------
# Per-config compile/link options
# NOTE: both use the same variable names so Debug -fsanitize=address is
# applied consistently to both compile and link steps.
# ---------------------------------------------------------------------------
target_compile_options(${PROJECT_NAME} PRIVATE
    $<$<CONFIG:Debug>:${DEBUG_FLAGS}>
    $<$<CONFIG:Release>:${RELEASE_FLAGS}>
    $<$<CONFIG:RelWithDebInfo>:${REL_WITH_DEB_INFO_FLAGS}>
)

if (MSVC)
    target_link_options(${PROJECT_NAME} PRIVATE
        $<$<CONFIG:Debug>:$<IF:$<CXX_COMPILER_ID:MSVC>,/DEBUG,--fsanitize=address>>
        # nothing needed for Release/RelWithDebInfo
    )
else()
    target_link_options(${PROJECT_NAME} PRIVATE
        $<$<CONFIG:Debug>:$<IF:$<CXX_COMPILER_ID:MSVC>,/DEBUG,-fsanitize=address>>
        # nothing needed for Release/RelWithDebInfo
    )
endif()


# ---------------------------------------------------------------------------
# Qt platform plugins
# ---------------------------------------------------------------------------
if(PLATFORM_LINUX)
    qt_import_plugins(${PROJECT_NAME}
        INCLUDE
        Qt6::QWaylandIntegrationPlugin
        Qt6::QXcbIntegrationPlugin
        Qt6::QEglFSIntegrationPlugin
    )
elseif(APPLE)
    qt_import_plugins(${PROJECT_NAME}
        INCLUDE Qt6::QCocoaIntegrationPlugin
    )
elseif(WIN32)
    qt_import_plugins(${PROJECT_NAME}
        INCLUDE Qt6::QWindowsIntegrationPlugin
    )
endif()

# ---------------------------------------------------------------------------
# Translations
# ---------------------------------------------------------------------------
set(TRANSLATION_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Translations")
file(GLOB TRANSLATION_FILES "${TRANSLATION_SRC_DIR}/*.ts")

set(TRANSLATIONS_DIR "${CMAKE_INSTALL_FULL_DATADIR}/locale")
configure_file(
    "${CMAKE_CURRENT_SOURCE_DIR}/TranslationsDir.hpp.in"
    "${CMAKE_CURRENT_BINARY_DIR}/include/TranslationsDir.hpp"
    @ONLY
)

if(Qt6LinguistTools_VERSION VERSION_GREATER_EQUAL "6.7")
    qt_add_translations(
        TARGETS ${PROJECT_NAME}
        TS_FILES ${TRANSLATION_FILES}
        QM_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/translations"
        QM_FILES_OUTPUT_VARIABLE QM_FILES
    )
else()
    foreach(ts_file ${TRANSLATION_FILES})
        set_source_files_properties(${ts_file} PROPERTIES
            OUTPUT_LOCATION "${CMAKE_CURRENT_BINARY_DIR}/translations"
        )
    endforeach()
    qt_add_translations(${PROJECT_NAME}
        TS_FILES ${TRANSLATION_FILES}
        QM_FILES_OUTPUT_VARIABLE QM_FILES
    )
endif()

if(TARGET lektra_lrelease)
    add_dependencies(${PROJECT_NAME} lektra_lrelease)
endif()

# Helper macro: extracts the language code from a .qm filename.
# e.g. lektra.es.qm -> "es",  lektra.qm -> "" (base/untranslated, skip)
macro(get_qm_lang qm_file out_lang)
    get_filename_component(_qm_name "${qm_file}" NAME)
    string(REGEX REPLACE "\\.qm$"       "" _qm_name  "${_qm_name}")
    string(REPLACE       "lektra."      "" ${out_lang} "${_qm_name}")
    if(${out_lang} STREQUAL "${_qm_name}" OR ${out_lang} STREQUAL "")
        set(${out_lang} "")
    endif()
endmacro()

# macOS: copy .qm files into the bundle
if(APPLE)
    add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E make_directory
        "$<TARGET_FILE_DIR:${PROJECT_NAME}>/../Resources"
        COMMAND ${CMAKE_COMMAND} -E copy_if_different
        "${CMAKE_CURRENT_SOURCE_DIR}/tutorial.pdf"
        "$<TARGET_FILE_DIR:${PROJECT_NAME}>/../Resources/tutorial.pdf"
        VERBATIM
    )
    foreach(qm_file ${QM_FILES})
        get_qm_lang("${qm_file}" lang)
        if(lang STREQUAL "")
            continue()
        endif()
        add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E make_directory
            "$<TARGET_FILE_DIR:${PROJECT_NAME}>/../Resources/translations"
            COMMAND ${CMAKE_COMMAND} -E copy_if_different
            "${qm_file}"
            "$<TARGET_FILE_DIR:${PROJECT_NAME}>/../Resources/translations/"
            VERBATIM
        )
    endforeach()
endif()

# Install .qm files
foreach(qm_file ${QM_FILES})
    get_qm_lang("${qm_file}" lang)
    if(lang STREQUAL "")
        continue()
    endif()
    install(
        FILES "${qm_file}"
        DESTINATION "${CMAKE_INSTALL_DATADIR}/lektra/translations"
    )
endforeach()

# ---------------------------------------------------------------------------
# Install rules
# ---------------------------------------------------------------------------
if(APPLE)
    install(TARGETS ${PROJECT_NAME} BUNDLE DESTINATION .)
else()
    install(TARGETS ${PROJECT_NAME} DESTINATION bin)
endif()

# .desktop entry (Linux / freedesktop)
configure_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/lektra-template.desktop.in
    ${CMAKE_CURRENT_BINARY_DIR}/lektra.desktop
    @ONLY
)
if(PLATFORM_LINUX)
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/lektra.desktop
        DESTINATION share/applications)
    install(DIRECTORY resources/hicolor
        DESTINATION share/icons
        FILES_MATCHING PATTERN "*.png")
endif()

# Docs
install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/tutorial.pdf
    DESTINATION share/doc/${PROJECT_NAME})

# Lua stubs (Linux and macOS only)
if(NOT WIN32)
    install(DIRECTORY stubs/lua/
        DESTINATION share/lektra/lua)
endif()

# Man pages (Unix only — not applicable on Windows)
if(NOT WIN32)
    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/docs/man/lektra.1
        DESTINATION share/man/man1)
    # install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/docs/man/lektra-config.5  DESTINATION share/man/man5)
    # install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/docs/man/lektra-commands.7 DESTINATION share/man/man7)
endif()

if(WIN32)
    # Find windeployqt executable
    find_program(WINDEPLOYQT_EXECUTABLE windeployqt
        HINTS "${Qt${QT_VERSION_MAJOR}_DIR}/../../../bin"
    )

    if(WINDEPLOYQT_EXECUTABLE)
        message(STATUS "Found windeployqt: ${WINDEPLOYQT_EXECUTABLE}")

        # Run windeployqt after build (for development/debugging)
        add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
            COMMAND ${WINDEPLOYQT_EXECUTABLE}
            --release
            --no-translations
            --compiler-runtime
            $<TARGET_FILE:${PROJECT_NAME}>
            COMMENT "Running windeployqt for development build..."
        )
    else()
        message(WARNING "windeployqt not found - Qt dependencies won't be deployed automatically")
    endif()
endif()

# Install Qt dependencies during cmake --install
if(WIN32 AND WINDEPLOYQT_EXECUTABLE)
    install(CODE "
    message(STATUS \"Deploying Qt dependencies with windeployqt...\")
    execute_process(
        COMMAND \"${WINDEPLOYQT_EXECUTABLE}\"
        --release
        --no-translations
        --compiler-runtime
        \"\${CMAKE_INSTALL_PREFIX}/bin/${PROJECT_NAME}.exe\"
        RESULT_VARIABLE WINDEPLOYQT_RESULT
    )
    if(NOT WINDEPLOYQT_RESULT EQUAL 0)
        message(WARNING \"windeployqt failed with code \${WINDEPLOYQT_RESULT}\")
    endif()
    " COMPONENT Runtime)
endif()


if (NOT WIN32)
    find_package(ZLIB REQUIRED)
    target_link_libraries(${PROJECT_NAME} PRIVATE ZLIB::ZLIB)
    target_include_directories(${PROJECT_NAME} PRIVATE ${ZLIB_INCLUDE_DIRS})
endif()
