# minizip-ng project
#
# Copyright (C) Nathan Moinvaziri
#   https://github.com/zlib-ng/minizip-ng
# Copyright (C) 2016 Matthias Schmieder
#   schmieder.matthias@gmail.com

cmake_minimum_required(VERSION 3.13)

# Library version
set(VERSION "4.2.2")
# API version
set(SOVERSION "4")

project(minizip-ng
    VERSION ${VERSION}
    LANGUAGES C
    DESCRIPTION "Zip manipulation library"
    HOMEPAGE_URL https://github.com/zlib-ng/minizip-ng/)

include(CheckCCompilerFlag)
include(CheckCSourceCompiles)
include(CheckFunctionExists)
include(CheckIncludeFile)
include(CheckIncludeFiles)
include(CheckLibraryExists)
include(CheckSymbolExists)
include(CheckTypeSize)
include(CMakeDependentOption)
include(CMakePushCheckState)
include(FeatureSummary)
include(GNUInstallDirs)

include(cmake/detect-sanitizer.cmake)

list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")

message(STATUS "Using CMake version ${CMAKE_VERSION}")

# Compatibility options
option(MZ_COMPAT "Enables compatibility layer" ON)
# Compression library options
option(MZ_ZLIB "Enables ZLIB compression" ON)

# Controls to select either zlib-ng or zlib
set(MZ_ZLIB_FLAVOR "auto" CACHE STRING "Select the preferred zlib flavor - auto searches for zlib-ng then zlib")
set_property(CACHE MZ_ZLIB_FLAVOR PROPERTY STRINGS "auto" "zlib-ng" "zlib")

option(MZ_BZIP2 "Enables BZIP2 compression" ON)
option(MZ_LZMA "Enables LZMA & XZ compression" ON)
option(MZ_PPMD "Enables PPMD compression" ON)
option(MZ_ZSTD "Enables ZSTD compression" ON)
cmake_dependent_option(MZ_LIBCOMP "Enables Apple compression" ON "APPLE" OFF)
option(MZ_FETCH_LIBS "Enables fetching third-party libraries if not found" ${WIN32})
option(MZ_FORCE_FETCH_LIBS "Enables fetching third-party libraries always" OFF)
# Encryption support options
option(MZ_PKCRYPT "Enables PKWARE traditional encryption" ON)
option(MZ_WZAES "Enables WinZIP AES encryption" ON)
option(MZ_OPENSSL "Enables OpenSSL for encryption" ${UNIX})
cmake_dependent_option(MZ_LIBBSD "Builds with libbsd crypto random" ON "UNIX" OFF)
# Character conversion options
option(MZ_ICONV "Enables iconv for string encoding conversion" ON)
option(MZ_ICU "Enables ICU for string encoding conversion" OFF)
# Code generation options
option(MZ_COMPRESS_ONLY "Only support compression" OFF)
option(MZ_DECOMPRESS_ONLY "Only support decompression" OFF)
option(MZ_FILE32_API "Builds using posix 32-bit file api" OFF)
# Build and continuous integration options
option(MZ_BUILD_TESTS "Builds minizip test executable" OFF)
option(MZ_BUILD_UNIT_TESTS "Builds minizip unit test project" OFF)
option(MZ_BUILD_FUZZ_TESTS "Builds minizip fuzzer executables" OFF)
option(MZ_CODE_COVERAGE "Builds with code coverage flags" OFF)
# Multi-choice code sanitizer option
set(MZ_SANITIZER OFF CACHE STRING "Enable sanitizer support")
set_property(CACHE MZ_SANITIZER PROPERTY STRINGS "OFF" "memory" "address" "undefined" "thread")

# Backwards compatibility
if(DEFINED MZ_BUILD_TEST)
    set(MZ_BUILD_TESTS ${MZ_BUILD_TEST})
endif()
if(DEFINED MZ_BUILD_UNIT_TEST)
    set(MZ_BUILD_UNIT_TESTS ${MZ_BUILD_UNIT_TEST})
endif()
if(DEFINED MZ_BUILD_FUZZ_TEST)
    set(MZ_BUILD_FUZZ_TESTS ${MZ_BUILD_FUZZ_TEST})
endif()
if(DEFINED MZ_PROJECT_SUFFIX)
    set(MZ_LIB_SUFFIX ${MZ_PROJECT_SUFFIX})
endif()

# Package management options
if(NOT MZ_COMPAT AND NOT DEFINED MZ_LIB_SUFFIX)
    set(MZ_LIB_SUFFIX "-ng" CACHE STRING "Library name suffix for package managers")
else()
    set(MZ_LIB_SUFFIX "" CACHE STRING "Library name suffix for package managers")
endif()

mark_as_advanced(MZ_FILE32_API MZ_LIB_SUFFIX)

# ZLIB_ROOT - Parent directory of zlib installation
# BZIP2_ROOT - Parent directory of BZip2 installation
# OPENSSL_ROOT - Parent directory of OpenSSL installation

include(cmake/clone-repo.cmake)

set(STDLIB_DEF)
set(MINIZIP_DEF)
set(MINIZIP_INC)
set(MINIZIP_LIB)
set(MINIZIP_LIB_PUBLIC)
set(MINIZIP_DEP)
set(MINIZIP_DEP_PKG)
set(MINIZIP_DEP_PKG_PUBLIC)
set(MINIZIP_LFG)

# Initial source files
set(MINIZIP_SRC
    mz_crypt.c
    mz_os.c
    mz_strm.c
    mz_strm_buf.c
    mz_strm_mem.c
    mz_strm_split.c
    mz_zip.c
    mz_zip_rw.c)

# Initial header files
set(MINIZIP_HDR
    mz.h
    mz_os.h
    mz_crypt.h
    mz_strm.h
    mz_strm_buf.h
    mz_strm_mem.h
    mz_strm_split.h
    mz_strm_os.h
    mz_zip.h
    mz_zip_rw.h)

set(PC_PRIVATE_LIBS)
set(PC_PRIVATE_DEPS)

# Check for system includes
check_include_file(dirent.h     HAVE_DIRENT_H)
check_include_file(sys/dirent.h HAVE_SYS_DIRENT_H)
check_include_file(inttypes.h   HAVE_INTTYPES_H)
check_include_file(stdint.h     HAVE_STDINT_H)

# Check DIR* exists
cmake_push_check_state(RESET)
    if(HAVE_DIRENT_H)
        list(APPEND CMAKE_EXTRA_INCLUDE_FILES dirent.h)
    endif()
    if(HAVE_SYS_DIRENT_H)
        list(APPEND CMAKE_EXTRA_INCLUDE_FILES sys/dirent.h)
    endif()
    check_type_size(DIR* PDIR)
cmake_pop_check_state()

# Check for large file support
check_type_size(off64_t OFF64_T)
if(HAVE_OFF64_T)
    list(APPEND STDLIB_DEF -D__USE_LARGEFILE64)
    list(APPEND STDLIB_DEF -D_LARGEFILE64_SOURCE)
endif()
# Check for fseeko support
check_function_exists(fseeko HAVE_FSEEKO)
# Check for symlink support
check_function_exists(symlink HAVE_SYMLINK)
# Check for readlink support
check_function_exists(readlink HAVE_READLINK)

configure_file(mz_config.h.cmakein ${CMAKE_CURRENT_BINARY_DIR}/mz_config.h @ONLY NEWLINE_STYLE UNIX)
list(APPEND MINIZIP_HDR ${CMAKE_CURRENT_BINARY_DIR}/mz_config.h)

if(MZ_LIBCOMP)
    if(APPLE)
        # Use Apple libcompression
        list(APPEND MINIZIP_DEF -DHAVE_LIBCOMP)
        list(APPEND MINIZIP_SRC mz_strm_libcomp.c)
        list(APPEND MINIZIP_HDR mz_strm_libcomp.h)
        list(APPEND MINIZIP_LIB compression)

        # Disable zlib as libcompression is preferred
        set(MZ_ZLIB OFF)
    else()
        message(STATUS "LibCompression not supported on the current platform")

        set(MZ_LIBCOMP OFF)
    endif()
endif()

if(MZ_ZLIB)
    # Check if zlib is present
    if(NOT MZ_FORCE_FETCH_LIBS)
        if (MZ_ZLIB_FLAVOR STREQUAL "zlib-ng" OR MZ_ZLIB_FLAVOR STREQUAL "auto")
            find_package(ZLIB-NG QUIET CONFIG)
        endif()
        if (MZ_ZLIB_FLAVOR STREQUAL "zlib" OR MZ_ZLIB_FLAVOR STREQUAL "auto")
            find_package(ZLIB QUIET)
        endif()
    endif()

    if(ZLIB-NG_FOUND AND NOT MZ_FORCE_FETCH_LIBS)
        message(STATUS "Using ZLIB-NG")

        if(BUILD_SHARED_LIBS)
            list(APPEND MINIZIP_LIB_PUBLIC zlib-ng::zlib)
        else()
            list(APPEND MINIZIP_LIB_PUBLIC zlib-ng::zlibstatic)
        endif()

        set(PC_PRIVATE_DEPS "zlib-ng")
        set(ZLIB_COMPAT OFF)
    elseif(ZLIB_FOUND AND NOT MZ_FORCE_FETCH_LIBS)
        message(STATUS "Using ZLIB ${ZLIB_VERSION_STRING}")

        list(APPEND MINIZIP_LIB_PUBLIC ZLIB::ZLIB)

        set(PC_PRIVATE_DEPS "zlib")
        set(ZLIB_COMPAT ON)
    elseif(MZ_FETCH_LIBS)
        set(BUILD_TESTING OFF CACHE BOOL "Build zlib-ng tests" FORCE)

        clone_repo(zlib https://github.com/zlib-ng/zlib-ng stable)

        list(APPEND MINIZIP_INC ${ZLIB_SOURCE_DIR})
        list(APPEND MINIZIP_INC ${ZLIB_BINARY_DIR})

        if(EXISTS "${ZLIB_BINARY_DIR}/zlib-ng.h")
            message(STATUS "ZLIB repository detected as ZLIB-NG")
            set(ZLIB_COMPAT OFF)
        else()
            set(ZLIB_COMPAT ON)
        endif()

        # Have to add zlib to install targets
        if(ZLIB_COMPAT AND (NOT DEFINED BUILD_SHARED_LIBS OR NOT BUILD_SHARED_LIBS))
            list(APPEND MINIZIP_DEP zlibstatic)
            list(APPEND MINIZIP_LIB_PUBLIC zlibstatic)
        else()
            list(APPEND MINIZIP_DEP zlib)
            list(APPEND MINIZIP_LIB_PUBLIC zlib)
        endif()
    else()
        message(STATUS "ZLIB library not found")

        set(MZ_ZLIB OFF)
    endif()

    if(MZ_ZLIB)
        list(APPEND MINIZIP_DEF -DHAVE_ZLIB)
        if(ZLIB_COMPAT)
            list(APPEND MINIZIP_DEF -DZLIB_COMPAT)
        endif()
        # MZ_COMPAT exposes zlib in public headers, so register it as PUBLIC.
        if(ZLIB-NG_FOUND)
            if(MZ_COMPAT)
                list(APPEND MINIZIP_DEP_PKG_PUBLIC ZLIB-NG)
            else()
                list(APPEND MINIZIP_DEP_PKG ZLIB-NG)
            endif()
        elseif(ZLIB_FOUND)
            if(MZ_COMPAT)
                list(APPEND MINIZIP_DEP_PKG_PUBLIC ZLIB)
            else()
                list(APPEND MINIZIP_DEP_PKG ZLIB)
            endif()
        endif()
        list(APPEND MINIZIP_SRC mz_strm_zlib.c)
        list(APPEND MINIZIP_HDR mz_strm_zlib.h)
    endif()
endif()

if(MZ_BZIP2)
    # Check if bzip2 is present
    if(NOT MZ_FORCE_FETCH_LIBS)
        find_package(BZip2 QUIET)
    endif()

    if(BZIP2_FOUND AND NOT MZ_FORCE_FETCH_LIBS)
        message(STATUS "Using BZIP2 ${BZIP2_VERSION_STRING}")

        list(APPEND MINIZIP_LIB BZip2::BZip2)

        set(PC_PRIVATE_LIBS "${PC_PRIVATE_LIBS} -lbz2")
    elseif(MZ_FETCH_LIBS)
        clone_repo(bzip2 https://sourceware.org/git/bzip2.git master)

        # BZip2 repository does not support cmake so we have to create
        # the bzip2 library ourselves
        set(BZIP2_SRC
            ${BZIP2_SOURCE_DIR}/blocksort.c
            ${BZIP2_SOURCE_DIR}/bzlib.c
            ${BZIP2_SOURCE_DIR}/compress.c
            ${BZIP2_SOURCE_DIR}/crctable.c
            ${BZIP2_SOURCE_DIR}/decompress.c
            ${BZIP2_SOURCE_DIR}/huffman.c
            ${BZIP2_SOURCE_DIR}/randtable.c)

        set(BZIP2_HDR
            ${BZIP2_SOURCE_DIR}/bzlib.h
            ${BZIP2_SOURCE_DIR}/bzlib_private.h)

        add_library(bzip2 STATIC ${BZIP2_SRC} ${BZIP2_HDR})

        target_compile_definitions(bzip2 PRIVATE -DBZ_NO_STDIO)

        list(APPEND MINIZIP_DEP bzip2)
        list(APPEND MINIZIP_INC ${BZIP2_SOURCE_DIR})
    else()
        message(STATUS "BZip2 library not found")

        set(MZ_BZIP2 OFF)
    endif()

    if(MZ_BZIP2)
        if(BZIP2_FOUND)
            list(APPEND MINIZIP_DEP_PKG BZip2)
        endif()
        list(APPEND MINIZIP_DEF -DHAVE_BZIP2)
        list(APPEND MINIZIP_SRC mz_strm_bzip.c)
        list(APPEND MINIZIP_HDR mz_strm_bzip.h)
    endif()
endif()

if(MZ_LZMA)
    # Check if liblzma is present
    if(NOT MZ_FORCE_FETCH_LIBS)
        find_package(LibLZMA QUIET)
    endif()

    if(LIBLZMA_FOUND AND NOT MZ_FORCE_FETCH_LIBS)
        message(STATUS "Using LZMA ${LIBLZMA_VERSION_STRING}")

        list(APPEND MINIZIP_LIB LibLZMA::LibLZMA)

        set(PC_PRIVATE_LIBS "${PC_PRIVATE_LIBS} -llzma")
    elseif(MZ_FETCH_LIBS)
        set(BUILD_TESTING OFF CACHE BOOL "Build lzma tests" FORCE)

        clone_repo(liblzma https://github.com/tukaani-project/xz master)

        list(APPEND MINIZIP_INC ${LIBLZMA_SOURCE_DIR}/src/liblzma/api)
        list(APPEND MINIZIP_DEP liblzma)
        # liblzma's exported target references Threads::Threads
        list(APPEND MINIZIP_DEP_PKG Threads)
    else()
        message(STATUS "LibLZMA library not found")

        set(MZ_LZMA OFF)
    endif()

    if(MZ_LZMA)
        if(LIBLZMA_FOUND)
            list(APPEND MINIZIP_DEP_PKG LibLZMA)
        endif()
        list(APPEND MINIZIP_DEF -DHAVE_LZMA -DLZMA_API_STATIC)
        list(APPEND MINIZIP_SRC mz_strm_lzma.c)
        list(APPEND MINIZIP_HDR mz_strm_lzma.h)
    endif()
endif()

if(MZ_PPMD)
    message(STATUS "Using PPMD")

    # PPMd version number below should match value in ppmd-dependabot.yml
    clone_repo(ppmd https://github.com/ip7z/7zip "26.02")

    # get the 7zip/PPMd version number
    file(READ "${PPMD_SOURCE_DIR}/C/7zVersion.h" version)
    string(REGEX MATCH "MY_VERSION_NUMBERS \"([0-9]*\.[0-9]*)\"" _ ${version})
    set(7ZIP_VERSION_NUMBER ${CMAKE_MATCH_1})
    message(STATUS "  Found 7Zip/PPMd ${7ZIP_VERSION_NUMBER}")

    # The PPMd repository does not support cmake so we have to create
    # a PPMd library ourselves
    set(PPMD_SRC
        ${PPMD_SOURCE_DIR}/C/Ppmd8.c
        ${PPMD_SOURCE_DIR}/C/Ppmd8Dec.c
        ${PPMD_SOURCE_DIR}/C/Ppmd8Enc.c)

    set(PPMD_HDR
        ${PPMD_SOURCE_DIR}/C/7zTypes.h
        ${PPMD_SOURCE_DIR}/C/Compiler.h
        ${PPMD_SOURCE_DIR}/C/CpuArch.h
        ${PPMD_SOURCE_DIR}/C/Ppmd.h
        ${PPMD_SOURCE_DIR}/C/Ppmd8.h
        ${PPMD_SOURCE_DIR}/C/Precomp.h)

    add_library(ppmd STATIC ${PPMD_SRC} ${PPMD_HDR})

    list(APPEND MINIZIP_DEP ppmd)
    list(APPEND MINIZIP_INC ${PPMD_SOURCE_DIR})

    list(APPEND MINIZIP_DEF -DHAVE_PPMD)
    list(APPEND MINIZIP_SRC mz_strm_ppmd.c)
    list(APPEND MINIZIP_HDR mz_strm_ppmd.h)
endif()

if(MZ_ZSTD)
    # Check if zstd is present
    if(NOT MZ_FORCE_FETCH_LIBS)
        find_package(zstd QUIET CONFIG)
    endif()

    if(zstd_FOUND AND NOT MZ_FORCE_FETCH_LIBS)
        message(STATUS "Using ZSTD ${zstd_VERSION}")

        if(BUILD_SHARED_LIBS)
            list(APPEND MINIZIP_LIB zstd::libzstd_shared)
        else()
            list(APPEND MINIZIP_LIB zstd::libzstd_static)
        endif()

        set(PC_PRIVATE_LIBS "${PC_PRIVATE_LIBS} -lzstd")
    elseif(MZ_FETCH_LIBS)
        set(ZSTD_BUILD_PROGRAMS OFF CACHE BOOL "Build zstd programs")

        clone_repo(zstd https://github.com/facebook/zstd release build/cmake)

        list(APPEND MINIZIP_INC ${ZSTD_SOURCE_DIR}/lib)
        if(NOT DEFINED BUILD_SHARED_LIBS OR NOT ${BUILD_SHARED_LIBS})
            list(APPEND MINIZIP_DEP libzstd_static)
        else()
            list(APPEND MINIZIP_DEP libzstd_shared)
        endif()
    else()
        message(STATUS "ZSTD library not found")

        set(MZ_ZSTD OFF)
    endif()

    if(MZ_ZSTD)
        if(zstd_FOUND)
            list(APPEND MINIZIP_DEP_PKG zstd)
        endif()
        list(APPEND MINIZIP_DEF -DHAVE_ZSTD)
        list(APPEND MINIZIP_SRC mz_strm_zstd.c)
        list(APPEND MINIZIP_HDR mz_strm_zstd.h)
    endif()
endif()

if(NOT MZ_LIBCOMP AND NOT MZ_ZLIB AND NOT MZ_ZSTD AND NOT MZ_BZIP2 AND NOT MZ_LZMA AND NOT MZ_PPMD)
    message(STATUS "Compression not supported due to missing libraries")

    list(APPEND MINIZIP_DEF -DMZ_ZIP_NO_DECOMPRESSION)
    list(APPEND MINIZIP_DEF -DMZ_ZIP_NO_COMPRESSION)
endif()

if(MZ_OPENSSL)
    find_package(OpenSSL QUIET)

    if(OPENSSL_FOUND)
        message(STATUS "Using OpenSSL ${OPENSSL_VERSION}")

        list(APPEND MINIZIP_SRC mz_crypt_openssl.c)
        list(APPEND MINIZIP_LIB OpenSSL::SSL OpenSSL::Crypto)

        # Delegate library naming to openssl.pc for portability.
        string(APPEND PC_PRIVATE_DEPS " openssl")
    else()
        message(STATUS "OpenSSL library not found")

        set(MZ_OPENSSL OFF)
    endif()
endif()

# Platform specific
if(WIN32)
    list(APPEND MINIZIP_DEF -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
    list(APPEND MINIZIP_SRC mz_os_win32.c mz_strm_os_win32.c)

    if(MZ_PKCRYPT OR MZ_WZAES)
        if(MZ_OPENSSL)
            list(APPEND MINIZIP_DEP_PKG OpenSSL)
        else()
            # Check for existence of BCrypt API
            set(CMAKE_REQUIRED_LIBRARIES bcrypt.lib ncrypt.lib crypt32.lib)
            check_symbol_exists(BCryptGenRandom "windows.h;bcrypt.h" HAVE_BCRYPT)
            set(CMAKE_REQUIRED_LIBRARIES)
            if (HAVE_BCRYPT)
                list(APPEND MINIZIP_SRC mz_crypt_winvista.c)
                list(APPEND MINIZIP_LIB bcrypt.lib ncrypt.lib)
            endif()

            list(APPEND MINIZIP_SRC mz_crypt_winxp.c)
            list(APPEND MINIZIP_LIB crypt32.lib)
        endif()
    else()
        list(APPEND MINIZIP_DEF -DMZ_ZIP_NO_CRYPTO)
    endif()

    set(MZ_LIBBSD OFF)
    set(MZ_ICONV OFF)
else()
    list(APPEND STDLIB_DEF -D_POSIX_C_SOURCE=200809L -D_BSD_SOURCE -D_DEFAULT_SOURCE)
    list(APPEND MINIZIP_SRC mz_os_posix.c mz_strm_os_posix.c)

    if(APPLE)
        # Despite being part of POSIX 2008, macOS thinks that O_NOFOLLOW is still a non-standard extension
        list(APPEND STDLIB_DEF -D_DARWIN_C_SOURCE)
    endif()

    if(MZ_PKCRYPT OR MZ_WZAES)
        if(MZ_OPENSSL)
            list(APPEND MINIZIP_DEP_PKG OpenSSL)
        else()
            if(APPLE)
                message(STATUS "Using CoreFoundation Framework")
                message(STATUS "Using Security Framework")

                list(APPEND MINIZIP_LIB "-framework CoreFoundation" "-framework Security")

                check_include_file(CommonCrypto/CommonCrypto.h COMMONCRYPTO_FOUND)
                if(COMMONCRYPTO_FOUND)
                    message(STATUS "Using CommonCrypto")

                    list(APPEND MINIZIP_SRC mz_crypt_apple.c)

                    set(MZ_LIBBSD OFF)
                else()
                    message(STATUS "CommonCrypto library not found")

                    list(APPEND MINIZIP_DEF -DMZ_ZIP_NO_CRYPTO)

                    if(MZ_WZAES)
                        message(STATUS "WinZIP AES support requires CommonCrypto or OpenSSL")

                        set(MZ_WZAES OFF)
                    endif()
                endif()
            else()
                list(APPEND MINIZIP_DEF -DMZ_ZIP_NO_CRYPTO)

                if(MZ_WZAES)
                    message(STATUS "WinZIP AES support requires OpenSSL")

                    set(MZ_WZAES OFF)
                endif()
            endif()

            # Check to see which random generation functions we have
            check_symbol_exists("getrandom" "sys/random.h" HAVE_GETRANDOM)
            if(HAVE_GETRANDOM)
                list(APPEND MINIZIP_DEF -DHAVE_GETRANDOM)
            endif()
            check_symbol_exists("arc4random_buf" "stdlib.h" HAVE_ARC4RANDOM_BUF)
            if(HAVE_ARC4RANDOM_BUF)
                list(APPEND MINIZIP_DEF -DHAVE_ARC4RANDOM_BUF)
            else()
                check_symbol_exists("arc4random" "stdlib.h" HAVE_ARC4RANDOM)
                if(HAVE_ARC4RANDOM)
                    list(APPEND MINIZIP_DEF -DHAVE_ARC4RANDOM)
                endif()
            endif()

            if(APPLE)
                # Requires _DARWIN_C_SOURCE for arcrandom functions
                list(APPEND MINIZIP_DEF -D_DARWIN_C_SOURCE)
            endif()

            if(MZ_LIBBSD AND NOT HAVE_ARC4RANDOM_BUF)
                find_package(PkgConfig REQUIRED)

                pkg_check_modules(LIBBSD IMPORTED_TARGET GLOBAL libbsd-overlay)
                if(LIBBSD_FOUND)
                    check_library_exists("${LIBBSD_LIBRARIES}" "arc4random_buf"
                        "${LIBBSD_LIBRARY_DIRS}" HAVE_LIBBSD_ARC4RANDOM_BUF)

                    if(HAVE_LIBBSD_ARC4RANDOM_BUF)
                        list(APPEND MINIZIP_DEF -DHAVE_LIBBSD -DHAVE_ARC4RANDOM_BUF)
                        list(APPEND MINIZIP_LIB PkgConfig::LIBBSD)
                    endif()
                else()
                    set(MZ_LIBBSD OFF)
                endif()
            else()
                set(MZ_LIBBSD OFF)
            endif()

            if(NOT MZ_LIBBSD AND NOT HAVE_GETRANDOM AND NOT HAVE_ARC4RANDOM_BUF AND NOT HAVE_ARC4RANDOM)
                message(WARNING "Low quality entropy function used for encryption")
            endif()
        endif()
    else()
        list(APPEND MINIZIP_DEF -DMZ_ZIP_NO_CRYPTO)
    endif()

    # Iconv and ICU are mutually exclusive; ICU takes precedence
    if (MZ_ICU AND MZ_ICONV)
        message(STATUS "ICU enabled, disabling Iconv")
        set(MZ_ICONV OFF)
    endif()

    # Iconv is only necessary when it is not already built-in
    # FindIconv requires cmake 3.11 or higher
    if (MZ_ICONV)
        find_package(Iconv QUIET)
    endif()

    if(Iconv_FOUND)
        message(STATUS "Using Iconv")

        list(APPEND MINIZIP_DEF -DHAVE_ICONV)
        list(APPEND MINIZIP_DEP_PKG Iconv)
        if(NOT Iconv_IS_BUILT_IN)
            list(APPEND MINIZIP_LIB Iconv::Iconv)
            set(PC_PRIVATE_LIBS "${PC_PRIVATE_LIBS} -liconv")
        endif()
    else()
        message(STATUS "Character encoding support requires iconv")

        set(MZ_ICONV OFF)
    endif()

    if (MZ_ICU)
        find_package(ICU COMPONENTS uc QUIET)
    endif()

    if(ICU_FOUND)
        message(STATUS "Using ICU ${ICU_VERSION}")

        list(APPEND MINIZIP_DEF -DHAVE_ICU)
        list(APPEND MINIZIP_DEP_PKG ICU)
        list(APPEND MINIZIP_LIB ICU::uc)
        set(PC_PRIVATE_LIBS "${PC_PRIVATE_LIBS} -licuuc")
    else()
        if(MZ_ICU)
            message(STATUS "ICU library not found")
            set(MZ_ICU OFF)
        endif()
    endif()
endif()

# Setup predefined macros
if(MZ_COMPRESS_ONLY)
    list(APPEND MINIZIP_DEF -DMZ_ZIP_NO_DECOMPRESSION)
endif()
if(MZ_DECOMPRESS_ONLY)
    list(APPEND MINIZIP_DEF -DMZ_ZIP_NO_COMPRESSION)
endif()
if(NOT MZ_PKCRYPT AND NOT MZ_WZAES)
    list(APPEND MINIZIP_DEF -DMZ_ZIP_NO_ENCRYPTION)
endif()
if(MZ_FILE32_API)
    list(APPEND MINIZIP_DEF -DMZ_FILE32_API)
endif()

# Include traditional PKWare encryption
if(MZ_PKCRYPT)
    list(APPEND MINIZIP_DEF -DHAVE_PKCRYPT)
    list(APPEND MINIZIP_SRC mz_strm_pkcrypt.c)
    list(APPEND MINIZIP_HDR mz_strm_pkcrypt.h)
endif()

# Include WinZIP AES encryption
if(MZ_WZAES)
    list(APPEND MINIZIP_DEF -DHAVE_WZAES)
    list(APPEND MINIZIP_SRC mz_strm_wzaes.c)
    list(APPEND MINIZIP_HDR mz_strm_wzaes.h)
endif()

# Include compatibility layer
if(MZ_COMPAT)
    set(SOVERSION "1")

    list(APPEND MINIZIP_SRC
        compat/ioapi.c
        compat/unzip.c
        compat/zip.c)
    list(APPEND MINIZIP_HDR
        compat/crypt.h
        compat/ioapi.h
        compat/unzip.h
        compat/zip.h)

    if(MZ_COMPAT_VERSION)
        list(APPEND MINIZIP_DEF -DMZ_COMPAT_VERSION=${MZ_COMPAT_VERSION})
    endif()
endif()

#
# Check whether a sanitizer was requested
#
message(STATUS "Checking for sanitizer option")

string(TOLOWER "${MZ_SANITIZER}" MZ_SANITIZER)
if(NOT MZ_SANITIZER)
    message(STATUS " sanitizer not enabled")
elseif(MZ_SANITIZER STREQUAL "address")
    add_address_sanitizer()
elseif(MZ_SANITIZER STREQUAL "memory")
    add_memory_sanitizer()
elseif(MZ_SANITIZER STREQUAL "thread")
    add_thread_sanitizer()
elseif(MZ_SANITIZER STREQUAL "undefined")
    add_undefined_sanitizer()
else()
    message(FATAL_ERROR "Unknown MZ_SANITIZER option: '${MZ_SANITIZER}'\n"
                        "MZ_SANITIZER must be one of: 'memory', 'address', 'undefined', 'thread'")
endif()

# Set compiler options
if(MZ_CODE_COVERAGE)
    if(NOT MSVC)
        message(STATUS "Code coverage enabled")
        add_compile_options(-O0 -g -fprofile-arcs -ftest-coverage)
        if(CMAKE_C_COMPILER_ID MATCHES "(Apple)?[Cc]lang")
            set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
        elseif(CMAKE_C_COMPILER_ID MATCHES "GNU")
            link_libraries(gcov)
        endif()
        set_property(DIRECTORY PROPERTY
            GCC_INSTRUMENT_PROGRAM_FLOW_ARCS YES
            GCC_GENERATE_TEST_COVERAGE_FILES YES)
    else()
        set(MZ_CODE_COVERAGE OFF)
    endif()
else()
    if(MSVC)
        add_compile_options($<$<CONFIG:Debug>:/W3>)
    else()
        add_compile_options($<$<CONFIG:Debug>:-Wall>)
    endif()
endif()

set(MINIZIP_TARGET minizip${MZ_LIB_SUFFIX})
set(MINIZIP_PC ${CMAKE_CURRENT_BINARY_DIR}/${MINIZIP_TARGET}.pc)
configure_file(minizip.pc.cmakein ${MINIZIP_PC} @ONLY)

# Create minizip library and aliases
add_library(${MINIZIP_TARGET} ${MINIZIP_SRC} ${MINIZIP_HDR})
add_library(MINIZIP::${MINIZIP_TARGET} ALIAS ${MINIZIP_TARGET})
if(NOT TARGET MINIZIP::minizip)
    add_library(MINIZIP::minizip ALIAS ${MINIZIP_TARGET})
endif()

set_target_properties(${MINIZIP_TARGET} PROPERTIES
                      VERSION ${VERSION}
                      SOVERSION ${SOVERSION}
                      LINKER_LANGUAGE C
                      DEFINE_SYMBOL "MZ_EXPORTS")

if(MINIZIP_LFG)
    target_link_options(${MINIZIP_TARGET} PRIVATE ${MINIZIP_LFG})
endif()
if(MZ_LZMA)
    set_target_properties(${MINIZIP_TARGET} PROPERTIES C_STANDARD 99)
endif()

target_link_libraries(${MINIZIP_TARGET} PRIVATE ${MINIZIP_LIB} ${MINIZIP_DEP})
if(MZ_COMPAT)
    # MZ_COMPAT exposes zlib in public headers.
    target_link_libraries(${MINIZIP_TARGET} PUBLIC ${MINIZIP_LIB_PUBLIC})
else()
    target_link_libraries(${MINIZIP_TARGET} PRIVATE ${MINIZIP_LIB_PUBLIC})
endif()
target_compile_definitions(${MINIZIP_TARGET} PRIVATE ${STDLIB_DEF} ${MINIZIP_DEF})
target_include_directories(${MINIZIP_TARGET} PRIVATE ${MINIZIP_INC})
target_include_directories(${MINIZIP_TARGET} PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
if(MZ_COMPAT)
    target_include_directories(${MINIZIP_TARGET} PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/compat/>)
endif()

# Install files
if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL)
    target_include_directories(${MINIZIP_TARGET} PUBLIC
        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${MINIZIP_TARGET}>)

    # Resolve alias targets to their real targets for installation
    set(MINIZIP_DEP_REAL)
    foreach(dep_target ${MINIZIP_DEP})
        get_target_property(alias_target ${dep_target} ALIASED_TARGET)
        if(alias_target)
            list(APPEND MINIZIP_DEP_REAL ${alias_target})
        else()
            list(APPEND MINIZIP_DEP_REAL ${dep_target})
        endif()
    endforeach()

    install(TARGETS ${MINIZIP_TARGET} ${MINIZIP_DEP_REAL}
            EXPORT ${MINIZIP_TARGET}-targets
            INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${MINIZIP_TARGET}"
            RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
            ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
            LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
    install(EXPORT ${MINIZIP_TARGET}-targets
            DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${MINIZIP_TARGET}"
            NAMESPACE "MINIZIP::")

    # Create and install CMake package config version file to allow find_package()
    include(CMakePackageConfigHelpers)
    write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${MINIZIP_TARGET}-config-version.cmake
        COMPATIBILITY SameMajorVersion)
    set(MINIZIP_CONFIG_CONTENT "@PACKAGE_INIT@\n")
    if(MINIZIP_DEP_PKG_PUBLIC OR (MINIZIP_DEP_PKG AND NOT BUILD_SHARED_LIBS))
        string(APPEND MINIZIP_CONFIG_CONTENT "include(CMakeFindDependencyMacro)\n")
        foreach(pkg_name ${MINIZIP_DEP_PKG_PUBLIC})
            string(APPEND MINIZIP_CONFIG_CONTENT "find_dependency(${pkg_name})\n")
        endforeach()
        # PRIVATE-linked deps are encapsulated in the shared library; consumers
        # of a static minizip still need them to satisfy transitive symbols.
        if(NOT BUILD_SHARED_LIBS)
            foreach(pkg_name ${MINIZIP_DEP_PKG})
                string(APPEND MINIZIP_CONFIG_CONTENT "find_dependency(${pkg_name})\n")
            endforeach()
        endif()
    endif()
    string(APPEND MINIZIP_CONFIG_CONTENT "include(\"\${CMAKE_CURRENT_LIST_DIR}/${MINIZIP_TARGET}-targets.cmake\")")
    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/minizip-config.cmake.in ${MINIZIP_CONFIG_CONTENT})

    # Create config for find_package()
    configure_package_config_file(
        ${CMAKE_CURRENT_BINARY_DIR}/minizip-config.cmake.in
        ${MINIZIP_TARGET}-config.cmake
        INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${MINIZIP_TARGET}")

    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${MINIZIP_TARGET}-config-version.cmake
                  ${CMAKE_CURRENT_BINARY_DIR}/${MINIZIP_TARGET}-config.cmake
            DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${MINIZIP_TARGET}")
endif()
if(NOT SKIP_INSTALL_HDR AND NOT SKIP_INSTALL_ALL)
    install(FILES ${MINIZIP_HDR} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${MINIZIP_TARGET}")
endif()
if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL)
    install(FILES ${MINIZIP_PC} DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
endif()

# Build test executables
if(MZ_BUILD_TESTS)
    if(MZ_ZLIB AND NOT MZ_LIBCOMP)
        add_executable(minigzip_cli minigzip.c)
        set_target_properties(minigzip_cli PROPERTIES OUTPUT_NAME minigzip)
        target_compile_definitions(minigzip_cli PRIVATE ${STDLIB_DEF} ${MINIZIP_DEF})
        target_link_libraries(minigzip_cli ${MINIZIP_TARGET})

        if(NOT SKIP_INSTALL_BINARIES AND NOT SKIP_INSTALL_ALL)
            install(TARGETS minigzip_cli RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
        endif()
    endif()

    add_executable(minizip_cli minizip.c)

    if(MSVC AND MZ_COMPAT AND CMAKE_BUILD_TYPE MATCHES "Debug|RelWithDebInfo")
        # VS debugger has problems when executable and static library are named the same
        set_target_properties(minizip_cli PROPERTIES OUTPUT_NAME minizip_cli)
    else()
        set_target_properties(minizip_cli PROPERTIES OUTPUT_NAME minizip)
    endif()

    target_compile_definitions(minizip_cli PRIVATE ${STDLIB_DEF} ${MINIZIP_DEF})
    target_link_libraries(minizip_cli ${MINIZIP_TARGET})
    if(WIN32)
        set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT minizip_cli)
    endif()

    if(NOT SKIP_INSTALL_BINARIES AND NOT SKIP_INSTALL_ALL)
        install(TARGETS minizip_cli RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
    endif()
endif()

if(MZ_BUILD_TESTS AND MZ_BUILD_UNIT_TESTS)
    enable_testing()

    add_subdirectory(test)

    # Can't disable zlib testing so ctest tries to run zlib example app
    if(MZ_ZLIB AND NOT MZ_LIBCOMP AND NOT ZLIB_FOUND)
        if(TARGET example)
            target_include_directories(example PRIVATE ${ZLIB_SOURCE_DIR})
            add_dependencies(${MINIZIP_TARGET} example)
        endif()
        if(TARGET example64)
            target_include_directories(example64 PRIVATE ${ZLIB_SOURCE_DIR})
            add_dependencies(${MINIZIP_TARGET} example64)
        endif()
    endif()

    set(TEST_TEMP_DIR ${CMAKE_CURRENT_BINARY_DIR}/Testing/Temporary)

    function(create_compress_tests EXTRA_NAME EXTRA_ARGS)
        if(MZ_DECOMPRESS_ONLY)
            return()
        endif()
        list(FIND EXTRA_ARGS "-z" ZIPCD_IDX)
        if(${ZIPCD_IDX} EQUAL -1)
            set(COMPRESS_METHOD_NAMES "raw")
            set(COMPRESS_METHOD_ARGS "-0")
        endif()
        if(MZ_ZLIB OR MZ_LIBCOMP)
            list(APPEND COMPRESS_METHOD_NAMES "deflate")
            list(APPEND COMPRESS_METHOD_ARGS "-9")
        endif()
        if(MZ_BZIP2)
            list(APPEND COMPRESS_METHOD_NAMES "bzip2")
            list(APPEND COMPRESS_METHOD_ARGS "-b")
        endif()
        if(MZ_LZMA)
            list(APPEND COMPRESS_METHOD_NAMES "lzma")
            list(APPEND COMPRESS_METHOD_ARGS "-m")
        endif()
        if(MZ_LZMA OR MZ_LIBCOMP)
            list(APPEND COMPRESS_METHOD_NAMES "xz")
            list(APPEND COMPRESS_METHOD_ARGS "-n")
        endif()
        if(MZ_PPMD)
            list(APPEND COMPRESS_METHOD_NAMES "ppmd")
            list(APPEND COMPRESS_METHOD_ARGS "-g")
        endif()
        if(MZ_ZSTD)
            list(APPEND COMPRESS_METHOD_NAMES "zstd")
            list(APPEND COMPRESS_METHOD_ARGS "-t")
        endif()
        list(LENGTH COMPRESS_METHOD_NAMES COMPRESS_METHOD_COUNT)
        math(EXPR COMPRESS_METHOD_COUNT "${COMPRESS_METHOD_COUNT}-1")
        foreach(INDEX RANGE ${COMPRESS_METHOD_COUNT})
            list(GET COMPRESS_METHOD_NAMES ${INDEX} COMPRESS_METHOD_NAME)
            list(GET COMPRESS_METHOD_ARGS ${INDEX} COMPRESS_METHOD_ARG)

            set(COMPRESS_METHOD_DEST_DIR
                ${TEST_TEMP_DIR}/${COMPRESS_METHOD_NAME}-${EXTRA_NAME})
            set(COMPRESS_METHOD_PATH
                ${TEST_TEMP_DIR}/${COMPRESS_METHOD_NAME}-${EXTRA_NAME}.zip)

            add_test(NAME ${COMPRESS_METHOD_NAME}-zip-${EXTRA_NAME}
                     COMMAND minizip_cli ${COMPRESS_METHOD_ARG} -o ${EXTRA_ARGS}
                        ${COMPRESS_METHOD_PATH}
                        test.c test.h empty.txt random.bin uniform.bin fuzz
                     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
            add_test(NAME ${COMPRESS_METHOD_NAME}-list-${EXTRA_NAME}
                     COMMAND minizip_cli -l ${EXTRA_ARGS} ${COMPRESS_METHOD_PATH}
                     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
            if(NOT MZ_COMPRESS_ONLY)
                add_test(NAME ${COMPRESS_METHOD_NAME}-unzip-${EXTRA_NAME}
                         COMMAND minizip_cli -x -o ${EXTRA_ARGS}
                            -d ${COMPRESS_METHOD_DEST_DIR} ${COMPRESS_METHOD_PATH}
                         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
            endif()
            add_test(NAME ${COMPRESS_METHOD_NAME}-append-${EXTRA_NAME}
                    COMMAND minizip_cli ${COMPRESS_METHOD_ARG} -a ${EXTRA_ARGS}
                        ${COMPRESS_METHOD_PATH} single.txt
                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
            if(NOT MZ_COMPRESS_ONLY)
                add_test(NAME ${COMPRESS_METHOD_NAME}-append-unzip-${EXTRA_NAME}
                            COMMAND minizip_cli -x -o ${EXTRA_ARGS}
                                -d ${COMPRESS_METHOD_DEST_DIR} ${COMPRESS_METHOD_PATH}
                            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
            endif()
            add_test(NAME ${COMPRESS_METHOD_NAME}-erase-${EXTRA_NAME}
                    COMMAND minizip_cli -o -e ${COMPRESS_METHOD_PATH} test.c test.h
                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
            if(NOT MZ_COMPRESS_ONLY)
                add_test(NAME ${COMPRESS_METHOD_NAME}-erase-unzip-${EXTRA_NAME}
                         COMMAND minizip_cli -x -o ${EXTRA_ARGS}
                            -d ${COMPRESS_METHOD_DEST_DIR} ${COMPRESS_METHOD_PATH}
                         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
            endif()
        endforeach()
    endfunction()

    # Perform tests against ourself
    create_compress_tests("generic" "")
    create_compress_tests("span" "-k;1024")
    create_compress_tests("zipcd" "-z")
    if(MZ_PKCRYPT)
        create_compress_tests("pkcrypt" "-p;test123")
    endif()
    if(MZ_WZAES)
        create_compress_tests("wzaes" "-s;-p;test123")
    endif()

    # Perform tests on others
    if(NOT MZ_COMPRESS_ONLY)
        if(MZ_ZLIB OR MZ_LIBCOMP)
            add_test(NAME unzip-tiny
                     COMMAND minizip_cli -x -o ${EXTRA_ARGS}
                        -d ${TEST_TEMP_DIR}/unzip-tiny
                        fuzz/unzip_fuzzer_seed_corpus/tiny.zip
                     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
        endif()
        if(MZ_BZIP2)
            add_test(NAME unzip-bzip2
                     COMMAND minizip_cli -x -o ${EXTRA_ARGS}
                        -d ${TEST_TEMP_DIR}/unzip-bzip2
                        fuzz/unzip_fuzzer_seed_corpus/bzip2.zip
                     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
        endif()
        if(MZ_LZMA)
            add_test(NAME unzip-lzma
                     COMMAND minizip_cli -x -o ${EXTRA_ARGS}
                        -d ${TEST_TEMP_DIR}/unzip-lzma
                        fuzz/unzip_fuzzer_seed_corpus/lzma.zip
                     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
        endif()
        if(MZ_PKCRYPT)
            add_test(NAME unzip-pkcrypt
                     COMMAND minizip_cli -x -o ${EXTRA_ARGS}
                        -d ${TEST_TEMP_DIR}/unzip-pkcrypt -p test123
                        fuzz/unzip_fuzzer_seed_corpus/encrypted_pkcrypt.zip
                     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
        endif()
        if(MZ_WZAES)
            add_test(NAME unzip-wzaes
                     COMMAND minizip_cli -x -o ${EXTRA_ARGS}
                        -d ${TEST_TEMP_DIR}/unzip-wzaes -p test123
                        fuzz/unzip_fuzzer_seed_corpus/encrypted_wzaes.zip
                     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/test)
        endif()
    endif()
    if(NOT MZ_COMPRESS_ONLY AND NOT MZ_DECOMPRESS_ONLY)
        if(MZ_ZLIB AND NOT MZ_LIBCOMP)
            file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/test/random.bin DESTINATION ${TEST_TEMP_DIR})
            add_test(NAME gz
                COMMAND minigzip_cli random.bin
                WORKING_DIRECTORY ${TEST_TEMP_DIR})
            add_test(NAME ungz
                COMMAND minigzip_cli -x -d ${TEST_TEMP_DIR} random.bin.gz
                WORKING_DIRECTORY ${TEST_TEMP_DIR})
        endif()
    endif()
endif()

#Build fuzzer executables
if(MZ_BUILD_FUZZ_TESTS)
    if(CMAKE_C_COMPILER_ID MATCHES "Clang")
        enable_language(CXX)

        if(DEFINED ENV{LIB_FUZZING_ENGINE})
            set(FUZZING_ENGINE $ENV{LIB_FUZZING_ENGINE})
            set(FUZZING_ENGINE_FOUND TRUE)
        else()
            find_library(FUZZING_ENGINE "FuzzingEngine")
        endif()
    endif()

    if(NOT FUZZING_ENGINE_FOUND)
        set(FUZZER_SRC "test/fuzz/standalone.c")
    else()
        set(FUZZER_SRC)
    endif()

    macro(configure_fuzz_test target)
        add_executable(${target} "test/fuzz/${target}.c" ${FUZZER_SRC})
        set_target_properties(${target} PROPERTIES LINKER_LANGUAGE CXX)
        target_compile_definitions(${target} PRIVATE ${STDLIB_DEF})
        target_link_libraries(${target} ${MINIZIP_TARGET})

        if(FUZZING_ENGINE_FOUND)
            target_link_libraries(${target} ${FUZZING_ENGINE})
        endif()
    endmacro()

    configure_fuzz_test(zip_fuzzer)
    configure_fuzz_test(unzip_fuzzer)

    if(NOT SKIP_INSTALL_BINARIES AND NOT SKIP_INSTALL_ALL)
        install(TARGETS zip_fuzzer RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
        install(TARGETS unzip_fuzzer RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
    endif()
endif()

# Compatibility options
add_feature_info(MZ_COMPAT MZ_COMPAT "Enables compatibility layer")
# Compression library options
add_feature_info(MZ_ZLIB MZ_ZLIB "Enables ZLIB compression")
add_feature_info(MZ_BZIP2 MZ_BZIP2 "Enables BZIP2 compression")
add_feature_info(MZ_LZMA MZ_LZMA "Enables LZMA & XZ compression")
add_feature_info(MZ_PPMD MZ_PPMD "Enables PPMD compression")
add_feature_info(MZ_ZSTD MZ_ZSTD "Enables ZSTD compression")
add_feature_info(MZ_LIBCOMP MZ_LIBCOMP "Enables Apple compression")
add_feature_info(MZ_FETCH_LIBS MZ_FETCH_LIBS "Enables fetching third-party libraries if not found")
add_feature_info(MZ_FORCE_FETCH_LIBS MZ_FORCE_FETCH_LIBS "Enables fetching third-party libraries always")
# Encryption support options
add_feature_info(MZ_PKCRYPT MZ_PKCRYPT "Enables PKWARE traditional encryption")
add_feature_info(MZ_WZAES MZ_WZAES "Enables WinZIP AES encryption")
add_feature_info(MZ_OPENSSL MZ_OPENSSL "Enables OpenSSL for encryption")
add_feature_info(MZ_LIBBSD MZ_LIBBSD "Builds with libbsd crypto random")
# Character conversion options
add_feature_info(MZ_ICONV MZ_ICONV "Enables iconv string encoding conversion library")
add_feature_info(MZ_ICU MZ_ICU "Enables ICU string encoding conversion library")
# Code generation options
add_feature_info(MZ_COMPRESS_ONLY MZ_COMPRESS_ONLY "Only support compression")
add_feature_info(MZ_DECOMPRESS_ONLY MZ_DECOMPRESS_ONLY "Only support decompression")
add_feature_info(MZ_FILE32_API MZ_FILE32_API "Builds using posix 32-bit file api")
# Build and continuous integration options
add_feature_info(MZ_BUILD_TESTS MZ_BUILD_TESTS "Builds minizip test executable")
add_feature_info(MZ_BUILD_UNIT_TESTS MZ_BUILD_UNIT_TESTS "Builds minizip unit test project")
add_feature_info(MZ_BUILD_FUZZ_TESTS MZ_BUILD_FUZZ_TESTS "Builds minizip fuzzer executables")
add_feature_info(MZ_CODE_COVERAGE MZ_CODE_COVERAGE "Builds with code coverage flags")
add_feature_info(MZ_SANITIZER MZ_SANITIZER "Enable sanitizer testing support")

feature_summary(WHAT ENABLED_FEATURES DISABLED_FEATURES INCLUDE_QUIET_PACKAGES)