CMakeLists.txt

cmake_minimum_required(VERSION 3.16)
project(carquet VERSION 0.4.0 LANGUAGES C)

set(CMAKE_C_STANDARD 11)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

# macOS deployment target - respect user-specified value, only set default if not provided
if(APPLE)
    # Only set a default deployment target if one wasn't already specified
    if(NOT CMAKE_OSX_DEPLOYMENT_TARGET)
        # Get the current macOS version and use it as deployment target
        execute_process(
            COMMAND sw_vers -productVersion
            OUTPUT_VARIABLE MACOS_VERSION
            OUTPUT_STRIP_TRAILING_WHITESPACE
            RESULT_VARIABLE SW_VERS_RESULT
        )
        if(SW_VERS_RESULT EQUAL 0 AND MACOS_VERSION)
            # Extract major version (e.g., "15" from "15.2")
            string(REGEX MATCH "^[0-9]+" MACOS_MAJOR_VERSION "${MACOS_VERSION}")
            if(MACOS_MAJOR_VERSION)
                set(CMAKE_OSX_DEPLOYMENT_TARGET "${MACOS_MAJOR_VERSION}.0" CACHE STRING "Minimum macOS version")
            endif()
        endif()
    endif()

    # Suppress linker warnings about library version mismatches from Homebrew LLVM
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -w")
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -w")
endif()

# Build options
option(CARQUET_BUILD_DEV "Build all development targets (tests, examples, benchmarks)" OFF)
option(CARQUET_BUILD_TESTS "Build tests" ${CARQUET_BUILD_DEV})
option(CARQUET_BUILD_EXAMPLES "Build example programs" ${CARQUET_BUILD_DEV})
option(CARQUET_BUILD_BENCHMARKS "Build benchmark and profiling programs" ${CARQUET_BUILD_DEV})
option(CARQUET_BUILD_ARROW_CPP_BENCHMARK "Build the optional Arrow C++ comparison benchmark" OFF)
option(CARQUET_BUILD_INTEROP "Build interoperability test programs" ${CARQUET_BUILD_DEV})
option(CARQUET_BUILD_CLI "Build carquet CLI tool" ON)
option(CARQUET_BUILD_SHARED "Build shared library" OFF)
option(CARQUET_ENABLE_SSE "Enable SSE optimizations" ON)
option(CARQUET_ENABLE_AVX "Enable AVX optimizations" ON)
option(CARQUET_ENABLE_AVX2 "Enable AVX2 optimizations" ON)
option(CARQUET_ENABLE_AVX512 "Enable AVX-512 optimizations" ON)
option(CARQUET_ENABLE_NEON "Enable NEON optimizations" ON)
option(CARQUET_ENABLE_SVE "Enable SVE optimizations" OFF)
set(CARQUET_ARROW_CPP_ROOT "" CACHE PATH
    "Optional Arrow/Parquet install prefix used only for benchmark_arrow_cpp")

# External compression libraries
include(FetchContent)

# Try to find system zstd first, fetch if not found
# Method 1: Try modern CMake config (works best on Windows/vcpkg/conda)
find_package(zstd CONFIG QUIET)
if(zstd_FOUND)
    message(STATUS "Found zstd via CMake config")
    # When building a shared library, prefer shared deps to avoid -fPIC issues
    # with static libraries that weren't compiled with -fPIC.
    if(CARQUET_BUILD_SHARED AND TARGET zstd::libzstd_shared)
        set(ZSTD_LIBRARIES zstd::libzstd_shared)
    elseif(TARGET zstd::libzstd_static)
        set(ZSTD_LIBRARIES zstd::libzstd_static)
    elseif(TARGET zstd::libzstd_shared)
        set(ZSTD_LIBRARIES zstd::libzstd_shared)
    endif()
    set(ZSTD_FOUND TRUE)
else()
    # Method 2: Try pkg-config (Linux/macOS)
    find_package(PkgConfig QUIET)
    if(PkgConfig_FOUND)
        pkg_check_modules(ZSTD QUIET libzstd)
    endif()
endif()

if(ZSTD_FOUND)
    message(STATUS "Found system libzstd")
else()
    # Method 3: Fetch from source
    message(STATUS "Fetching zstd...")
    FetchContent_Declare(
        zstd
        GIT_REPOSITORY https://github.com/facebook/zstd.git
        GIT_TAG        v1.5.6
        SOURCE_SUBDIR  build/cmake
    )
    set(ZSTD_BUILD_PROGRAMS OFF CACHE BOOL "" FORCE)
    set(ZSTD_BUILD_TESTS OFF CACHE BOOL "" FORCE)
    set(ZSTD_BUILD_SHARED OFF CACHE BOOL "" FORCE)
    set(ZSTD_BUILD_STATIC ON CACHE BOOL "" FORCE)
    FetchContent_MakeAvailable(zstd)
    set(ZSTD_LIBRARIES libzstd_static)
    set(ZSTD_INCLUDE_DIRS ${zstd_SOURCE_DIR}/lib)
endif()

# Try to find system zlib first, fetch if not found
find_package(ZLIB QUIET)
if(ZLIB_FOUND)
    message(STATUS "Found system zlib: ${ZLIB_VERSION_STRING}")
else()
    message(STATUS "Fetching zlib...")
    FetchContent_Declare(
        zlib
        GIT_REPOSITORY https://github.com/madler/zlib.git
        GIT_TAG        v1.3.1
    )
    set(ZLIB_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
    FetchContent_MakeAvailable(zlib)
    set(ZLIB_LIBRARIES zlibstatic)
    set(ZLIB_INCLUDE_DIRS ${zlib_SOURCE_DIR} ${zlib_BINARY_DIR})
endif()

# Try to find system lz4 first, fetch if not found
# Prefer CMake config (gives proper targets with full paths on all platforms)
find_package(lz4 CONFIG QUIET)
if(lz4_FOUND)
    message(STATUS "Found lz4 via CMake config")
    if(CARQUET_BUILD_SHARED AND TARGET LZ4::lz4_shared)
        set(LZ4_LIBRARIES LZ4::lz4_shared)
    elseif(TARGET LZ4::lz4_static)
        set(LZ4_LIBRARIES LZ4::lz4_static)
    elseif(TARGET LZ4::lz4_shared)
        set(LZ4_LIBRARIES LZ4::lz4_shared)
    elseif(TARGET lz4::lz4)
        set(LZ4_LIBRARIES lz4::lz4)
    endif()
    # Only mark as found if we actually resolved a target
    if(LZ4_LIBRARIES)
        set(LZ4_FOUND TRUE)
    else()
        message(STATUS "lz4 CMake config found but no known target — trying pkg-config")
        set(LZ4_FOUND FALSE)
    endif()
endif()

if(NOT LZ4_FOUND)
    find_package(PkgConfig QUIET)
    if(PkgConfig_FOUND)
        pkg_check_modules(LZ4 QUIET liblz4)
        if(LZ4_FOUND)
            message(STATUS "Found system liblz4 via pkg-config")
            # Use LINK_LIBRARIES (full paths) instead of LIBRARIES (bare names)
            # to avoid MSVC linker failing to locate the .lib file
            if(LZ4_LINK_LIBRARIES)
                set(LZ4_LIBRARIES ${LZ4_LINK_LIBRARIES})
            endif()
        endif()
    endif()
endif()

if(NOT LZ4_FOUND)
    message(STATUS "Fetching lz4...")
    FetchContent_Declare(
        lz4
        GIT_REPOSITORY https://github.com/lz4/lz4.git
        GIT_TAG        v1.10.0
        SOURCE_SUBDIR  build/cmake
    )
    set(LZ4_BUILD_CLI OFF CACHE BOOL "" FORCE)
    set(LZ4_BUILD_LEGACY_LZ4C OFF CACHE BOOL "" FORCE)
    # Save and restore BUILD_SHARED_LIBS to avoid corrupting cache for rest of build
    set(_saved_BSL ${BUILD_SHARED_LIBS})
    set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
    set(BUILD_STATIC_LIBS ON CACHE BOOL "" FORCE)
    FetchContent_MakeAvailable(lz4)
    set(BUILD_SHARED_LIBS ${_saved_BSL} CACHE BOOL "" FORCE)
    set(LZ4_LIBRARIES lz4_static)
    set(LZ4_INCLUDE_DIRS ${lz4_SOURCE_DIR}/lib)
endif()

# Compiler detection
if(CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
    set(CARQUET_COMPILER_GCC_LIKE TRUE)
elseif(CMAKE_C_COMPILER_ID MATCHES "MSVC")
    set(CARQUET_COMPILER_MSVC TRUE)
endif()

# Architecture detection
include(CheckCSourceCompiles)
check_c_source_compiles("
    #if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
    int main() { return 0; }
    #else
    #error Not x86
    #endif
" CARQUET_ARCH_X86)

check_c_source_compiles("
    #if defined(__aarch64__) || defined(__arm64__) || defined(_M_ARM64) || defined(__arm__) || defined(_M_ARM)
    int main() { return 0; }
    #else
    #error Not ARM
    #endif
" CARQUET_ARCH_ARM)

# Compiler flags
if(CARQUET_COMPILER_GCC_LIKE)
    add_compile_options(-Wall -Wextra -Wpedantic -Wno-unused-parameter)

    # Debug/Release flags
    set(CMAKE_C_FLAGS_DEBUG "-g -O0 -DCARQUET_DEBUG")
    set(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG -flto=auto")
    set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG")

    # When using LTO, ensure ar/ranlib match the compiler toolchain
    # (Apple's ranlib can't parse LLVM bitcode from Homebrew LLVM)
    if(CMAKE_C_COMPILER MATCHES "llvm")
        get_filename_component(_LLVM_BIN_DIR "${CMAKE_C_COMPILER}" DIRECTORY)
        find_program(_LLVM_AR llvm-ar HINTS "${_LLVM_BIN_DIR}" NO_DEFAULT_PATH)
        find_program(_LLVM_RANLIB llvm-ranlib HINTS "${_LLVM_BIN_DIR}" NO_DEFAULT_PATH)
        if(_LLVM_AR)
            set(CMAKE_AR "${_LLVM_AR}" CACHE FILEPATH "Archiver" FORCE)
        endif()
        if(_LLVM_RANLIB)
            set(CMAKE_RANLIB "${_LLVM_RANLIB}" CACHE FILEPATH "Ranlib" FORCE)
        endif()
    endif()
elseif(CARQUET_COMPILER_MSVC)
    # MSVC warning levels and options
    add_compile_options(/W3 /wd4996 /wd4244 /wd4267)

    # Debug/Release flags
    set(CMAKE_C_FLAGS_DEBUG "/Zi /Od /DCARQUET_DEBUG")
    set(CMAKE_C_FLAGS_RELEASE "/O2 /DNDEBUG")
    set(CMAKE_C_FLAGS_RELWITHDEBINFO "/O2 /Zi /DNDEBUG")
endif()

# Optional native architecture optimization
option(CARQUET_NATIVE_ARCH "Build with -march=native for maximum performance" OFF)
if(CARQUET_NATIVE_ARCH AND CARQUET_COMPILER_GCC_LIKE)
    add_compile_options(-march=native)
endif()

# Source files
set(CARQUET_CORE_SOURCES
    src/core/arena.c
    src/core/buffer.c
    src/core/bitpack.c
    src/core/endian.c
    src/core/error.c
)

set(CARQUET_THRIFT_SOURCES
    src/thrift/thrift_decode.c
    src/thrift/thrift_encode.c
    src/thrift/parquet_types.c
)

set(CARQUET_ENCODING_SOURCES
    src/encoding/plain.c
    src/encoding/rle.c
    src/encoding/delta.c
    src/encoding/delta_length.c
    src/encoding/delta_strings.c
    src/encoding/dictionary.c
    src/encoding/byte_stream_split.c
)

set(CARQUET_COMPRESSION_SOURCES
    src/compression/lz4.c
    src/compression/snappy.c
    src/compression/zstd.c
    src/compression/gzip.c
)

# Snappy uses SSSE3 (pshufb) for pattern extension on x86.
# SSSE3 is baseline since Core 2 (2006) / x86-64-v2.
if(CARQUET_ARCH_X86 AND CARQUET_ENABLE_SSE)
    if(CARQUET_COMPILER_GCC_LIKE)
        set_source_files_properties(src/compression/snappy.c PROPERTIES
            COMPILE_FLAGS "-mssse3")
    endif()
endif()

set(CARQUET_SIMD_SOURCES
    src/simd/detect.c
    src/simd/dispatch.c
)

# Runtime CPU feature detection must stay correct under mixed LLVM/macOS toolchains.
# Excluding this tiny unit from LTO avoids miscompiled feature flags on Apple Silicon.
if(CARQUET_COMPILER_GCC_LIKE)
    set_source_files_properties(src/simd/detect.c PROPERTIES COMPILE_FLAGS "-fno-lto")
endif()

set(CARQUET_READER_SOURCES
    src/reader/file_reader.c
    src/reader/row_group_reader.c
    src/reader/column_reader.c
    src/reader/page_reader.c
    src/reader/batch_reader.c
    src/reader/statistics.c
    src/reader/mmap_reader.c
    src/reader/worker_pool.c
)

set(CARQUET_WRITER_SOURCES
    src/writer/file_writer.c
    src/writer/row_group_writer.c
    src/writer/column_writer.c
    src/writer/page_writer.c
)

set(CARQUET_METADATA_SOURCES
    src/metadata/schema.c
    src/metadata/statistics.c
    src/metadata/bloom_filter.c
    src/metadata/page_index.c
)

set(CARQUET_UTIL_SOURCES
    src/util/crc32.c
    src/util/xxhash.c
)

# x86 SIMD sources — only compile files for enabled instruction sets
if(CARQUET_ARCH_X86)
    # Auto-detect: disable AVX-512 if compiler lacks _mm512_set_epi8 (GCC < 9)
    if(CARQUET_ENABLE_AVX512 AND CARQUET_COMPILER_GCC_LIKE)
        include(CheckCSourceCompiles)
        set(CMAKE_REQUIRED_FLAGS "-mavx512f -mavx512bw -mavx512vl")
        check_c_source_compiles("
            #include <immintrin.h>
            int main(void) {
                __m512i v = _mm512_set_epi8(
                    0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
                    16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
                    32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
                    48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63);
                (void)v; return 0;
            }
        " CARQUET_HAS_AVX512_INTRINSICS)
        unset(CMAKE_REQUIRED_FLAGS)
        if(NOT CARQUET_HAS_AVX512_INTRINSICS)
            message(WARNING "Compiler lacks full AVX-512 intrinsic support — disabling AVX-512")
            set(CARQUET_ENABLE_AVX512 OFF)
        endif()
    endif()

    set(CARQUET_SIMD_X86_SOURCES "")

    if(CARQUET_ENABLE_SSE)
        list(APPEND CARQUET_SIMD_X86_SOURCES src/simd/x86/sse_ops.c)
        if(CARQUET_COMPILER_GCC_LIKE)
            set_source_files_properties(src/simd/x86/sse_ops.c PROPERTIES
                COMPILE_FLAGS "-msse4.2")
        endif()
    endif()

    if(CARQUET_ENABLE_AVX)
        list(APPEND CARQUET_SIMD_X86_SOURCES src/simd/x86/avx_ops.c)
        if(CARQUET_COMPILER_GCC_LIKE)
            set_source_files_properties(src/simd/x86/avx_ops.c PROPERTIES
                COMPILE_FLAGS "-mavx -msse4.2")
        elseif(CARQUET_COMPILER_MSVC)
            set_source_files_properties(src/simd/x86/avx_ops.c PROPERTIES
                COMPILE_FLAGS "/arch:AVX")
        endif()
    endif()

    if(CARQUET_ENABLE_AVX2)
        list(APPEND CARQUET_SIMD_X86_SOURCES src/simd/x86/avx2_ops.c)
        if(CARQUET_COMPILER_GCC_LIKE)
            set_source_files_properties(src/simd/x86/avx2_ops.c PROPERTIES
                COMPILE_FLAGS "-mavx2 -mbmi2")
        elseif(CARQUET_COMPILER_MSVC)
            set_source_files_properties(src/simd/x86/avx2_ops.c PROPERTIES
                COMPILE_FLAGS "/arch:AVX2")
        endif()
    endif()

    if(CARQUET_ENABLE_AVX512)
        list(APPEND CARQUET_SIMD_X86_SOURCES src/simd/x86/avx512_ops.c)
        if(CARQUET_COMPILER_GCC_LIKE)
            set_source_files_properties(src/simd/x86/avx512_ops.c PROPERTIES
                COMPILE_FLAGS "-mavx512f -mavx512bw -mavx512vl")
        elseif(CARQUET_COMPILER_MSVC)
            set_source_files_properties(src/simd/x86/avx512_ops.c PROPERTIES
                COMPILE_FLAGS "/arch:AVX512")
        endif()
    endif()
endif()

# ARM SIMD sources — only compile files for enabled instruction sets
if(CARQUET_ARCH_ARM)
    set(CARQUET_SIMD_ARM_SOURCES "")

    if(CARQUET_ENABLE_NEON)
        list(APPEND CARQUET_SIMD_ARM_SOURCES src/simd/arm/neon_ops.c)
        list(APPEND CARQUET_SIMD_ARM_SOURCES src/simd/arm/crc32_arm.c)
        if(CARQUET_COMPILER_GCC_LIKE)
            set_source_files_properties(src/simd/arm/crc32_arm.c PROPERTIES
                COMPILE_FLAGS "-march=armv8-a+crc")
        endif()
    endif()

    if(CARQUET_ENABLE_SVE)
        list(APPEND CARQUET_SIMD_ARM_SOURCES src/simd/arm/sve_ops.c)
        if(CARQUET_COMPILER_GCC_LIKE)
            set_source_files_properties(src/simd/arm/sve_ops.c PROPERTIES
                COMPILE_FLAGS "-march=armv8-a+sve")
        endif()
    endif()
endif()

# OpenMP support for parallel column reading
find_package(OpenMP)
if(OpenMP_C_FOUND)
    message(STATUS "OpenMP found - enabling parallel column reading")
endif()

# Combine all sources
set(CARQUET_SOURCES
    ${CARQUET_CORE_SOURCES}
    ${CARQUET_THRIFT_SOURCES}
    ${CARQUET_ENCODING_SOURCES}
    ${CARQUET_COMPRESSION_SOURCES}
    ${CARQUET_SIMD_SOURCES}
    ${CARQUET_READER_SOURCES}
    ${CARQUET_WRITER_SOURCES}
    ${CARQUET_METADATA_SOURCES}
    ${CARQUET_UTIL_SOURCES}
)

if(CARQUET_ARCH_X86)
    list(APPEND CARQUET_SOURCES ${CARQUET_SIMD_X86_SOURCES})
endif()
if(CARQUET_ARCH_ARM)
    list(APPEND CARQUET_SOURCES ${CARQUET_SIMD_ARM_SOURCES})
endif()

# Create library
if(CARQUET_BUILD_SHARED)
    add_library(carquet SHARED ${CARQUET_SOURCES})
    set_target_properties(carquet PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
    target_compile_definitions(carquet
        PUBLIC CARQUET_BUILD_SHARED
        PRIVATE CARQUET_BUILDING_DLL
    )
else()
    add_library(carquet STATIC ${CARQUET_SOURCES})
endif()

target_include_directories(carquet
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
        $<INSTALL_INTERFACE:include>
    PRIVATE
        ${CMAKE_CURRENT_SOURCE_DIR}/src
        ${ZSTD_INCLUDE_DIRS}
        ${ZLIB_INCLUDE_DIRS}
        ${LZ4_INCLUDE_DIRS}
)

# Link external compression libraries
set(CARQUET_COMPRESSION_LIBS ${ZSTD_LIBRARIES} ${LZ4_LIBRARIES})

if(ZLIB_FOUND)
    target_link_libraries(carquet PRIVATE ${CARQUET_COMPRESSION_LIBS} ZLIB::ZLIB)
else()
    target_link_libraries(carquet PRIVATE ${CARQUET_COMPRESSION_LIBS} ${ZLIB_LIBRARIES})
endif()

# Link libm for math functions (bloom_filter.c uses log())
# PUBLIC so that consumers of the shared library also link -lm; on some toolchains
# (RHEL with --no-copy-dt-needed-entries) PRIVATE alone is not sufficient.
if(UNIX)
    target_link_libraries(carquet PUBLIC m)
endif()

# Link pthreads for worker pool (POSIX)
if(UNIX)
    find_package(Threads REQUIRED)
    target_link_libraries(carquet PRIVATE Threads::Threads)
endif()

# Link OpenMP for parallel column reading
if(OpenMP_C_FOUND)
    target_link_libraries(carquet PRIVATE OpenMP::OpenMP_C)
endif()

# Architecture definitions
if(CARQUET_ARCH_X86)
    target_compile_definitions(carquet PRIVATE CARQUET_ARCH_X86)
    if(CARQUET_ENABLE_SSE)
        target_compile_definitions(carquet PRIVATE CARQUET_ENABLE_SSE)
    endif()
    if(CARQUET_ENABLE_AVX)
        target_compile_definitions(carquet PRIVATE CARQUET_ENABLE_AVX)
    endif()
    if(CARQUET_ENABLE_AVX2)
        target_compile_definitions(carquet PRIVATE CARQUET_ENABLE_AVX2)
    endif()
    if(CARQUET_ENABLE_AVX512)
        target_compile_definitions(carquet PRIVATE CARQUET_ENABLE_AVX512)
    endif()
endif()

if(CARQUET_ARCH_ARM)
    target_compile_definitions(carquet PRIVATE CARQUET_ARCH_ARM)
    if(CARQUET_ENABLE_NEON)
        target_compile_definitions(carquet PRIVATE CARQUET_ENABLE_NEON)
    endif()
    if(CARQUET_ENABLE_SVE)
        target_compile_definitions(carquet PRIVATE CARQUET_ENABLE_SVE)
    endif()
endif()

# Tests
if(CARQUET_BUILD_TESTS)
    enable_testing()

    # Helper function to configure test targets
    function(add_carquet_test TEST_NAME TEST_SOURCE)
        add_executable(${TEST_NAME} ${TEST_SOURCE})
        target_link_libraries(${TEST_NAME} PRIVATE carquet)
        target_include_directories(${TEST_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
        # Tests use assert() for validation — keep assertions enabled in all build types
        if(MSVC)
            target_compile_options(${TEST_NAME} PRIVATE /UNDEBUG)
        else()
            target_compile_options(${TEST_NAME} PRIVATE -UNDEBUG)
        endif()
        if(CARQUET_COMPILER_GCC_LIKE)
            target_compile_options(${TEST_NAME} PRIVATE -Wno-unused-result)
        endif()
        add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME})
    endfunction()

    add_carquet_test(test_core tests/test_core.c)
    add_carquet_test(test_thrift tests/test_thrift.c)
    add_carquet_test(test_encodings tests/test_encodings.c)
    add_carquet_test(test_reader tests/test_reader.c)
    add_carquet_test(test_encodings_extended tests/test_encodings_extended.c)
    add_carquet_test(test_compression tests/test_compression.c)
    add_carquet_test(test_utils tests/test_utils.c)
    add_carquet_test(test_production tests/test_production.c)
    add_carquet_test(test_maturity tests/test_maturity.c)
    add_carquet_test(test_large_schema tests/test_large_schema.c)

    # Edge case tests
    add_carquet_test(test_edge_encodings tests/test_edge_encodings.c)
    add_carquet_test(test_edge_compression tests/test_edge_compression.c)
    add_carquet_test(test_edge_malformed tests/test_edge_malformed.c)
    add_carquet_test(test_edge_boundaries tests/test_edge_boundaries.c)
    add_carquet_test(test_edge_io tests/test_edge_io.c)

    # Nested schema tests
    add_carquet_test(test_nested tests/test_nested.c)

    # Bloom filter and page index tests
    add_carquet_test(test_bloom_page_index tests/test_bloom_page_index.c)

    # Memory mapping tests
    add_carquet_test(test_mmap tests/test_mmap.c)

    # Advanced API tests (bloom filter, page index, kv metadata, etc.)
    add_carquet_test(test_advanced_api tests/test_advanced_api.c)
endif()

# Examples
if(CARQUET_BUILD_EXAMPLES)
    # Helper function to configure example targets
    function(add_carquet_example EXAMPLE_NAME EXAMPLE_SOURCE)
        add_executable(${EXAMPLE_NAME} ${EXAMPLE_SOURCE})
        target_link_libraries(${EXAMPLE_NAME} PRIVATE carquet)
        if(CARQUET_COMPILER_GCC_LIKE)
            target_compile_options(${EXAMPLE_NAME} PRIVATE -Wno-unused-result)
        endif()
    endfunction()

    add_carquet_example(example_basic_write_read examples/basic_write_read.c)
    add_carquet_example(example_data_types examples/data_types.c)
    add_carquet_example(example_compression examples/compression_codecs.c)
    add_carquet_example(example_nullable examples/nullable_columns.c)
    add_carquet_example(example_advanced examples/advanced_features.c)
endif()

# Benchmarks
if(CARQUET_BUILD_BENCHMARKS)
    add_executable(benchmark_carquet benchmark/benchmark_carquet.c)
    target_link_libraries(benchmark_carquet PRIVATE carquet)
    if(UNIX AND NOT APPLE)
        target_link_libraries(benchmark_carquet PRIVATE m)  # libm for math functions
    endif()
    if(CARQUET_COMPILER_GCC_LIKE)
        target_compile_options(benchmark_carquet PRIVATE -Wno-unused-result)
    endif()

    # Test file generator (C replacement for generate_test_files.py - no extra deps)
    add_executable(generate_test_files benchmark/generate_test_files.c)
    target_link_libraries(generate_test_files PRIVATE carquet)
    if(CARQUET_COMPILER_GCC_LIKE)
        target_compile_options(generate_test_files PRIVATE -Wno-unused-result)
    endif()

    if(CARQUET_BUILD_ARROW_CPP_BENCHMARK)
        include(CheckLanguage)
        check_language(CXX)
        if(CMAKE_CXX_COMPILER)
            enable_language(CXX)

            if(CARQUET_ARROW_CPP_ROOT)
                find_package(Arrow CONFIG QUIET PATHS ${CARQUET_ARROW_CPP_ROOT})
                find_package(Parquet CONFIG QUIET PATHS ${CARQUET_ARROW_CPP_ROOT})
            endif()

            if(NOT Arrow_FOUND)
                find_package(Arrow CONFIG QUIET)
            endif()
            if(NOT Parquet_FOUND)
                find_package(Parquet CONFIG QUIET)
            endif()

            set(CARQUET_ARROW_TARGET "")
            set(CARQUET_PARQUET_TARGET "")
            if(TARGET Arrow::arrow_shared)
                set(CARQUET_ARROW_TARGET Arrow::arrow_shared)
            elseif(TARGET Arrow::arrow_static)
                set(CARQUET_ARROW_TARGET Arrow::arrow_static)
            endif()
            if(TARGET Parquet::parquet_shared)
                set(CARQUET_PARQUET_TARGET Parquet::parquet_shared)
            elseif(TARGET Parquet::parquet_static)
                set(CARQUET_PARQUET_TARGET Parquet::parquet_static)
            endif()

            if(CARQUET_ARROW_TARGET AND CARQUET_PARQUET_TARGET)
                add_executable(benchmark_arrow_cpp benchmark/benchmark_arrow_cpp.cpp)
                target_link_libraries(benchmark_arrow_cpp PRIVATE
                    ${CARQUET_PARQUET_TARGET}
                    ${CARQUET_ARROW_TARGET}
                )
                set_target_properties(benchmark_arrow_cpp PROPERTIES
                    CXX_STANDARD 20
                    CXX_STANDARD_REQUIRED YES
                )
                if(CARQUET_COMPILER_GCC_LIKE)
                    target_compile_options(benchmark_arrow_cpp PRIVATE -Wno-unused-result)
                endif()
            else()
                message(STATUS
                    "Skipping benchmark_arrow_cpp: Arrow/Parquet C++ libraries were not found. "
                    "Install system packages or configure -DCARQUET_ARROW_CPP_ROOT=/path/to/prefix. "
                    "The benchmark remains fully opt-in to keep normal builds lean.")
            endif()
        else()
            message(STATUS
                "Skipping benchmark_arrow_cpp: no C++ compiler available for the optional Arrow C++ benchmark.")
        endif()
    endif()

    # Profiling benchmark for CPU profiling (sample, Instruments, perf)
    # Only build on Unix systems (uses dirent.h and Unix profiling tools)
    if(NOT WIN32)
        add_executable(profile_core benchmark/profile_core.c)
        target_link_libraries(profile_core PRIVATE carquet)
        if(NOT APPLE)
            target_link_libraries(profile_core PRIVATE m)
        endif()

        # Profiling binaries (used by profiling/run_profiler.py)
        add_executable(profile_read profiling/profile_read.c)
        target_link_libraries(profile_read PRIVATE carquet)
        if(NOT APPLE)
            target_link_libraries(profile_read PRIVATE m)
        endif()

        add_executable(profile_write profiling/profile_write.c)
        target_link_libraries(profile_write PRIVATE carquet)
        if(NOT APPLE)
            target_link_libraries(profile_write PRIVATE m)
        endif()

        add_executable(profile_micro profiling/profile_micro.c)
        target_link_libraries(profile_micro PRIVATE carquet)
        target_include_directories(profile_micro PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
        if(NOT APPLE)
            target_link_libraries(profile_micro PRIVATE m)
        endif()
    endif()
endif()

# Interoperability tests
if(CARQUET_BUILD_INTEROP)
    if(NOT WIN32)
        add_executable(test_interop interop/test_interop.c)
        target_link_libraries(test_interop PRIVATE carquet)
        target_include_directories(test_interop PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
        if(CARQUET_COMPILER_GCC_LIKE)
            target_compile_options(test_interop PRIVATE -Wno-unused-result)
        endif()

        add_executable(roundtrip_writer interop/roundtrip_writer.c)
        target_link_libraries(roundtrip_writer PRIVATE carquet)
        if(CARQUET_COMPILER_GCC_LIKE)
            target_compile_options(roundtrip_writer PRIVATE -Wno-unused-result)
        endif()
    endif()
endif()

# Fuzzing
option(CARQUET_BUILD_FUZZ "Build fuzz targets" OFF)
if(CARQUET_BUILD_FUZZ)
    add_subdirectory(fuzz)
endif()

# CLI tool
if(CARQUET_BUILD_CLI)
    add_executable(carquet_cli
        src/cli/main.c
        src/cli/commands.c
        src/cli/codegen.c
        src/cli/codegen_read.c
        src/cli/codegen_write.c
    )
    set_target_properties(carquet_cli PROPERTIES OUTPUT_NAME carquet)
    target_link_libraries(carquet_cli PRIVATE carquet)
    target_include_directories(carquet_cli PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
    if(CARQUET_COMPILER_GCC_LIKE)
        target_compile_options(carquet_cli PRIVATE -Wno-unused-result)
    endif()
endif()

# Installation (skip when used as a subdirectory via FetchContent/add_subdirectory)
if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
    include(GNUInstallDirs)
    install(TARGETS carquet
        EXPORT carquetTargets
        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    )

    if(CARQUET_BUILD_CLI)
        install(TARGETS carquet_cli RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
    endif()

    install(DIRECTORY include/carquet
        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
    )

    install(EXPORT carquetTargets
        FILE carquetTargets.cmake
        NAMESPACE carquet::
        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/carquet
    )

    # Package configuration
    include(CMakePackageConfigHelpers)
    write_basic_package_version_file(
        "${CMAKE_CURRENT_BINARY_DIR}/carquetConfigVersion.cmake"
        VERSION ${PROJECT_VERSION}
        COMPATIBILITY SameMajorVersion
    )

    configure_package_config_file(
        "${CMAKE_CURRENT_SOURCE_DIR}/cmake/carquetConfig.cmake.in"
        "${CMAKE_CURRENT_BINARY_DIR}/carquetConfig.cmake"
        INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/carquet
    )
endif()