CMakeLists.txt

cmake_minimum_required(VERSION 3.14)
project(PackageManagerModulePlugin LANGUAGES CXX)

include(GNUInstallDirs)

set(CMAKE_AUTOMOC ON)

option(LOGOS_PACKAGE_MANAGER_USE_VENDOR "Force use of vendored Logos dependencies" OFF)
option(LGPM_PORTABLE_BUILD "Build for portable variant selection (selects portable LGX variants instead of dev)" OFF)

# Allow override from environment or command line
if(NOT DEFINED LOGOS_MODULE_ROOT)
    set(_parent_module "${CMAKE_SOURCE_DIR}/../logos-module")
    set(_use_vendor ${LOGOS_PACKAGE_MANAGER_USE_VENDOR})
    if(NOT _use_vendor)
        if(NOT EXISTS "${_parent_module}/src/interface.h")
            set(_use_vendor ON)
        endif()
    endif()
    if(_use_vendor)
        set(LOGOS_MODULE_ROOT "${CMAKE_SOURCE_DIR}/vendor/logos-module")
    else()
        set(LOGOS_MODULE_ROOT "${_parent_module}")
    endif()
endif()

if(NOT DEFINED LOGOS_CPP_SDK_ROOT)
    set(_parent_cpp_sdk "${CMAKE_SOURCE_DIR}/../logos-cpp-sdk")
    set(_use_vendor ${LOGOS_PACKAGE_MANAGER_USE_VENDOR})
    if(NOT _use_vendor)
        if(NOT EXISTS "${_parent_cpp_sdk}/cpp/logos_api.h")
            set(_use_vendor ON)
        endif()
    endif()
    if(_use_vendor)
        set(LOGOS_CPP_SDK_ROOT "${CMAKE_SOURCE_DIR}/vendor/logos-cpp-sdk")
    else()
        set(LOGOS_CPP_SDK_ROOT "${_parent_cpp_sdk}")
    endif()
endif()

# Check if dependencies are available (support both source and installed layouts)
set(_logos_module_found FALSE)
if(EXISTS "${LOGOS_MODULE_ROOT}/src/interface.h")
    set(_logos_module_found TRUE)
    set(_logos_module_is_source TRUE)
elseif(EXISTS "${LOGOS_MODULE_ROOT}/include/module_lib/interface.h")
    set(_logos_module_found TRUE)
    set(_logos_module_is_source FALSE)
endif()

set(_cpp_sdk_found FALSE)
if(EXISTS "${LOGOS_CPP_SDK_ROOT}/cpp/logos_api.h")
    set(_cpp_sdk_found TRUE)
    set(_cpp_sdk_is_source TRUE)
elseif(EXISTS "${LOGOS_CPP_SDK_ROOT}/include/cpp/logos_api.h")
    set(_cpp_sdk_found TRUE)
    set(_cpp_sdk_is_source FALSE)
endif()

if(NOT _logos_module_found)
    message(FATAL_ERROR "logos-module not found at ${LOGOS_MODULE_ROOT}. "
                        "Set LOGOS_MODULE_ROOT or run git submodule update --init --recursive.")
endif()

if(NOT _cpp_sdk_found)
    message(FATAL_ERROR "logos-cpp-sdk not found at ${LOGOS_CPP_SDK_ROOT}. "
                        "Set LOGOS_CPP_SDK_ROOT or run git submodule update --init --recursive.")
endif()

# Root that contains the vendored dependencies (logos-core checkout or script vendor directory)
get_filename_component(LOGOS_DEPS_ROOT "${LOGOS_CPP_SDK_ROOT}" DIRECTORY)

# Find Qt RemoteObjects (needed for LogosAPI)
if(NOT DEFINED QT_VERSION_MAJOR)
    find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Core RemoteObjects Network)
    if(Qt6_FOUND)
        set(QT_VERSION_MAJOR 6)
    else()
        set(QT_VERSION_MAJOR 5)
    endif()
endif()
find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core RemoteObjects Network)

# Run Logos C++ generator on metadata before compilation
set(METADATA_JSON "${CMAKE_CURRENT_SOURCE_DIR}/metadata.json")
set(PLUGINS_OUTPUT_DIR "${CMAKE_BINARY_DIR}/modules")

# For iOS cross-compilation, skip the generator (it's a host tool)
# The generated files should exist from a prior macOS build or be pre-generated
if(CMAKE_SYSTEM_NAME STREQUAL "iOS")
    message(STATUS "iOS build: Skipping cpp_generator (host tool not available during cross-compilation)")
    # Create a dummy target so dependencies still work
    add_custom_target(run_cpp_generator_package_manager
        COMMAND ${CMAKE_COMMAND} -E echo "Skipping code generator for iOS build"
        COMMENT "Skipping logos-cpp-generator for iOS cross-compilation"
    )
elseif(_cpp_sdk_is_source)
    # Source layout: build the generator
    set(CPP_GENERATOR_BUILD_DIR "${LOGOS_DEPS_ROOT}/build/cpp-generator")
    set(CPP_GENERATOR "${CPP_GENERATOR_BUILD_DIR}/bin/logos-cpp-generator")
    
    if(NOT TARGET cpp_generator_build)
        add_custom_target(cpp_generator_build
            COMMAND bash "${LOGOS_CPP_SDK_ROOT}/cpp-generator/compile.sh"
            WORKING_DIRECTORY "${LOGOS_DEPS_ROOT}"
            COMMENT "Building logos-cpp-generator via ${LOGOS_CPP_SDK_ROOT}/cpp-generator/compile.sh"
            VERBATIM
        )
    endif()
    
    add_custom_target(run_cpp_generator_package_manager
        COMMAND "${CPP_GENERATOR}" --metadata "${METADATA_JSON}" --module-dir "${PLUGINS_OUTPUT_DIR}"
        WORKING_DIRECTORY "${LOGOS_DEPS_ROOT}"
        COMMENT "Running logos-cpp-generator on ${METADATA_JSON} with module-dir ${PLUGINS_OUTPUT_DIR}"
        VERBATIM
    )
    add_dependencies(run_cpp_generator_package_manager cpp_generator_build)
else()
    # Installed layout: use the generator from the install path
    find_program(CPP_GENERATOR logos-cpp-generator PATHS ${LOGOS_CPP_SDK_ROOT}/bin NO_DEFAULT_PATH REQUIRED)
    
    add_custom_target(run_cpp_generator_package_manager
        COMMAND "${CPP_GENERATOR}" --metadata "${METADATA_JSON}" --module-dir "${PLUGINS_OUTPUT_DIR}"
        WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
        COMMENT "Running logos-cpp-generator on ${METADATA_JSON} with module-dir ${PLUGINS_OUTPUT_DIR}"
        VERBATIM
    )
endif()

# Plugin sources
set(PLUGIN_SOURCES
    src/package_manager_plugin.cpp
    src/package_manager_plugin.h
    src/package_manager_interface.h
    src/lib/package_manager_lib.cpp
    src/lib/package_manager_lib.h
)

# Add logos-module interface header
if(_logos_module_is_source)
    list(APPEND PLUGIN_SOURCES ${LOGOS_MODULE_ROOT}/src/interface.h)
else()
    list(APPEND PLUGIN_SOURCES ${LOGOS_MODULE_ROOT}/include/module_lib/interface.h)
endif()

# Add SDK sources (only if source layout, installed layout uses the library)
if(_cpp_sdk_is_source)
    list(APPEND PLUGIN_SOURCES
        ${LOGOS_CPP_SDK_ROOT}/cpp/logos_api.cpp
        ${LOGOS_CPP_SDK_ROOT}/cpp/logos_api.h
        ${LOGOS_CPP_SDK_ROOT}/cpp/logos_api_client.cpp
        ${LOGOS_CPP_SDK_ROOT}/cpp/logos_api_client.h
        ${LOGOS_CPP_SDK_ROOT}/cpp/logos_api_consumer.cpp
        ${LOGOS_CPP_SDK_ROOT}/cpp/logos_api_consumer.h
        ${LOGOS_CPP_SDK_ROOT}/cpp/logos_api_provider.cpp
        ${LOGOS_CPP_SDK_ROOT}/cpp/logos_api_provider.h
        ${LOGOS_CPP_SDK_ROOT}/cpp/token_manager.cpp
        ${LOGOS_CPP_SDK_ROOT}/cpp/token_manager.h
        ${LOGOS_CPP_SDK_ROOT}/cpp/module_proxy.cpp
        ${LOGOS_CPP_SDK_ROOT}/cpp/module_proxy.h
    )
endif()

# Create the plugin library
# Build as static for iOS (dynamic libraries not supported in iOS apps), shared otherwise
if(CMAKE_SYSTEM_NAME STREQUAL "iOS")
    add_library(package_manager_plugin STATIC ${PLUGIN_SOURCES})
    # Enable Qt static plugin registration so Q_IMPORT_PLUGIN works
    target_compile_definitions(package_manager_plugin PRIVATE QT_STATICPLUGIN)
else()
    add_library(package_manager_plugin SHARED ${PLUGIN_SOURCES})
endif()

# Propagate portable build flag to plugin library
if(LGPM_PORTABLE_BUILD)
    target_compile_definitions(package_manager_plugin PRIVATE LGPM_PORTABLE_BUILD=1)
endif()

# Set output name without lib prefix
set_target_properties(package_manager_plugin PROPERTIES
    PREFIX "")

# Ensure generator runs before building the plugin
add_dependencies(package_manager_plugin run_cpp_generator_package_manager)

# Link Qt libraries
target_link_libraries(package_manager_plugin PRIVATE 
    Qt${QT_VERSION_MAJOR}::Core 
    Qt${QT_VERSION_MAJOR}::RemoteObjects
    Qt${QT_VERSION_MAJOR}::Network)

# Link SDK library if using installed layout
if(NOT _cpp_sdk_is_source)
    find_library(LOGOS_SDK_LIB logos_sdk PATHS ${LOGOS_CPP_SDK_ROOT}/lib NO_DEFAULT_PATH REQUIRED)
    target_link_libraries(package_manager_plugin PRIVATE ${LOGOS_SDK_LIB})
endif()

# Add lgx library
message(STATUS "Using lgx library at: ${LGX_ROOT}")
target_include_directories(package_manager_plugin PRIVATE ${LGX_ROOT}/include)
find_library(LGX_LIB lgx PATHS ${LGX_ROOT}/lib NO_DEFAULT_PATH REQUIRED)
message(STATUS "Found lgx library: ${LGX_LIB}")
target_link_libraries(package_manager_plugin PRIVATE ${LGX_LIB})

# Include directories
target_include_directories(package_manager_plugin PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}
    ${CMAKE_CURRENT_SOURCE_DIR}/src
    ${CMAKE_CURRENT_SOURCE_DIR}/src/lib
)

# Add include directories based on layout type
if(_logos_module_is_source)
    target_include_directories(package_manager_plugin PRIVATE ${LOGOS_MODULE_ROOT}/src)
else()
    target_include_directories(package_manager_plugin PRIVATE ${LOGOS_MODULE_ROOT}/include/module_lib)
endif()

if(_cpp_sdk_is_source)
    target_include_directories(package_manager_plugin PRIVATE 
        ${LOGOS_CPP_SDK_ROOT}/cpp
        ${LOGOS_CPP_SDK_ROOT}/cpp/generated
    )
else()
    target_include_directories(package_manager_plugin PRIVATE 
        ${LOGOS_CPP_SDK_ROOT}/include
        ${LOGOS_CPP_SDK_ROOT}/include/cpp
        ${LOGOS_CPP_SDK_ROOT}/include/core
    )
endif()

# Set common properties for both platforms
set_target_properties(package_manager_plugin PROPERTIES
    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/modules"
    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/modules"  # For static libraries
    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/modules"  # For Windows .dll
    BUILD_WITH_INSTALL_RPATH TRUE
    SKIP_BUILD_RPATH FALSE)

# Skip RPATH settings for iOS (not applicable for static libraries)
if(NOT CMAKE_SYSTEM_NAME STREQUAL "iOS")
    if(APPLE)
        # macOS specific settings
        set_target_properties(package_manager_plugin PROPERTIES
            INSTALL_RPATH "@loader_path;${LGX_ROOT}/lib"
            INSTALL_NAME_DIR "@rpath"
            BUILD_WITH_INSTALL_NAME_DIR TRUE)
        
        add_custom_command(TARGET package_manager_plugin POST_BUILD
            COMMAND install_name_tool -id "@rpath/package_manager_plugin.dylib" $<TARGET_FILE:package_manager_plugin>
            COMMAND install_name_tool -change "${LGX_LIB}" "@rpath/liblgx.dylib" $<TARGET_FILE:package_manager_plugin>
            COMMENT "Updating library paths for macOS"
        )
    else()
        # Linux specific settings
        set_target_properties(package_manager_plugin PROPERTIES
            INSTALL_RPATH "$ORIGIN:${LGX_ROOT}/lib"
            INSTALL_RPATH_USE_LINK_PATH FALSE)
    endif()
endif()

# Add CLI subdirectory (skip for iOS)
if(NOT CMAKE_SYSTEM_NAME STREQUAL "iOS")
    add_subdirectory(cmd)
endif()

# Install rules - use lib directory for iOS static libraries
if(CMAKE_SYSTEM_NAME STREQUAL "iOS")
    install(TARGETS package_manager_plugin
        ARCHIVE DESTINATION lib
    )
else()
    install(TARGETS package_manager_plugin
        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/logos/modules
        RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}/logos/modules
        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}/logos/modules
    )
endif()

install(FILES ${METADATA_JSON}
    DESTINATION ${CMAKE_INSTALL_DATADIR}/logos-package-manager
)

install(DIRECTORY "${PLUGINS_OUTPUT_DIR}/"
    DESTINATION ${CMAKE_INSTALL_DATADIR}/logos-package-manager/generated
    OPTIONAL
)