cmake_minimum_required(VERSION 3.18.1)

# Project configuration
project(VavCoreTextureBindingTest)

# Set C++ standard
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Android configuration (must be Android)
if(NOT ANDROID)
    message(FATAL_ERROR "This CMakeLists.txt is for Android builds only")
endif()

# Minimum API level for comprehensive graphics support
set(ANDROID_NATIVE_API_LEVEL 29)

# Configure Android-specific settings
set(CMAKE_ANDROID_API_MIN ${ANDROID_NATIVE_API_LEVEL})
set(CMAKE_ANDROID_GUI FALSE)

message(STATUS "Building VavCore Texture Binding Test for Android API ${ANDROID_NATIVE_API_LEVEL}")

# Android-specific compiler flags
add_compile_definitions(ANDROID)

# Test app source directory (relative to this CMakeLists.txt)
set(TEST_ROOT ${CMAKE_CURRENT_SOURCE_DIR})

# Include directories
include_directories(
    ${TEST_ROOT}/src
    ${CMAKE_CURRENT_SOURCE_DIR}/../../vavcore/include
    ${CMAKE_CURRENT_SOURCE_DIR}/../../vavcore/src
)

# Add project-wide include directories if provided
if(DEFINED PROJECT_INCLUDE_DIR)
    include_directories(${PROJECT_INCLUDE_DIR})
    message(STATUS "Added project include directory: ${PROJECT_INCLUDE_DIR}")
else()
    # Default fallback to parent directory include
    get_filename_component(PARENT_DIR ${CMAKE_CURRENT_SOURCE_DIR} DIRECTORY)
    get_filename_component(PARENT_DIR ${PARENT_DIR} DIRECTORY)
    get_filename_component(PARENT_DIR ${PARENT_DIR} DIRECTORY)
    get_filename_component(PARENT_DIR ${PARENT_DIR} DIRECTORY)
    get_filename_component(PROJECT_ROOT ${PARENT_DIR} DIRECTORY)
    set(FALLBACK_INCLUDE_DIR "${PROJECT_ROOT}/include")
    if(EXISTS ${FALLBACK_INCLUDE_DIR})
        include_directories(${FALLBACK_INCLUDE_DIR})
        message(STATUS "Using fallback include directory: ${FALLBACK_INCLUDE_DIR}")
    endif()
endif()

# Test app source files
set(TEST_SOURCES
    ${TEST_ROOT}/src/main.cpp
    ${TEST_ROOT}/src/OpenGLESTextureTest.cpp
    ${TEST_ROOT}/src/VulkanImageTest.cpp
    ${TEST_ROOT}/src/TestFramework.cpp
)

# Find required Android libraries
find_library(log-lib log)
find_library(android-lib android)
find_library(egl-lib EGL)
find_library(gles3-lib GLESv3)

if(NOT log-lib)
    message(FATAL_ERROR "Android log library not found")
endif()

if(NOT android-lib)
    message(FATAL_ERROR "Android library not found")
endif()

if(NOT egl-lib)
    message(FATAL_ERROR "EGL library not found")
endif()

if(NOT gles3-lib)
    message(FATAL_ERROR "OpenGL ES 3.0 library not found")
endif()

# Android system libraries
set(TEST_ANDROID_LIBS
    ${log-lib}        # Android logging
    ${android-lib}    # Android framework
    ${egl-lib}        # EGL for OpenGL ES context
    ${gles3-lib}      # OpenGL ES 3.0
)

# Import VavCore library
set(VAVCORE_LIB_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../vavcore/lib/android-${ANDROID_ABI}/libVavCore.so")
if(NOT EXISTS ${VAVCORE_LIB_PATH})
    message(FATAL_ERROR "VavCore library not found: ${VAVCORE_LIB_PATH}")
endif()

add_library(VavCore SHARED IMPORTED)
set_target_properties(VavCore PROPERTIES
    IMPORTED_LOCATION ${VAVCORE_LIB_PATH}
)

message(STATUS "VavCore library path: ${VAVCORE_LIB_PATH}")

# Import dav1d library
if(DEFINED DAV1D_LIBRARY_DIR)
    set(DAV1D_LIB_PATH "${DAV1D_LIBRARY_DIR}/libdav1d.so")
else()
    # Use project lib directory
    if(DEFINED FALLBACK_INCLUDE_DIR)
        get_filename_component(PROJECT_ROOT ${FALLBACK_INCLUDE_DIR} DIRECTORY)
        set(DAV1D_LIB_PATH "${PROJECT_ROOT}/lib/android-${ANDROID_ABI}/dav1d/libdav1d.so")
    else()
        set(DAV1D_LIB_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../lib/android-${ANDROID_ABI}/dav1d/libdav1d.so")
    endif()
endif()

if(EXISTS ${DAV1D_LIB_PATH})
    add_library(dav1d SHARED IMPORTED)
    set_target_properties(dav1d PROPERTIES
        IMPORTED_LOCATION ${DAV1D_LIB_PATH}
    )
    message(STATUS "dav1d library path: ${DAV1D_LIB_PATH}")
    set(DAV1D_AVAILABLE TRUE)
else()
    message(WARNING "dav1d library not found at: ${DAV1D_LIB_PATH}")
    set(DAV1D_AVAILABLE FALSE)
endif()

# Import libwebm library
if(DEFINED LIBWEBM_LIBRARY_DIR)
    set(LIBWEBM_LIB_PATH "${LIBWEBM_LIBRARY_DIR}/libwebm.a")
else()
    # Use project lib directory
    if(DEFINED FALLBACK_INCLUDE_DIR)
        get_filename_component(PROJECT_ROOT ${FALLBACK_INCLUDE_DIR} DIRECTORY)
        set(LIBWEBM_LIB_PATH "${PROJECT_ROOT}/lib/android-${ANDROID_ABI}/libwebm/libwebm.a")
    else()
        set(LIBWEBM_LIB_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../lib/android-${ANDROID_ABI}/libwebm/libwebm.a")
    endif()
endif()

if(EXISTS ${LIBWEBM_LIB_PATH})
    add_library(webm STATIC IMPORTED)
    set_target_properties(webm PROPERTIES
        IMPORTED_LOCATION ${LIBWEBM_LIB_PATH}
    )
    message(STATUS "libwebm library path: ${LIBWEBM_LIB_PATH}")
    set(LIBWEBM_AVAILABLE TRUE)
else()
    message(WARNING "libwebm library not found at: ${LIBWEBM_LIB_PATH}")
    set(LIBWEBM_AVAILABLE FALSE)
endif()

# Create the test executable
add_executable(VavCoreTextureBindingTest ${TEST_SOURCES})

# Link libraries
set(TEST_LINK_LIBS ${TEST_ANDROID_LIBS} VavCore)

if(DAV1D_AVAILABLE)
    list(APPEND TEST_LINK_LIBS dav1d)
    message(STATUS "Linking with dav1d")
endif()

if(LIBWEBM_AVAILABLE)
    list(APPEND TEST_LINK_LIBS webm)
    message(STATUS "Linking with libwebm")
endif()

target_link_libraries(VavCoreTextureBindingTest ${TEST_LINK_LIBS})

# Set Android-specific properties
set_target_properties(VavCoreTextureBindingTest PROPERTIES
    ANDROID_API_MIN ${ANDROID_NATIVE_API_LEVEL}
    ANDROID_GUI FALSE
)

# Compiler-specific flags
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    target_compile_options(VavCoreTextureBindingTest PRIVATE
        -Wall
        -Wextra
        -Wno-unused-parameter
        -Wno-missing-field-initializers
    )
endif()

# Debug/Release specific flags
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
    target_compile_definitions(VavCoreTextureBindingTest PRIVATE DEBUG=1)
    message(STATUS "Building VavCore Texture Binding Test in Debug mode")
else()
    target_compile_definitions(VavCoreTextureBindingTest PRIVATE NDEBUG=1)
    target_compile_options(VavCoreTextureBindingTest PRIVATE -O3)
    message(STATUS "Building VavCore Texture Binding Test in Release mode")
endif()

# Install the test executable
install(TARGETS VavCoreTextureBindingTest
    RUNTIME DESTINATION bin
)

# Display configuration summary
message(STATUS "=== VavCore Texture Binding Test Configuration ===")
message(STATUS "Platform: ${CMAKE_SYSTEM_NAME}")
message(STATUS "Architecture: ${CMAKE_SYSTEM_PROCESSOR}")
message(STATUS "C++ Standard: ${CMAKE_CXX_STANDARD}")
message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}")
message(STATUS "Android API Level: ${ANDROID_NATIVE_API_LEVEL}")
message(STATUS "Android NDK: ${ANDROID_NDK}")
message(STATUS "Test Root: ${TEST_ROOT}")
message(STATUS "VavCore Available: YES")
message(STATUS "dav1d Available: ${DAV1D_AVAILABLE}")
message(STATUS "libwebm Available: ${LIBWEBM_AVAILABLE}")
message(STATUS "================================================")