################################################################################
# CUDA Configuration Functions
# Functions for CUDA-specific build configuration and optimization
################################################################################

# Enhanced CUDA toolkit detection with proper include path setup
function(setup_cuda_toolkit_paths)
    message(STATUS "🔍 Setting up CUDA toolkit paths...")

    # Find CUDA toolkit first
    find_package(CUDAToolkit REQUIRED)

    if(NOT CUDAToolkit_FOUND)
        message(FATAL_ERROR "CUDA toolkit not found. Please install CUDA toolkit or set CUDA_PATH environment variable.")
    endif()

    # Get CUDA include directories
    get_target_property(CUDA_INCLUDE_DIRS CUDA::toolkit INTERFACE_INCLUDE_DIRECTORIES)

    # If the above doesn't work, try alternative methods
    if(NOT CUDA_INCLUDE_DIRS)
        set(CUDA_INCLUDE_DIRS "${CUDAToolkit_INCLUDE_DIRS}")
    endif()

    # Still not found? Try environment variables and common paths
    if(NOT CUDA_INCLUDE_DIRS)
        set(CUDA_SEARCH_PATHS
                $ENV{CUDA_PATH}
                $ENV{CUDA_HOME}
                $ENV{CUDA_ROOT}
                ${CUDAToolkit_ROOT}
        )

        if(WIN32)
            list(APPEND CUDA_SEARCH_PATHS
                    "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.6"
                    "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.5"
                    "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.4"
                    "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.3"
                    "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.2"
                    "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.1"
                    "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.0"
                    "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v11.8"
                    "C:/tools/cuda"
            )
        else()
            list(APPEND CUDA_SEARCH_PATHS
                    /usr/local/cuda
                    /opt/cuda
                    /usr/cuda
            )
        endif()

        foreach(search_path ${CUDA_SEARCH_PATHS})
            if(EXISTS "${search_path}/include/cuda.h")
                set(CUDA_INCLUDE_DIRS "${search_path}/include")
                message(STATUS "✅ Found CUDA include directory: ${CUDA_INCLUDE_DIRS}")
                break()
            endif()
        endforeach()
    endif()

    # Verify we found CUDA headers
    if(NOT CUDA_INCLUDE_DIRS)
        message(FATAL_ERROR "❌ CUDA include directories not found. Please ensure CUDA toolkit is properly installed.")
    endif()

    # Verify cuda.h exists
    set(CUDA_H_FOUND FALSE)
    foreach(include_dir ${CUDA_INCLUDE_DIRS})
        if(EXISTS "${include_dir}/cuda.h")
            set(CUDA_H_FOUND TRUE)
            message(STATUS "✅ Found cuda.h in: ${include_dir}")
            break()
        endif()
    endforeach()

    if(NOT CUDA_H_FOUND)
        message(FATAL_ERROR "❌ cuda.h not found in CUDA include directories: ${CUDA_INCLUDE_DIRS}")
    endif()

    # Set variables for parent scope
    set(CUDA_INCLUDE_DIRS "${CUDA_INCLUDE_DIRS}" PARENT_SCOPE)
    set(CUDA_TOOLKIT_ROOT_DIR "${CUDAToolkit_ROOT}" PARENT_SCOPE)

    message(STATUS "✅ CUDA toolkit paths configured:")
    message(STATUS "   Root: ${CUDAToolkit_ROOT}")
    message(STATUS "   Include: ${CUDA_INCLUDE_DIRS}")
    message(STATUS "   Version: ${CUDAToolkit_VERSION}")
endfunction()

# Modern cuDNN detection using updated FindCUDNN.cmake practices
function(setup_modern_cudnn)
    set(HAVE_CUDNN FALSE PARENT_SCOPE)

    if(NOT (HELPERS_cudnn AND SD_CUDA))
        message(STATUS "🔍 cuDNN: Skipped (HELPERS_cudnn=${HELPERS_cudnn}, SD_CUDA=${SD_CUDA})")
        return()
    endif()

    message(STATUS "🔍 Searching for cuDNN...")

    # Find the CUDA toolkit first to get the proper paths
    find_package(CUDAToolkit REQUIRED)

    # Enhanced search paths for CI environments and common installations
    set(CUDNN_SEARCH_PATHS
            # Environment variables
            $ENV{CUDNN_ROOT_DIR}
            $ENV{CUDNN_ROOT}
            $ENV{CUDA_PATH}
            $ENV{CUDA_HOME}

            # CMake variables
            ${CUDNN_ROOT_DIR}
            ${CUDAToolkit_ROOT}
    )

    # Add platform-specific paths
    if(WIN32)
        # Windows-specific paths
        list(APPEND CUDNN_SEARCH_PATHS
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.6"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.5"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.4"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.3"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.2"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.1"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v12.0"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v11.8"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v11.7"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v11.6"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v11.5"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v11.4"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v11.3"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v11.2"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v11.1"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA/v11.0"
                "$ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit/CUDA"
                "C:/tools/cuda" # Common CI path on Windows
        )
    else()
        # Linux/Unix-specific paths
        list(APPEND CUDNN_SEARCH_PATHS
                # CI-specific paths (GitHub Actions, etc.)
                /usr/local/cuda-12.6
                /usr/local/cuda-12.5
                /usr/local/cuda-12.4
                /usr/local/cuda-12.3
                /usr/local/cuda-12.2
                /usr/local/cuda-12.1
                /usr/local/cuda-12.0
                /usr/local/cuda-11.8
                /usr/local/cuda-11.7
                /usr/local/cuda-11.6
                /usr/local/cuda-11.5
                /usr/local/cuda-11.4
                /usr/local/cuda-11.3
                /usr/local/cuda-11.2
                /usr/local/cuda-11.1
                /usr/local/cuda-11.0
                /usr/local/cuda

                # Package manager paths
                /usr/include/cudnn
                /usr/local/include/cudnn
                /opt/cuda
                /opt/cudnn

                # System paths
                /usr
                /usr/local
        )
    endif()

    message(STATUS "🔍 Searching for cuDNN headers...")

    # Search for cuDNN headers with comprehensive path coverage
    find_path(CUDNN_INCLUDE_DIR
            NAMES cudnn.h
            HINTS ${CUDNN_SEARCH_PATHS}
            PATHS ${CUDNN_SEARCH_PATHS}
            PATH_SUFFIXES
            include
            targets/x86_64-linux/include
            targets/aarch64-linux/include
            include/cudnn
            cudnn/include
            x86_64-linux/include
            aarch64-linux/include
            NO_DEFAULT_PATH
    )

    # If not found, try system paths
    if(NOT CUDNN_INCLUDE_DIR)
        find_path(CUDNN_INCLUDE_DIR
                NAMES cudnn.h
                PATHS /usr/include /usr/local/include /opt/include
                PATH_SUFFIXES cudnn
        )
    endif()

    message(STATUS "🔍 Searching for cuDNN libraries...")

    # Search for cuDNN libraries
    find_library(CUDNN_LIBRARY
            NAMES cudnn libcudnn cudnn8 libcudnn8
            HINTS ${CUDNN_SEARCH_PATHS}
            PATHS ${CUDNN_SEARCH_PATHS}
            PATH_SUFFIXES
            lib64
            lib
            lib/x64
            targets/x86_64-linux/lib
            targets/aarch64-linux/lib
            lib64/cudnn
            lib/cudnn
            cudnn/lib64
            cudnn/lib
            x86_64-linux/lib
            aarch64-linux/lib
            NO_DEFAULT_PATH
    )

    # If not found, try system paths
    if(NOT CUDNN_LIBRARY)
        find_library(CUDNN_LIBRARY
                NAMES cudnn libcudnn cudnn8 libcudnn8
                PATHS /usr/lib64 /usr/lib /usr/local/lib64 /usr/local/lib /opt/lib64 /opt/lib
                PATH_SUFFIXES cudnn
        )
    endif()

    message(STATUS "🔍 cuDNN search results:")
    message(STATUS "   CUDNN_INCLUDE_DIR: ${CUDNN_INCLUDE_DIR}")
    message(STATUS "   CUDNN_LIBRARY: ${CUDNN_LIBRARY}")

    # Check if we found both header and library
    if(CUDNN_INCLUDE_DIR AND CUDNN_LIBRARY)
        message(STATUS "✅ cuDNN found!")

        # Extract version information from cudnn.h
        if(EXISTS "${CUDNN_INCLUDE_DIR}/cudnn.h")
            file(READ "${CUDNN_INCLUDE_DIR}/cudnn.h" CUDNN_HEADER_CONTENTS)

            # Try different version detection methods
            string(REGEX MATCH "define CUDNN_MAJOR[ \t]+([0-9]+)" CUDNN_VERSION_MAJOR_MATCH "${CUDNN_HEADER_CONTENTS}")
            string(REGEX MATCH "define CUDNN_MINOR[ \t]+([0-9]+)" CUDNN_VERSION_MINOR_MATCH "${CUDNN_HEADER_CONTENTS}")
            string(REGEX MATCH "define CUDNN_PATCHLEVEL[ \t]+([0-9]+)" CUDNN_VERSION_PATCH_MATCH "${CUDNN_HEADER_CONTENTS}")

            if(CUDNN_VERSION_MAJOR_MATCH)
                string(REGEX REPLACE "define CUDNN_MAJOR[ \t]+([0-9]+)" "\\1" CUDNN_VERSION_MAJOR "${CUDNN_VERSION_MAJOR_MATCH}")
                string(REGEX REPLACE "define CUDNN_MINOR[ \t]+([0-9]+)" "\\1" CUDNN_VERSION_MINOR "${CUDNN_VERSION_MINOR_MATCH}")
                string(REGEX REPLACE "define CUDNN_PATCHLEVEL[ \t]+([0-9]+)" "\\1" CUDNN_VERSION_PATCH "${CUDNN_VERSION_PATCH_MATCH}")

                set(CUDNN_VERSION_STRING "${CUDNN_VERSION_MAJOR}.${CUDNN_VERSION_MINOR}.${CUDNN_VERSION_PATCH}")
            else()
                # Try alternative version detection
                string(REGEX MATCH "#define CUDNN_MAJOR ([0-9]+)" CUDNN_VERSION_MAJOR_MATCH2 "${CUDNN_HEADER_CONTENTS}")
                if(CUDNN_VERSION_MAJOR_MATCH2)
                    string(REGEX REPLACE "#define CUDNN_MAJOR ([0-9]+)" "\\1" CUDNN_VERSION_MAJOR "${CUDNN_VERSION_MAJOR_MATCH2}")
                    string(REGEX MATCH "#define CUDNN_MINOR ([0-9]+)" CUDNN_VERSION_MINOR_MATCH2 "${CUDNN_HEADER_CONTENTS}")
                    string(REGEX MATCH "#define CUDNN_PATCHLEVEL ([0-9]+)" CUDNN_VERSION_PATCH_MATCH2 "${CUDNN_HEADER_CONTENTS}")
                    string(REGEX REPLACE "#define CUDNN_MINOR ([0-9]+)" "\\1" CUDNN_VERSION_MINOR "${CUDNN_VERSION_MINOR_MATCH2}")
                    string(REGEX REPLACE "#define CUDNN_PATCHLEVEL ([0-9]+)" "\\1" CUDNN_VERSION_PATCH "${CUDNN_VERSION_PATCH_MATCH2}")
                    set(CUDNN_VERSION_STRING "${CUDNN_VERSION_MAJOR}.${CUDNN_VERSION_MINOR}.${CUDNN_VERSION_PATCH}")
                else()
                    set(CUDNN_VERSION_STRING "Unknown")
                endif()
            endif()
        else()
            message(WARNING "⚠️  cuDNN header found but cannot read version")
            set(CUDNN_VERSION_STRING "Unknown")
        endif()

        # Create imported target if it doesn't exist
        if(NOT TARGET CUDNN::cudnn)
            add_library(CUDNN::cudnn UNKNOWN IMPORTED)
            set_target_properties(CUDNN::cudnn PROPERTIES
                    IMPORTED_LOCATION "${CUDNN_LIBRARY}"
                    INTERFACE_INCLUDE_DIRECTORIES "${CUDNN_INCLUDE_DIR}"
            )
        endif()

        message(STATUS "✅ cuDNN configuration:")
        message(STATUS "   Include: ${CUDNN_INCLUDE_DIR}")
        message(STATUS "   Library: ${CUDNN_LIBRARY}")
        message(STATUS "   Version: ${CUDNN_VERSION_STRING}")

        # Set all the variables that might be needed
        set(HAVE_CUDNN TRUE PARENT_SCOPE)
        set(CUDNN_FOUND TRUE PARENT_SCOPE)
        set(CUDNN_INCLUDE_DIR "${CUDNN_INCLUDE_DIR}" PARENT_SCOPE)
        set(CUDNN_LIBRARIES "${CUDNN_LIBRARY}" PARENT_SCOPE)
        set(CUDNN_LIBRARY "${CUDNN_LIBRARY}" PARENT_SCOPE)
        set(CUDNN_VERSION_STRING "${CUDNN_VERSION_STRING}" PARENT_SCOPE)

        return()
    endif()

    # Try package manager detection as fallback
    find_package(PkgConfig QUIET)
    if(PkgConfig_FOUND)
        pkg_check_modules(PC_CUDNN QUIET cudnn)
        if(PC_CUDNN_FOUND)
            message(STATUS "✅ Found cuDNN via pkg-config")
            set(HAVE_CUDNN TRUE PARENT_SCOPE)
            set(CUDNN_INCLUDE_DIR "${PC_CUDNN_INCLUDE_DIRS}" PARENT_SCOPE)
            set(CUDNN_LIBRARIES "${PC_CUDNN_LIBRARIES}" PARENT_SCOPE)
            set(CUDNN_VERSION_STRING "${PC_CUDNN_VERSION}" PARENT_SCOPE)
            return()
        endif()
    endif()

    # Final attempt: check if cuDNN is embedded in CUDA installation
    if(CUDAToolkit_FOUND AND CUDAToolkit_INCLUDE_DIRS)
        foreach(cuda_include_dir ${CUDAToolkit_INCLUDE_DIRS})
            if(EXISTS "${cuda_include_dir}/cudnn.h")
                message(STATUS "✅ Found cuDNN embedded in CUDA installation")
                set(HAVE_CUDNN TRUE PARENT_SCOPE)
                set(CUDNN_INCLUDE_DIR "${cuda_include_dir}" PARENT_SCOPE)
                set(CUDNN_LIBRARIES "" PARENT_SCOPE)  # May be linked with CUDA
                set(CUDNN_VERSION_STRING "Embedded" PARENT_SCOPE)
                return()
            endif()
        endforeach()
    endif()

    message(STATUS "❌ cuDNN not found. Searched extensively in:")
    message(STATUS "   Environment variables: CUDNN_ROOT_DIR, CUDNN_ROOT, CUDA_PATH, CUDA_HOME")
    message(STATUS "   CUDA installation: ${CUDAToolkit_ROOT}")
    if(WIN32)
        message(STATUS "   System paths: $ENV{ProgramFiles}/NVIDIA GPU Computing Toolkit")
    else()
        message(STATUS "   System paths: /usr, /usr/local, /opt")
    endif()
    message(STATUS "   Package manager: pkg-config")
    message(STATUS "")
    message(STATUS "💡 To fix this issue:")
    message(STATUS "   1. Install cuDNN development libraries")
    message(STATUS "   2. Set CUDNN_ROOT_DIR to your cuDNN installation")
    message(STATUS "   3. Ensure cuDNN headers are in CUDA_PATH/include")
    message(STATUS "   4. Or disable cuDNN with -DHELPERS_cudnn=OFF")

    # Debug information
    message(STATUS "")
    message(STATUS "🔍 Debug information:")
    message(STATUS "   CUDAToolkit_ROOT: ${CUDAToolkit_ROOT}")
    message(STATUS "   CUDAToolkit_INCLUDE_DIRS: ${CUDAToolkit_INCLUDE_DIRS}")
    message(STATUS "   ENV CUDNN_ROOT_DIR: $ENV{CUDNN_ROOT_DIR}")
    message(STATUS "   ENV CUDA_PATH: $ENV{CUDA_PATH}")
    message(STATUS "   ENV CUDA_HOME: $ENV{CUDA_HOME}")
endfunction()

function(configure_cuda_linking main_target_name)
    # Setup CUDA toolkit paths first
    setup_cuda_toolkit_paths()

    # Find the CUDAToolkit to define the CUDA::toolkit target
    find_package(CUDAToolkit REQUIRED)

    # Setup modern cuDNN detection
    setup_modern_cudnn()

    # This ensures cuda.h and other CUDA headers are found
    if(CUDA_INCLUDE_DIRS)
        target_include_directories(${main_target_name} PUBLIC ${CUDA_INCLUDE_DIRS})
        message(STATUS "✅ Added CUDA include directories to ${main_target_name}: ${CUDA_INCLUDE_DIRS}")
    endif()

    # Apply GNU-specific CUDA compiler flags for duplicate instantiation handling
    # ONLY for non-Windows builds
    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT WIN32)
        message(STATUS "🔧 Applying GNU-specific CUDA flags for duplicate instantiation handling")
        target_compile_options(${main_target_name} PRIVATE
                $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-fno-implicit-templates>
        )
    endif()

    # Modern CMake uses imported targets which handle all necessary dependencies.
    # Linking against CUDA::toolkit automatically adds include directories,
    # runtime libraries, and all other required flags.
    target_link_libraries(${main_target_name} PUBLIC CUDA::toolkit)

    # If cuDNN was found, link against its imported target
    if(HAVE_CUDNN AND TARGET CUDNN::cudnn)
        message(STATUS "✅ Linking with modern CUDNN::cudnn target")
        target_link_libraries(${main_target_name} PUBLIC CUDNN::cudnn)
        target_compile_definitions(${main_target_name} PUBLIC HAVE_CUDNN=1)
    elseif(HAVE_CUDNN AND CUDNN_LIBRARIES)
        message(STATUS "✅ Linking with cuDNN libraries: ${CUDNN_LIBRARIES}")
        target_link_libraries(${main_target_name} PUBLIC ${CUDNN_LIBRARIES})
        target_include_directories(${main_target_name} PUBLIC ${CUDNN_INCLUDE_DIR})
        target_compile_definitions(${main_target_name} PUBLIC HAVE_CUDNN=1)
    elseif(HAVE_CUDNN AND CUDNN_INCLUDE_DIR)
        message(STATUS "✅ Linking with cuDNN include-only (embedded in CUDA)")
        target_include_directories(${main_target_name} PUBLIC ${CUDNN_INCLUDE_DIR})
        target_compile_definitions(${main_target_name} PUBLIC HAVE_CUDNN=1)
    else()
        message(STATUS "ℹ️  Building without cuDNN support")
        target_compile_definitions(${main_target_name} PUBLIC HAVE_CUDNN=0)
    endif()

    target_link_libraries(${main_target_name} PUBLIC flatbuffers_interface)
    install(TARGETS ${main_target_name} DESTINATION .)
endfunction()

function(setup_cuda_architectures_early)
    if(NOT SD_CUDA)
        return()
    endif()

    # Fix missing _CMAKE_CUDA_WHOLE_FLAG (note the underscore prefix)
    if(NOT DEFINED _CMAKE_CUDA_WHOLE_FLAG)
        message(STATUS "Setting _CMAKE_CUDA_WHOLE_FLAG (was missing)")
        if(WIN32)
            set(_CMAKE_CUDA_WHOLE_FLAG "/WHOLEARCHIVE:" CACHE INTERNAL "CUDA whole archive flag")
        else()
            set(_CMAKE_CUDA_WHOLE_FLAG "-Wl,--whole-archive" CACHE INTERNAL "CUDA whole archive flag")
        endif()
    endif()

    if(NOT DEFINED CMAKE_CUDA_WHOLE_FLAG)
        if(WIN32)
            set(CMAKE_CUDA_WHOLE_FLAG "/WHOLEARCHIVE:" CACHE STRING "CUDA whole archive flag")
        else()
            set(CMAKE_CUDA_WHOLE_FLAG "-Wl,--whole-archive" CACHE STRING "CUDA whole archive flag")
        endif()
    endif()

    message(STATUS "🔧 Early CUDA: Configuring architectures before project() call")

    if(DEFINED COMPUTE)
        string(TOLOWER "${COMPUTE}" COMPUTE_CMP)
        if(COMPUTE_CMP STREQUAL "all")
            set(CUDA_ARCHITECTURES "75;80;86;89" PARENT_SCOPE)
            message(STATUS "   CUDA architectures (all): 75;80;86;89")
        elseif(COMPUTE_CMP STREQUAL "auto")
            set(CMAKE_CUDA_ARCHITECTURES "86" PARENT_SCOPE)
            message(STATUS "   CUDA architectures (auto): 86")
        else()
            string(REPLACE "," ";" ARCH_LIST "${COMPUTE}")
            set(PARSED_ARCHS "")
            foreach(ARCH ${ARCH_LIST})
                string(REPLACE "." "" ARCH_CLEAN "${ARCH}")
                if(ARCH_CLEAN MATCHES "^[0-9][0-9]$")
                    list(APPEND PARSED_ARCHS "${ARCH_CLEAN}")
                endif()
            endforeach()
            if(PARSED_ARCHS)
                set(CUDA_ARCHITECTURES "${PARSED_ARCHS}" PARENT_SCOPE)
                message(STATUS "   CUDA architectures (custom): ${PARSED_ARCHS}")
            else()
                set(CUDA_ARCHITECTURES "86" PARENT_SCOPE)
                message(STATUS "   CUDA architectures (default): 86")
            endif()
        endif()
    else()
        set(CUDA_ARCHITECTURES "86" PARENT_SCOPE)
        message(STATUS "   CUDA architectures (no COMPUTE): 86")
    endif()
endfunction()

function(setup_cuda_language)
    if(NOT DEFINED _CMAKE_CUDA_WHOLE_FLAG)
        message(STATUS "Setting _CMAKE_CUDA_WHOLE_FLAG (was missing)")
        if(WIN32)
            set(_CMAKE_CUDA_WHOLE_FLAG "/WHOLEARCHIVE:" CACHE INTERNAL "CUDA whole archive flag")
        else()
            set(_CMAKE_CUDA_WHOLE_FLAG "-Wl,--whole-archive" CACHE INTERNAL "CUDA whole archive flag")
        endif()
    endif()

    include(CheckLanguage)
    check_language(CUDA)

    if(NOT CMAKE_CUDA_COMPILER)
        find_program(NVCC_EXECUTABLE nvcc)
        if(NVCC_EXECUTABLE)
            set(CMAKE_CUDA_COMPILER ${NVCC_EXECUTABLE} PARENT_SCOPE)
            message(STATUS "CUDA compiler found: ${CMAKE_CUDA_COMPILER}")
        else()
            message(FATAL_ERROR "CUDA compiler not found. Please ensure CUDA toolkit is installed and nvcc is in PATH.")
        endif()
    endif()

    message(STATUS "CUDA language enabled successfully with compiler: ${CMAKE_CUDA_COMPILER}")
endfunction()

function(configure_windows_cuda_build)
    if(NOT WIN32)
        return()
    endif()

    message(STATUS "Configuring Windows CUDA build with verbose mode...")

    # Enable verbose output for the build system
    set(CMAKE_VERBOSE_MAKEFILE ON PARENT_SCOPE)
    set(CMAKE_CUDA_VERBOSE_FLAG ON PARENT_SCOPE)

    # Completely disable response files to prevent command line issues
    set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_OBJECTS OFF PARENT_SCOPE)
    set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_INCLUDES OFF PARENT_SCOPE)
    set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_LIBRARIES OFF PARENT_SCOPE)
    set(CMAKE_CUDA_USE_RESPONSE_FILE_FOR_LINK_OBJECTS OFF PARENT_SCOPE)

    # Remove problematic dependency generation that causes NVCC failures
    set(CMAKE_CUDA_DEPFILE_FORMAT "" PARENT_SCOPE)
    set(CMAKE_CUDA_DEPENDS_USE_COMPILER OFF PARENT_SCOPE)

    # Clean MSVC runtime library settings
    set(CMAKE_CUDA_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreaded "" PARENT_SCOPE)
    set(CMAKE_CUDA_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL "" PARENT_SCOPE)
    set(CMAKE_CUDA_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebug "" PARENT_SCOPE)
    set(CMAKE_CUDA_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDebugDLL "" PARENT_SCOPE)

    # Force clean CXX flags to prevent contamination
    set(CMAKE_CXX_FLAGS "" PARENT_SCOPE)

    # Enable verbose rule and target messages
    set_property(GLOBAL PROPERTY RULE_MESSAGES ON)
    set_property(GLOBAL PROPERTY TARGET_MESSAGES ON)

    message(STATUS "Windows CUDA: Verbose mode enabled with clean flags")
endfunction()
function(configure_cuda_architecture_flags COMPUTE)
    string(TOLOWER "${COMPUTE}" COMPUTE_CMP)
    if(COMPUTE_CMP STREQUAL "all")
        set(CUDA_ARCH_FLAGS "-gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_89,code=sm_89" PARENT_SCOPE)
        message(STATUS "Building for all CUDA architectures (gencode flags)")
    elseif(COMPUTE_CMP STREQUAL "auto")
        set(CUDA_ARCH_FLAGS "-gencode arch=compute_86,code=sm_86" PARENT_SCOPE)
        message(STATUS "Auto-detecting CUDA architectures (gencode flags)")
    else()
        string(REPLACE "," ";" ARCH_LIST "${COMPUTE}")
        set(ARCH_FLAGS "")
        foreach(ARCH ${ARCH_LIST})
            string(REPLACE "." "" ARCH_CLEAN "${ARCH}")
            if(ARCH_CLEAN MATCHES "^[0-9][0-9]$")
                set(ARCH_FLAGS "${ARCH_FLAGS} -gencode arch=compute_${ARCH_CLEAN},code=sm_${ARCH_CLEAN}")
            endif()
        endforeach()
        string(STRIP "${ARCH_FLAGS}" ARCH_FLAGS)
        if(ARCH_FLAGS)
            set(CUDA_ARCH_FLAGS "${ARCH_FLAGS}" PARENT_SCOPE)
            message(STATUS "Using custom CUDA architectures (gencode flags): ${ARCH_FLAGS}")
        else()
            set(CUDA_ARCH_FLAGS "-gencode arch=compute_86,code=sm_86" PARENT_SCOPE)
            message(STATUS "Using default CUDA architecture (gencode flags)")
        endif()
    endif()
endfunction()

function(build_cuda_compiler_flags CUDA_ARCH_FLAGS)
    set(LOCAL_CUDA_FLAGS "")

    if(WIN32 AND MSVC)
        message(STATUS "Configuring CUDA for Windows MSVC with verbose mode...")
        set(CMAKE_CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER} PARENT_SCOPE)
        set(LOCAL_CUDA_FLAGS "-maxrregcount=128")

        # Enable verbose mode for Windows CUDA compilation
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} --verbose")
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} --ptxas-options=-v")
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} --resource-usage")

        # Host compiler verbose flags
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xcompiler=/showIncludes")
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xcompiler=/verbose")
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xcompiler=/diagnostics:caret")

        # Linker verbose flags
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xlinker=/VERBOSE")
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xlinker=/TIME")

        # Explicitly enable C++17 for the host compiler
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xcompiler=/std:c++17")

        if(WIN32 AND NOT CMAKE_CUDA_HOST_COMPILER)
            find_program(CL_IN_PATH cl.exe)
            if(CL_IN_PATH)
                # Check if this cl.exe is 64-bit by examining its path
                get_filename_component(CL_DIR ${CL_IN_PATH} DIRECTORY)
                if(CL_DIR MATCHES "x64")
                    set(CMAKE_CUDA_HOST_COMPILER ${CL_IN_PATH})
                    message(STATUS "Found x64 cl.exe in PATH: ${CMAKE_CUDA_HOST_COMPILER}")
                else()
                    # Try to find x64 version relative to this cl.exe
                    get_filename_component(CL_PARENT ${CL_DIR} DIRECTORY)
                    if(EXISTS "${CL_PARENT}/x64/cl.exe")
                        set(CMAKE_CUDA_HOST_COMPILER "${CL_PARENT}/x64/cl.exe")
                        message(STATUS "Found x64 cl.exe relative to PATH cl.exe: ${CMAKE_CUDA_HOST_COMPILER}")
                    endif()
                endif()
            endif()
        endif()

        if(WIN32 AND NOT CMAKE_CUDA_HOST_COMPILER)
            # Only check the most common paths that exist in barebones installs
            set(COMMON_PATHS
                    "C:/Program Files (x86)/Microsoft Visual Studio/2022/BuildTools/VC/Tools/MSVC"
                    "C:/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools/VC/Tools/MSVC"
                    "C:/Program Files/Microsoft Visual Studio/2022/BuildTools/VC/Tools/MSVC"
            )

            foreach(BASE_PATH ${COMMON_PATHS})
                if(EXISTS ${BASE_PATH})
                    file(GLOB MSVC_VERSIONS "${BASE_PATH}/*")
                    if(MSVC_VERSIONS)
                        # Get the lexicographically last version (should be newest)
                        list(SORT MSVC_VERSIONS)
                        list(REVERSE MSVC_VERSIONS)
                        list(GET MSVC_VERSIONS 0 LATEST_MSVC)

                        set(CANDIDATE_COMPILER "${LATEST_MSVC}/bin/Hostx64/x64/cl.exe")
                        if(EXISTS ${CANDIDATE_COMPILER})
                            set(CMAKE_CUDA_HOST_COMPILER ${CANDIDATE_COMPILER})
                            message(STATUS "Found CUDA host compiler in standard path: ${CMAKE_CUDA_HOST_COMPILER}")
                            break()
                        endif()
                    endif()
                endif()
            endforeach()
        endif()

        # Validation and warning
        if(WIN32)
            if(CMAKE_CUDA_HOST_COMPILER)
                if(NOT EXISTS ${CMAKE_CUDA_HOST_COMPILER})
                    message(WARNING "CUDA host compiler path does not exist: ${CMAKE_CUDA_HOST_COMPILER}")
                    unset(CMAKE_CUDA_HOST_COMPILER)
                else()
                    message(STATUS "Final CUDA host compiler: ${CMAKE_CUDA_HOST_COMPILER}")
                endif()
            else()
                message(WARNING "Could not auto-detect x64 CUDA host compiler.")
                message(STATUS "Manual options:")
                message(STATUS "  1. Use x64 Native Tools Command Prompt")
                message(STATUS "  2. Set manually: -DCMAKE_CUDA_HOST_COMPILER=\"path/to/x64/cl.exe\"")
                message(STATUS "  3. Ensure x64 cl.exe is in your PATH")
            endif()
        endif()

        # Windows/MSVC flags: bigobj, EHsc, *and* disable the new preprocessor
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}
         -Xcompiler=/std:c++17
        -Xcompiler=/bigobj
        -Xcompiler=/EHsc
        -Xcompiler=/Zc:preprocessor-")

        # Force clean host compiler flags
        set(CMAKE_CXX_FLAGS "" PARENT_SCOPE)

        message(STATUS "CUDA Windows verbose flags configured")
    else()
        message(STATUS "Configuring CUDA for Unix/Linux with verbose mode...")
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -maxrregcount=128")

        # Enable verbose mode for Unix/Linux CUDA compilation
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} --verbose")
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} --ptxas-options=-v")
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} --resource-usage")

        if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
            # Host compiler verbose flags for GCC
            set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xcompiler=-v")
            set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xcompiler=-H")

            # Linker verbose flags
            set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xlinker=-v")
            set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xlinker=--verbose")

            if(SD_GCC_FUNCTRACE)
                set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xcompiler=-fPIC --device-debug -lineinfo -G")
            else()
                set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xcompiler=-fPIC -Xcompiler=-fpermissive")
                # Add flags to handle duplicate instantiations for GNU compiler
                set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -Xcompiler=-fno-implicit-templates")
            endif()
        endif()

        message(STATUS "CUDA Unix/Linux verbose flags configured")
    endif()

    if("${SD_PTXAS}" STREQUAL "ON")
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} --ptxas-options=-v")
    endif()

    if(SD_KEEP_NVCC_OUTPUT)
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} --keep")
    endif()

    if(DEFINED CUDA_ARCH_FLAGS)
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} ${CUDA_ARCH_FLAGS}")
    endif()
    set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -w --cudart=shared --expt-extended-lambda -Xfatbin -compress-all")

    if(CMAKE_CUDA_COMPILER_VERSION)
        string(REGEX MATCH "^([0-9]+)" CUDA_VERSION_MAJOR "${CMAKE_CUDA_COMPILER_VERSION}")
        set(LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS} -DCUDA_VERSION_MAJOR=${CUDA_VERSION_MAJOR}")
    endif()

    # Clean up any problematic flags for Windows
    if(WIN32)
        # Remove any GCC-style flags that might have been added
        string(REGEX REPLACE "-MD[^a-zA-Z]" "" LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}")
        string(REGEX REPLACE "-MT[^a-zA-Z]" "" LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}")
        string(REGEX REPLACE "-MF[^a-zA-Z]" "" LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}")
        string(REGEX REPLACE "-x cu" "" LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}")
        string(REGEX REPLACE "-fpermissive" "" LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}")
        string(REGEX REPLACE "-Wno-error" "" LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}")
        string(REGEX REPLACE "/FS[ ]*" "" LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}")
        string(REGEX REPLACE "-Xcompiler=-Fd[^,]*,?" "" LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}")
        string(REGEX REPLACE "-Xcompiler=," "-Xcompiler=" LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}")
        string(REGEX REPLACE "-Xcompiler=$" "" LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}")
    endif()

    string(REGEX REPLACE "  +" " " LOCAL_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}")
    string(STRIP "${LOCAL_CUDA_FLAGS}" LOCAL_CUDA_FLAGS)

    set(CMAKE_CUDA_SEPARABLE_COMPILATION ON PARENT_SCOPE)
    set(CMAKE_CUDA_FLAGS "${LOCAL_CUDA_FLAGS}" PARENT_SCOPE)

    message(STATUS "Final CMAKE_CUDA_FLAGS (with verbose): ${LOCAL_CUDA_FLAGS}")
endfunction()

# Debug configuration function
function(debug_cuda_configuration)
    message(STATUS "=== CUDA Configuration Debug Info ===")
    message(STATUS "CMAKE_CUDA_COMPILER: ${CMAKE_CUDA_COMPILER}")
    message(STATUS "CMAKE_CUDA_COMPILER_VERSION: ${CMAKE_CUDA_COMPILER_VERSION}")
    message(STATUS "CMAKE_CUDA_ARCHITECTURES: ${CMAKE_CUDA_ARCHITECTURES}")
    message(STATUS "CMAKE_CUDA_FLAGS: ${CMAKE_CUDA_FLAGS}")
    message(STATUS "CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES: ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}")
    message(STATUS "CMAKE_CUDA_COMPILE_OBJECT: ${CMAKE_CUDA_COMPILE_OBJECT}")
    message(STATUS "CUDA_INCLUDE_DIRS: ${CUDA_INCLUDE_DIRS}")
    message(STATUS "CUDAToolkit_ROOT: ${CUDAToolkit_ROOT}")
    message(STATUS "CUDAToolkit_INCLUDE_DIRS: ${CUDAToolkit_INCLUDE_DIRS}")
    if(HAVE_CUDNN)
        message(STATUS "CUDNN_INCLUDE_DIR: ${CUDNN_INCLUDE_DIR}")
        message(STATUS "CUDNN_LIBRARIES: ${CUDNN_LIBRARIES}")
        message(STATUS "CUDNN_VERSION: ${CUDNN_VERSION_STRING}")
    endif()
    message(STATUS "=== End CUDA Debug Info ===")
endfunction()

# Enhanced CUDA include directory setup for global configuration
function(setup_cuda_include_directories)
    setup_cuda_toolkit_paths()

    # Set global include directories that will be inherited by all targets
    if(CUDA_INCLUDE_DIRS)
        include_directories(${CUDA_INCLUDE_DIRS})
        message(STATUS "✅ Added global CUDA include directories: ${CUDA_INCLUDE_DIRS}")
    endif()

    # Also set the CMAKE variable for compatibility
    if(CUDAToolkit_INCLUDE_DIRS)
        set(CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES ${CUDAToolkit_INCLUDE_DIRS} PARENT_SCOPE)
    endif()
endfunction()

function(setup_cuda_build)
    message(STATUS "=== CUDA BUILD CONFIGURATION (VERBOSE MODE) ===")

    # Enable verbose output for the build system
    set(CMAKE_VERBOSE_MAKEFILE ON PARENT_SCOPE)
    set(CMAKE_CUDA_VERBOSE_FLAG ON PARENT_SCOPE)

    if(NOT DEFINED _CMAKE_CUDA_WHOLE_FLAG)
        message(STATUS "Setting _CMAKE_CUDA_WHOLE_FLAG (was missing)")
        if(WIN32)
            set(_CMAKE_CUDA_WHOLE_FLAG "/WHOLEARCHIVE:" CACHE INTERNAL "CUDA whole archive flag")
        else()
            set(_CMAKE_CUDA_WHOLE_FLAG "-Wl,--whole-archive" CACHE INTERNAL "CUDA whole archive flag")
        endif()
    endif()

    # Setup CUDA toolkit paths and include directories early
    setup_cuda_include_directories()

    if(NOT DEFINED COMPUTE)
        set(COMPUTE "auto")
    endif()
    configure_cuda_architecture_flags("${COMPUTE}")
    set_property(GLOBAL PROPERTY CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}")

    setup_cuda_language()

    if(NOT CMAKE_CUDA_COMPILER)
        message(FATAL_ERROR "CUDA compiler not found after enabling CUDA language")
    endif()

    message(STATUS "CUDA Compiler: ${CMAKE_CUDA_COMPILER}")
    message(STATUS "CUDA Include Dirs: ${CUDA_INCLUDE_DIRS}")
    message(STATUS "CUDAToolkit Include Dirs: ${CUDAToolkit_INCLUDE_DIRS}")
    message(STATUS "Host CXX Compiler: ${CMAKE_CXX_COMPILER_ID}")

    configure_windows_cuda_build()
    build_cuda_compiler_flags("${CUDA_ARCH_FLAGS}")

    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS}" PARENT_SCOPE)

    # Also set the toolkit include directories for global access
    set(CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES "${CUDA_INCLUDE_DIRS}" PARENT_SCOPE)

    # Enable verbose rule and target messages
    set_property(GLOBAL PROPERTY RULE_MESSAGES ON)
    set_property(GLOBAL PROPERTY TARGET_MESSAGES ON)

    debug_cuda_configuration()

    add_compile_definitions(SD_CUDA=true)
    set(DEFAULT_ENGINE "samediff::ENGINE_CUDA" PARENT_SCOPE)

    message(STATUS "=== CUDA BUILD CONFIGURATION (VERBOSE MODE) COMPLETE ===")
endfunction()

# Enhanced function to ensure CUDA paths are available at configure time
function(ensure_cuda_paths_available)
    if(NOT SD_CUDA)
        return()
    endif()

    message(STATUS "🔍 Ensuring CUDA paths are available...")

    # Find CUDA early
    find_package(CUDAToolkit REQUIRED)

    # Set up paths immediately
    setup_cuda_toolkit_paths()

    # Export to parent scope for immediate use
    set(CUDA_INCLUDE_DIRS "${CUDA_INCLUDE_DIRS}" PARENT_SCOPE)
    set(CUDA_TOOLKIT_ROOT_DIR "${CUDAToolkit_ROOT}" PARENT_SCOPE)

    message(STATUS "✅ CUDA paths configured and available")
endfunction()

# Legacy function for backward compatibility - now calls modern version
function(setup_cudnn)
    setup_modern_cudnn()

    # Set legacy variables for backward compatibility
    set(HAVE_CUDNN ${HAVE_CUDNN} PARENT_SCOPE)
    if(HAVE_CUDNN)
        set(CUDNN_INCLUDE_DIR ${CUDNN_INCLUDE_DIR} PARENT_SCOPE)
        set(CUDNN ${CUDNN_LIBRARIES} PARENT_SCOPE)
    endif()
endfunction()