CMakeLists.txt

cmake_minimum_required(VERSION 3.15)
project(SupabaseCpp)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Mobile platform configuration
if(ANDROID)
    message(STATUS "Building for Android")

    # OpenSSL configuration for Android
    set(OPENSSL_BASE "${CMAKE_SOURCE_DIR}/third_party/openssl-android")
    set(OPENSSL_ROOT "${OPENSSL_BASE}/${CMAKE_ANDROID_ARCH_ABI}")
    
    # Check if OpenSSL is available for this ABI
    if(EXISTS "${OPENSSL_ROOT}/lib/libssl.a" AND EXISTS "${OPENSSL_ROOT}/lib/libcrypto.a")
        message(STATUS "Found OpenSSL for ${CMAKE_ANDROID_ARCH_ABI}")
        set(USE_OPENSSL ON)
        
        # Import OpenSSL libraries
        add_library(crypto STATIC IMPORTED)
        set_target_properties(crypto PROPERTIES
            IMPORTED_LOCATION "${OPENSSL_ROOT}/lib/libcrypto.a"
            INTERFACE_INCLUDE_DIRECTORIES "${OPENSSL_ROOT}/include"
        )
        
        add_library(ssl STATIC IMPORTED)
        set_target_properties(ssl PROPERTIES
            IMPORTED_LOCATION "${OPENSSL_ROOT}/lib/libssl.a"
            INTERFACE_INCLUDE_DIRECTORIES "${OPENSSL_ROOT}/include"
        )
    else()
        message(WARNING "OpenSSL not found for ${CMAKE_ANDROID_ARCH_ABI}. Building without SSL support.")
        set(USE_OPENSSL OFF)
    endif()
elseif(IOS)
    message(STATUS "Building for iOS")

    # OpenSSL configuration for iOS
    if(USE_SSL)
        set(OPENSSL_IOS_BASE "${CMAKE_SOURCE_DIR}/third_party/openssl-ios")
        
        # Determine which OpenSSL libraries to use based on the target
        if(CMAKE_OSX_SYSROOT MATCHES "simulator")
            set(OPENSSL_PLATFORM_DIR "${OPENSSL_IOS_BASE}/iphonesimulator")
            message(STATUS "Using OpenSSL for iOS Simulator")
        else()
            set(OPENSSL_PLATFORM_DIR "${OPENSSL_IOS_BASE}/iphoneos")
            message(STATUS "Using OpenSSL for iOS Device")
        endif()
        
        # Check if OpenSSL static libraries are available
        if(EXISTS "${OPENSSL_PLATFORM_DIR}/lib/libssl.a" AND 
           EXISTS "${OPENSSL_PLATFORM_DIR}/lib/libcrypto.a")
            message(STATUS "Found OpenSSL static libraries for iOS")
            set(USE_OPENSSL ON)
            
            # Import OpenSSL static libraries
            add_library(crypto_ios STATIC IMPORTED)
            set_target_properties(crypto_ios PROPERTIES
                IMPORTED_LOCATION "${OPENSSL_PLATFORM_DIR}/lib/libcrypto.a"
                INTERFACE_INCLUDE_DIRECTORIES "${OPENSSL_PLATFORM_DIR}/include"
            )
            
            add_library(ssl_ios STATIC IMPORTED)
            set_target_properties(ssl_ios PROPERTIES
                IMPORTED_LOCATION "${OPENSSL_PLATFORM_DIR}/lib/libssl.a"
                INTERFACE_INCLUDE_DIRECTORIES "${OPENSSL_PLATFORM_DIR}/include"
                INTERFACE_LINK_LIBRARIES crypto_ios
            )
        else()
            message(WARNING "OpenSSL static libraries not found for iOS at ${OPENSSL_PLATFORM_DIR}. Building without SSL support.")
            set(USE_OPENSSL OFF)
        endif()
    else()
        message(STATUS "OpenSSL support disabled for iOS")
        set(USE_OPENSSL OFF)
    endif()
else()
    message(STATUS "Building for development/testing")
endif()

# Include directories
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/third_party/httplib)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/third_party)

# Source files
set(SOURCES
    src/supabase.cpp
)

# Headers
set(HEADERS
    include/supabase.h
)

# Create shared library for mobile platforms
add_library(supabase SHARED ${SOURCES} ${HEADERS})

# Configure OpenSSL support
if(ANDROID AND USE_OPENSSL)
    target_link_libraries(supabase ssl crypto)
    target_compile_definitions(supabase PRIVATE CPPHTTPLIB_OPENSSL_SUPPORT)
    message(STATUS "Enabled OpenSSL support for Android")
elseif(IOS AND USE_OPENSSL)
    target_link_libraries(supabase ssl_ios crypto_ios)
    target_compile_definitions(supabase PRIVATE CPPHTTPLIB_OPENSSL_SUPPORT)
    message(STATUS "Enabled OpenSSL support for iOS")
elseif(NOT ANDROID AND NOT IOS)
    # Try to find system OpenSSL for non-mobile builds
    find_package(OpenSSL QUIET)
    if(OpenSSL_FOUND)
        target_link_libraries(supabase OpenSSL::SSL OpenSSL::Crypto)
        target_compile_definitions(supabase PRIVATE CPPHTTPLIB_OPENSSL_SUPPORT)
        message(STATUS "Enabled system OpenSSL support")
    else()
        message(WARNING "OpenSSL not found. Building without SSL support.")
    endif()
endif()

# Platform-specific linking
if(ANDROID)
    # Link Android log library for debugging
    find_library(LOG_LIB log)
    target_link_libraries(supabase ${LOG_LIB})
elseif(IOS)
    target_link_libraries(supabase "-framework Foundation")
endif()

# Set library properties
set_target_properties(supabase PROPERTIES
    VERSION 1.0.0
    SOVERSION 1
    PUBLIC_HEADER "${HEADERS}"
)

# Mobile platform-specific settings
if(ANDROID)
    # Android-specific settings - use static STL to avoid runtime dependency
    set_target_properties(supabase PROPERTIES
        ANDROID_STL c++_static
    )
elseif(IOS)
    # iOS-specific settings for framework
    set_target_properties(supabase PROPERTIES
        FRAMEWORK TRUE
        FRAMEWORK_VERSION A
        MACOSX_FRAMEWORK_IDENTIFIER com.supabase.cpp
        MACOSX_FRAMEWORK_BUNDLE_VERSION 1.0.0
        MACOSX_FRAMEWORK_SHORT_VERSION_STRING 1.0.0
        XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "iPhone Developer"
        XCODE_ATTRIBUTE_DEVELOPMENT_TEAM ""
        PUBLIC_HEADER "${HEADERS}"
    )
elseif(APPLE)
    # Development on macOS
    set_target_properties(supabase PROPERTIES
        MACOSX_RPATH TRUE
        INSTALL_NAME_DIR "@rpath"
    )
endif()

# Install targets (for development)
install(TARGETS supabase
    LIBRARY DESTINATION lib
    ARCHIVE DESTINATION lib
    RUNTIME DESTINATION bin
    FRAMEWORK DESTINATION Frameworks
    PUBLIC_HEADER DESTINATION include
)