#!/usr/bin/env bash
#
# /* ******************************************************************************
#  *
#  *
#  * This program and the accompanying materials are made available under the
#  * terms of the Apache License, Version 2.0 which is available at
#  * https://www.apache.org/licenses/LICENSE-2.0.
#  *
#  * See the NOTICE file distributed with this work for additional
#  * information regarding copyright ownership.
#  * Unless required by applicable law or agreed to in writing, software
#  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#  * License for the specific language governing permissions and limitations
#  * under the License.
#  *
#  * SPDX-License-Identifier: Apache-2.0
#  ******************************************************************************/
#
# PREFLIGHT CHECK OPTIONS:
#   --dry-run              Run preflight checks and CMake configuration, then exit
#                          Validates prerequisites, configuration, and binary size
#
# BUILD MODE OPTIONS:
#   --cmake-only ON        Run CMake configuration only, skip build
#   --link-only ON         Skip compilation, only relink (requires prior build)
#
# EXAMPLES:
#   # Validate build configuration before building
#   ./buildnativeoperations.sh --dry-run -a cpu -c ON --compiler clang
#
#   # Normal build
#   ./buildnativeoperations.sh -a cpu -c ON --compiler clang -j 14
#
set -eu

# cd to the directory containing this script
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
cd "$DIR"


# Check bash version and set compatibility mode
BASH_MAJOR_VERSION=${BASH_VERSION%%.*}
USE_ASSOCIATIVE_ARRAYS=false

if [[ $BASH_MAJOR_VERSION -ge 4 ]]; then
    USE_ASSOCIATIVE_ARRAYS=true
    echo "✅ Using bash $BASH_VERSION with associative array support"
else
    echo "⚠️  Using bash $BASH_VERSION - falling back to compatibility mode"
fi




# =============================================================================
# TYPE VALIDATION SYSTEM
# =============================================================================


    # Fallback for older bash - use delimited strings
# Format: "key:value|key:value|..."
ALL_SUPPORTED_TYPES_STR="bool:Boolean type|int8:8-bit signed integer|uint8:8-bit unsigned integer|int16:16-bit signed integer|uint16:16-bit unsigned integer|int32:32-bit signed integer|uint32:32-bit unsigned integer|int64:64-bit signed integer|uint64:64-bit unsigned integer|float16:16-bit floating point (half precision)|bfloat16:16-bit brain floating point|float32:32-bit floating point (single precision)|double:64-bit floating point (double precision)|float:Alias for float32|half:Alias for float16|long:Alias for int64|unsignedlong:Alias for uint64|int:Alias for int32|bfloat:Alias for bfloat16|float64:Alias for double|utf8:UTF-8 string type|utf16:UTF-16 string type|utf32:UTF-32 string type"

TYPE_ALIASES_STR="float:float32|half:float16|long:int64|unsignedlong:uint64|int:int32|bfloat:bfloat16|float64:double"

DEBUG_TYPE_PROFILES_STR="MINIMAL_INDEXING:float32;double;int32;int64|ESSENTIAL:float32;double;int32;int64;int8;int16|FLOATS_ONLY:float32;double;float16|INTEGERS_ONLY:int8;int16;int32;int64;uint8;uint16;uint32;uint64|SINGLE_PRECISION:float32;int32;int64|DOUBLE_PRECISION:double;int32;int64"

# Bare minimum types required for basic functionality
MINIMUM_REQUIRED_TYPES=("int32" "int64" "float32")

# Essential types for most operations (recommended minimum)
ESSENTIAL_TYPES=("int32" "int64" "float32" "double")

# =============================================================================
# COMPATIBILITY HELPER FUNCTIONS
# =============================================================================

# Function to lookup value in delimited string (fallback for associative arrays)
lookup_in_string() {
    local key="$1"
    local data_string="$2"
    local default_value="${3:-}"

    # Extract value using parameter expansion and grep
    local result
    result=$(echo "$data_string" | grep -o "${key}:[^|]*" | cut -d: -f2- || echo "$default_value")
    echo "$result"
}

# Function to check if key exists in delimited string
key_exists_in_string() {
    local key="$1"
    local data_string="$2"

    echo "$data_string" | grep -q "${key}:" && return 0 || return 1
}

# Function to get all keys from delimited string
get_keys_from_string() {
    local data_string="$1"
    echo "$data_string" | grep -o '[^|]*:' | sed 's/:$//'
}


get_type_description() {
    case "$1" in
        "bool") echo "Boolean type" ;;
        "int8") echo "8-bit signed integer" ;;
        "uint8") echo "8-bit unsigned integer" ;;
        "int16") echo "16-bit signed integer" ;;
        "uint16") echo "16-bit unsigned integer" ;;
        "int32") echo "32-bit signed integer" ;;
        "uint32") echo "32-bit unsigned integer" ;;
        "int64") echo "64-bit signed integer" ;;
        "uint64") echo "64-bit unsigned integer" ;;
        "float16") echo "16-bit floating point (half precision)" ;;
        "bfloat16") echo "16-bit brain floating point" ;;
        "float32") echo "32-bit floating point (single precision)" ;;
        "double") echo "64-bit floating point (double precision)" ;;
        "float") echo "Alias for float32" ;;
        "half") echo "Alias for float16" ;;
        "long") echo "Alias for int64" ;;
        "unsignedlong") echo "Alias for uint64" ;;
        "int") echo "Alias for int32" ;;
        "bfloat") echo "Alias for bfloat16" ;;
        "float64") echo "Alias for double" ;;
        "utf8") echo "UTF-8 string type" ;;
        "utf16") echo "UTF-16 string type" ;;
        "utf32") echo "UTF-32 string type" ;;
        *) echo "Unknown type" ;;
    esac
}

is_supported_type() {
    local normalized_type
    normalized_type=$(normalize_type "$1")
    case "$normalized_type" in
        bool|int8|uint8|int16|uint16|int32|uint32|int64|uint64|float16|bfloat16|float32|double|utf8|utf16|utf32)
            return 0 ;;
        *)
            return 1 ;;
    esac
}

# =============================================================================
# UTILITY FUNCTIONS
# =============================================================================

# Function to print colored output with status indicators
print_colored() {
    local color="$1"
    local message="$2"

    # Check if stdout is a terminal and colors are supported
    if [[ -t 1 ]] && command -v tput >/dev/null 2>&1 && [[ "$(tput colors 2>/dev/null || echo 0)" -ge 8 ]]; then
        # Terminal supports colors
        case "$color" in
            "red")    echo -e "\033[1;31m❌ $message\033[0m" ;;
            "green")  echo -e "\033[1;32m✅ $message\033[0m" ;;
            "yellow") echo -e "\033[1;33m⚠️  $message\033[0m" ;;
            "blue")   echo -e "\033[1;34mℹ️  $message\033[0m" ;;
            "cyan")   echo -e "\033[1;36m🔍 $message\033[0m" ;;
            "magenta"|"purple") echo -e "\033[1;35m🔧 $message\033[0m" ;;
            "white")  echo -e "\033[1;37m💬 $message\033[0m" ;;
            "gray"|"grey") echo -e "\033[1;90m📝 $message\033[0m" ;;
            "bold")   echo -e "\033[1m$message\033[0m" ;;
            *)        echo "$message" ;;
        esac
    else
        # No color support or not a terminal - use plain text with indicators
        case "$color" in
            "red")    echo "❌ ERROR: $message" ;;
            "green")  echo "✅ SUCCESS: $message" ;;
            "yellow") echo "⚠️  WARNING: $message" ;;
            "blue")   echo "ℹ️  INFO: $message" ;;
            "cyan")   echo "🔍 DEBUG: $message" ;;
            "magenta"|"purple") echo "🔧 CONFIG: $message" ;;
            "white")  echo "💬 MESSAGE: $message" ;;
            "gray"|"grey") echo "📝 NOTE: $message" ;;
            *)        echo "$message" ;;
        esac
    fi
}

# Function to normalize type names (handle aliases)
normalize_type() {
    case "$1" in
        "float") echo "float32" ;;
        "half") echo "float16" ;;
        "long") echo "int64" ;;
        "unsignedlong") echo "uint64" ;;
        "int") echo "int32" ;;
        "bfloat") echo "bfloat16" ;;
        "float64") echo "double" ;;
        *) echo "$1" ;;
    esac
}

get_debug_type_profile() {
    case "$1" in
        "MINIMAL_INDEXING") echo "float32;double;int32;int64" ;;
        "ESSENTIAL") echo "float32;double;int32;int64;int8;int16" ;;
        "FLOATS_ONLY") echo "float32;double;float16" ;;
        "INTEGERS_ONLY") echo "int8;int16;int32;int64;uint8;uint16;uint32;uint64" ;;
        "SINGLE_PRECISION") echo "float32;int32;int64" ;;
        "DOUBLE_PRECISION") echo "double;int32;int64" ;;
        *) echo "float32;double;int32;int64" ;;  # default to MINIMAL_INDEXING
    esac
}


# Function to validate a single type
validate_single_type() {
    local type="$1"
    is_supported_type "$type"
}
# Function to display available types
show_available_types() {
    print_colored "cyan" "\n=== AVAILABLE DATA TYPES ==="
    echo
    print_colored "yellow" "Core Types:"
    for type in bool int8 uint8 int16 uint16 int32 uint32 int64 uint64; do
        printf "  %-12s - %s\n" "$type" "$(get_type_description "$type")"
    done

    echo
    print_colored "yellow" "Floating Point Types:"
    for type in float16 bfloat16 float32 double; do
        printf "  %-12s - %s\n" "$type" "$(get_type_description "$type")"
    done

    echo
    print_colored "yellow" "String Types:"
    for type in utf8 utf16 utf32; do
        printf "  %-12s - %s\n" "$type" "$(get_type_description "$type")"
    done

    echo
    print_colored "yellow" "Type Aliases:"
    for alias in float half long unsignedlong int bfloat float64; do
        printf "  %-12s -> %s\n" "$alias" "$(normalize_type "$alias")"
    done

    echo
    print_colored "yellow" "Debug Type Profiles:"
    for profile in MINIMAL_INDEXING ESSENTIAL FLOATS_ONLY INTEGERS_ONLY SINGLE_PRECISION DOUBLE_PRECISION; do
        printf "  %-16s: %s\n" "$profile" "$(get_debug_type_profile "$profile")"
    done
}


# Function to validate types list with comprehensive checking
validate_types() {
    local types_string="$1"
    local mode="${2:-normal}"  # normal, debug, or strict

    if [[ -z "$types_string" ]]; then
        if [[ "$mode" == "strict" ]]; then
            print_colored "red" "ERROR: No data types specified and strict mode enabled!"
            return 1
        else
            print_colored "yellow" "WARNING: No data types specified, using ALL types"
            return 0
        fi
    fi

    # Handle special keywords
    if [[ "$types_string" == "all" || "$types_string" == "ALL" ]]; then
        print_colored "green" "✓ Using ALL data types"
        return 0
    fi

    # Parse semicolon-separated types
    IFS=';' read -ra TYPES_ARRAY <<< "$types_string"
    local invalid_types=()
    local valid_types=()
    local normalized_types=()

    print_colored "blue" "\n=== TYPE VALIDATION ==="

    for type in "${TYPES_ARRAY[@]}"; do
        # Trim whitespace
        type=$(echo "$type" | tr -d ' ')

        if [[ -z "$type" ]]; then
            continue
        fi

        if validate_single_type "$type"; then
            local normalized_type
            normalized_type=$(normalize_type "$type")
            valid_types+=("$type")
            normalized_types+=("$normalized_type")

            if [[ "$type" != "$normalized_type" ]]; then
                print_colored "cyan" "  ✓ $type (normalized to: $normalized_type)"
            else
                print_colored "green" "  ✓ $type"
            fi
        else
            invalid_types+=("$type")
            print_colored "red" "  ✗ $type (INVALID)"
        fi
    done

    # Report results
    echo
    if [[ ${#invalid_types[@]} -gt 0 ]]; then
        print_colored "red" "ERROR: Found ${#invalid_types[@]} invalid type(s): ${invalid_types[*]}"
        echo
        show_available_types
        return 1
    fi

    if [[ ${#valid_types[@]} -eq 0 ]]; then
        print_colored "red" "ERROR: No valid types found!"
        show_available_types
        return 1
    fi

    # Check for minimum required types
    local missing_essential=()
    for req_type in "${MINIMUM_REQUIRED_TYPES[@]}"; do
        local found=false
        for norm_type in "${normalized_types[@]}"; do
            if [[ "$norm_type" == "$req_type" ]]; then
                found=true
                break
            fi
        done
        if [[ "$found" == false ]]; then
            missing_essential+=("$req_type")
        fi
    done

    if [[ ${#missing_essential[@]} -gt 0 ]]; then
        print_colored "yellow" "WARNING: Missing recommended essential types: ${missing_essential[*]}"
        print_colored "yellow" "         Array indexing and basic operations may fail at runtime!"

        if [[ "$mode" == "strict" ]]; then
            print_colored "red" "ERROR: Strict mode requires essential types: ${MINIMUM_REQUIRED_TYPES[*]}"
            return 1
        fi
    fi

    # Check for excessive type combinations in debug builds
    if [[ "$mode" == "debug" && ${#normalized_types[@]} -gt 6 ]]; then
        local estimated_combinations=$((${#normalized_types[@]} * ${#normalized_types[@]} * ${#normalized_types[@]}))
        print_colored "yellow" "WARNING: Debug build with ${#normalized_types[@]} types may generate ~$estimated_combinations combinations"
        print_colored "yellow" "         This could result in very large binaries and long compile times!"
        print_colored "yellow" "         Consider using a debug type profile: --debug-type-profile MINIMAL_INDEXING"
    fi

    print_colored "green" "✓ Type validation passed: ${#valid_types[@]} valid types"
    print_colored "cyan" "Selected types: ${normalized_types[*]}"

    return 0
}


# Function to resolve debug type profile
resolve_debug_types() {
    local profile="$1"
    local custom_types="$2"

    if [[ "$profile" == "CUSTOM" ]]; then
        if [[ -n "$custom_types" ]]; then
            # Ensure minimum indexing types are included in custom
            local minimum_types="int32;int64;float32"
            local combined_types="$minimum_types"

            # Add custom types, avoiding duplicates
            IFS=';' read -ra CUSTOM_ARRAY <<< "$custom_types"
            for type in "${CUSTOM_ARRAY[@]}"; do
                if [[ "$combined_types" != *"$type"* ]]; then
                    combined_types="$combined_types;$type"
                fi
            done
            echo "$combined_types"
        else
            print_colored "red" "ERROR: CUSTOM profile specified but no custom types provided!"
            return 1
        fi
    else
        local resolved_types
        resolved_types=$(get_debug_type_profile "$profile")
        if [[ -z "$resolved_types" ]]; then
            print_colored "yellow" "Warning: Unknown debug profile '$profile', using MINIMAL_INDEXING"
            resolved_types=$(get_debug_type_profile "MINIMAL_INDEXING")
        fi
        echo "$resolved_types"
    fi
}
# Function to estimate build impact
estimate_build_impact() {
    local types_string="$1"
    local build_type="${2:-release}"

    if [[ -z "$types_string" || "$types_string" == "all" || "$types_string" == "ALL" ]]; then
        print_colored "cyan" "\n=== BUILD IMPACT ESTIMATION ==="
        print_colored "yellow" "Using ALL types - expect full compilation with all template instantiations"
        return 0
    fi

    IFS=';' read -ra TYPES_ARRAY <<< "$types_string"
    local type_count=${#TYPES_ARRAY[@]}

    if [[ $type_count -gt 0 ]]; then
        local est_2_combinations=$((type_count * type_count))
        local est_3_combinations=$((type_count * type_count * type_count))
        local est_binary_size_mb=$((est_3_combinations * 10 / 27))  # Rough estimate

        print_colored "cyan" "\n=== BUILD IMPACT ESTIMATION ==="
        print_colored "yellow" "Type count: $type_count"
        print_colored "yellow" "Estimated 2-type combinations: $est_2_combinations"
        print_colored "yellow" "Estimated 3-type combinations: $est_3_combinations"
        print_colored "yellow" "Estimated binary size: ~${est_binary_size_mb}MB"

        if [[ "$build_type" == "debug" && $est_3_combinations -gt 125 ]]; then
            print_colored "red" "⚠️  HIGH COMBINATION COUNT WARNING!"
            print_colored "red" "   Debug build with $est_3_combinations combinations may cause:"
            print_colored "red" "   - Binary size >2GB (x86-64 limit exceeded)"
            print_colored "red" "   - Compilation failure due to PLT overflow"
            print_colored "red" "   - Very long build times"
            echo
            print_colored "yellow" "Consider using fewer types for debug builds:"
            print_colored "yellow" "  --debug-type-profile MINIMAL_INDEXING"
            print_colored "yellow" "  --datatypes \"float32;double;int32;int64\""
        elif [[ $est_binary_size_mb -gt 1000 ]]; then
            print_colored "yellow" "⚠️  Large binary size warning: ~${est_binary_size_mb}MB"
        fi
    fi
}

# Function to show type validation summary
show_type_summary() {
    local types_string="$1"
    local build_type="${2:-release}"
    local profile="${3:-}"

    print_colored "cyan" "\n=== TYPE CONFIGURATION SUMMARY ==="

    if [[ -n "$profile" ]]; then
        print_colored "yellow" "Debug Type Profile: $profile"
        if [[ "$profile" != "CUSTOM" ]]; then
            print_colored "cyan" "Profile Types: $(get_debug_type_profile "$profile")"
        fi
    fi

    if [[ -z "$types_string" || "$types_string" == "all" || "$types_string" == "ALL" ]]; then
        print_colored "green" "Type Selection: ALL (default)"
        print_colored "cyan" "Building with all supported data types"
    else
        print_colored "green" "Type Selection: SELECTIVE"
        print_colored "cyan" "Building with types: $types_string"
    fi

    print_colored "yellow" "Build Type: $build_type"
    echo
}


# =============================================================================
# PLATFORM HELPER FUNCTIONS
# =============================================================================

setwindows_msys() {
  if [[ $KERNEL == *"windows"* ]]; then
    export CMAKE_COMMAND="$CMAKE_COMMAND -G \"MSYS Makefiles\""
  fi
}

setandroid_defaults() {
  if [[ -z ${ANDROID_NDK:-} ]]; then
    export ANDROID_NDK=$HOME/Android/android-ndk/
    echo "No ANDROID_NDK variable set. Setting to default of $ANDROID_NDK"
  else
    echo "USING ANDROID NDK $ANDROID_NDK"
  fi

  if [[ -z ${ANDROID_VERSION:-} ]]; then
    export ANDROID_VERSION=21
    echo "No ANDROID_VERSION variable set. Setting to default of $ANDROID_VERSION"
  else
    echo "USING ANDROID VERSION $ANDROID_VERSION"
  fi
}

# =============================================================================
# VARIABLE INITIALIZATION
# =============================================================================

export CMAKE_COMMAND="cmake"
if which cmake3 &> /dev/null; then
    export CMAKE_COMMAND="cmake3"
fi

[[ -z ${MAKEJ:-} ]] && MAKEJ=4

# Add load average limiting to prevent memory exhaustion
# -l flag: only start new job if load average < limit
# Load limit = 75% of available cores (24 for 32 cores)
LOAD_LIMIT=$(($(nproc) * 3 / 4))
export MAKE_COMMAND="make -j${MAKEJ} -l${LOAD_LIMIT}"
export MAKE_ARGUMENTS=
echo eval $CMAKE_COMMAND


# Initialize all script variables to prevent unbound variable errors
PARALLEL="${PARALLEL:-true}"
OS="${OS:-}"
CHIP="${CHIP:-}"
BUILD="${BUILD:-}"
COMPUTE="${COMPUTE:-}"
ARCH="${ARCH:-}"
LIBTYPE="${LIBTYPE:-}"
PACKAGING="${PACKAGING:-}"
CHIP_EXTENSION="${CHIP_EXTENSION:-}"
CHIP_VERSION="${CHIP_VERSION:-}"
EXPERIMENTAL="${EXPERIMENTAL:-}"
OPERATIONS="${OPERATIONS:-}"
DATATYPES="${DATATYPES:-}"
CLEAN="${CLEAN:-false}"
MINIFIER="${MINIFIER:-false}"
TESTS="${TESTS:-false}"
PRINT_INDICES="${PRINT_INDICES:-OFF}"
VERBOSE="${VERBOSE:-true}"
VERBOSE_ARG="${VERBOSE_ARG:-VERBOSE=1}"
HELPER="${HELPER:-}"
CHECK_VECTORIZATION="${CHECK_VECTORIZATION:-OFF}"
NAME="${NAME:-}"
OP_OUTPUT_FILE="${OP_OUTPUT_FILE:-include/generated/include_ops.h}"
USE_LTO="${USE_LTO:-}"
SANITIZE="${SANITIZE:-OFF}"
OPTIMIZATION_LEVEL="${OPTIMIZATION_LEVEL:-}"
SANITIZERS="${SANITIZERS:-address,undefined,float-divide-by-zero,float-cast-overflow}"
FUNC_TRACE="${FUNC_TRACE:-OFF}"
LOG_OUTPUT="${LOG_OUTPUT:-none}"
PRINT_MATH="${PRINT_MATH:-OFF}"
KEEP_NVCC="${KEEP_NVCC:-OFF}"
PREPROCESS="${PREPROCESS:-ON}"
CMAKE_ARGUMENTS="${CMAKE_ARGUMENTS:-}"
PTXAS_INFO="${PTXAS_INFO:-OFF}"
BUILD_PPSTEP="${BUILD_PPSTEP:-OFF}"
EXTRACT_INSTANTIATIONS="${EXTRACT_INSTANTIATIONS:-OFF}"
CMAKE_ONLY="${CMAKE_ONLY:-OFF}"
LINK_ONLY="${LINK_ONLY:-OFF}"
COMPILER="${COMPILER:-}"
BUILD_WITH_JAVA="${BUILD_WITH_JAVA:-ON}"


# Type validation specific variables
DEBUG_TYPE_PROFILE="${DEBUG_TYPE_PROFILE:-}"
DEBUG_CUSTOM_TYPES="${DEBUG_CUSTOM_TYPES:-}"
DEBUG_AUTO_REDUCE="${DEBUG_AUTO_REDUCE:-true}"
STRICT_TYPE_VALIDATION="${STRICT_TYPE_VALIDATION:-false}"
SD_TYPES_VALIDATED="${SD_TYPES_VALIDATED:-false}"
SD_VALIDATED_TYPES="${SD_VALIDATED_TYPES:-}"

# =============================================================================
# COMMAND LINE ARGUMENT PARSING
# =============================================================================

while [[ $# -gt 0 ]]
do
    key="$1"
    value="${2:-}"

    case $key in
         --extract-instantiations)
        EXTRACT_INSTANTIATIONS="$value"
        print_colored "blue" "✓ Template instantiation extraction enabled"
        print_colored "yellow" "Build will extract instantiations and exit"
        shift # past argument
        ;;

        -dt|--datatypes)
            DATATYPES="$value"
            print_colored "green" "✓ Detected datatypes argument: $value"
            shift # past argument
            ;;
        --dataypes|--dataype|--datatype)
            print_colored "red" "❌ ERROR: Invalid argument '$key'"
            print_colored "red" "    Did you mean '--datatypes' or '-dt'?"
            print_colored "yellow" "    Correct usage: --datatypes \"float32;double;int32;int64\""
            exit 1
            ;;
        --debug-type-profile)
            DEBUG_TYPE_PROFILE="$value"
            print_colored "blue" "✓ Detected debug profile: $value"
            shift # past argument
            ;;
        --debug-custom-types)
            DEBUG_CUSTOM_TYPES="$value"
            shift # past argument
            ;;
        --debug-auto-reduce)
            DEBUG_AUTO_REDUCE="$value"
            shift # past argument
            ;;
        --strict-types)
            STRICT_TYPE_VALIDATION="true"
            shift # past argument
            ;;
        --show-types)
            show_available_types
            exit 0
            ;;
        --validate-types)
            if [[ -n "$value" ]]; then
                validate_types "$value" "strict"
                exit $?
            else
                print_colored "red" "ERROR: --validate-types requires a type list"
                exit 1
            fi
            ;;

        # Build configuration arguments
        --generate-flatc)
            export GENERATE_FLATC="ON"
            CMAKE_ARGUMENTS="$CMAKE_ARGUMENTS -DGENERATE_FLATC=ON"
            shift # past argument
            ;;
        -ptxas|--ptxas-info)
            PTXAS_INFO="$value"
            shift # past argument
            ;;
        -ol|--optimization-level)
            OPTIMIZATION_LEVEL="$value"
            shift # past argument
            ;;
        -pi|--print-indices)
            PRINT_INDICES="$value"
            shift # past argument
            ;;
        -pm|--print-math)
            PRINT_MATH="$value"
            shift # past argument
            ;;
        -h|--helper)
            HELPER="$value"
            shift # past argument
            ;;
        -o|-platform|--platform)
            OS="$value"
            shift # past argument
            ;;
        -ft|-functrace|--functrace)
            FUNC_TRACE="$value"
            if [[ "$value" == "ON" ]]; then
                print_colored "cyan" "✓ Function tracing enabled"
            fi
            shift # past argument
            ;;
        -b|--build-type)
            BUILD="$value"
            shift # past argument
            ;;
        --compiler|-compiler)
            COMPILER="$value"
            print_colored "blue" "✓ Compiler set to: $value"
            shift # past argument
            ;;
        -p|--packaging)
            PACKAGING="$value"
            shift # past argument
            ;;
        -kno|--keep-nvcc-output)
            KEEP_NVCC="$value"
            shift # past argument
            ;;
        -c|--chip)
            CHIP="$value"
            shift # past argument
            ;;
        -cc|--compute)
            COMPUTE="$value"
            echo COMPUTE="$value"
            shift # past argument
            ;;
        -a|--arch)
            ARCH="$value"
            shift # past argument
            ;;
        -l|--libtype)
            LIBTYPE="$value"
            shift # past argument
            ;;
        -e|--chip-extension)
            CHIP_EXTENSION="$value"
            shift # past argument
            ;;
        -v|--chip-version)
            CHIP_VERSION="$value"
            shift # past argument
            ;;
        -op|--operations)
            OPERATIONS="$value"
            shift # past argument
            ;;
        --use_lto)
            USE_LTO="-DSD_USE_LTO=$value"
            shift # past argument
            ;;
        --name)
            NAME="$value"
            shift # past argument
            ;;
        --check-vectorization)
            CHECK_VECTORIZATION="$value"
            shift # past argument
            ;;
        -j)
            MAKEJ="$value"
            shift # past argument
            ;;
        clean)
            CLEAN="true"
            shift # past argument
            ;;
        -m|--minifier)
            MINIFIER="true"
            shift # past argument
            ;;
        -t|--tests)
            TESTS="true"
            shift # past argument
            ;;
        -V|--verbose)
            VERBOSE="true"
            shift # past argument
            ;;
        -l|--log-output)
            LOG_OUTPUT="$value"
            shift # past argument
            ;;
        -sa|--sanitize)
            SANITIZE="$value"
            shift # past argument
            ;;
        -sar|--sanitizers)
            SANITIZERS="$value"
            shift # past argument
            ;;
        -of|--op-output-file)
            OP_OUTPUT_FILE="$value"
            shift # past argument
            ;;
          --preprocess)
            PREPROCESS="$value"
            shift # past argument
            ;;
        --ppstep|--build-ppstep)
            BUILD_PPSTEP="$value"
            shift # past argument
            ;;
        --cmake-only|--configure-only)
            CMAKE_ONLY="$value"
            print_colored "blue" "✓ CMake-only mode enabled - will exit after configuration"
            shift # past argument
            ;;
        --link-only)
            LINK_ONLY="$value"
            print_colored "blue" "✓ Link-only mode enabled - will skip compilation and only relink"
            shift # past argument
            ;;
        --dry-run)
            # Handle both "--dry-run" (no value) and "--dry-run ON" (with value)
            if [[ "$value" == "ON" ]] || [[ "$value" == "OFF" ]]; then
                DRY_RUN="$value"
                shift # past argument
            else
                DRY_RUN="ON"
            fi
            if [ "$DRY_RUN" == "ON" ]; then
                print_colored "blue" "✓ Dry-run mode enabled - will run preflight checks and CMake, then exit"
            fi
            shift # past argument
            ;;
        --default)
            DEFAULT=YES
            shift # past argument
            ;;
        *)
            # unknown option
            shift # past argument
            ;;
    esac
done

# =============================================================================
# POST-ARGUMENT PROCESSING AND TYPE VALIDATION
# =============================================================================

print_colored "blue" "\n🔍 PROCESSING TYPE CONFIGURATION"

USER_EXPLICIT_DATATYPES="$DATATYPES"

# Handle debug builds with auto-reduction
if [[ "$FUNC_TRACE" == "ON" && "$DEBUG_AUTO_REDUCE" == "true" ]]; then
    print_colored "cyan" "=== DEBUG BUILD TYPE REDUCTION ACTIVE ==="

    if [[ -n "$DEBUG_TYPE_PROFILE" ]]; then
        RESOLVED_TYPES=$(resolve_debug_types "$DEBUG_TYPE_PROFILE" "$DEBUG_CUSTOM_TYPES")
        if [[ $? -eq 0 ]]; then
            # FIXED: Only override DATATYPES if it wasn't explicitly set by user
            if [[ -z "$USER_EXPLICIT_DATATYPES" ]]; then
                DATATYPES="$RESOLVED_TYPES"
                print_colored "green" "Auto-applied debug profile: $DEBUG_TYPE_PROFILE"
                print_colored "cyan" "Profile resolved to: $DATATYPES"
            else
                print_colored "yellow" "⚠️  Debug profile specified but datatypes already set"
                print_colored "yellow" "    Using explicit datatypes: $USER_EXPLICIT_DATATYPES"
                print_colored "yellow" "    Ignoring profile: $DEBUG_TYPE_PROFILE"
                DATATYPES="$USER_EXPLICIT_DATATYPES"
            fi
        else
            exit 1
        fi
    elif [[ -z "$USER_EXPLICIT_DATATYPES" ]]; then
        # No types specified and no profile - use minimal safe default
        DATATYPES=$(resolve_debug_types "MINIMAL_INDEXING" "")
        print_colored "yellow" "Auto-selected MINIMAL_INDEXING profile for debug build"
        print_colored "cyan" "Resolved to: $DATATYPES"
    else
        print_colored "green" "Using explicitly specified datatypes for debug build: $USER_EXPLICIT_DATATYPES"
        DATATYPES="$USER_EXPLICIT_DATATYPES"
    fi

    print_colored "cyan" "============================================="
fi


# Determine validation mode
validation_mode="normal"
if [[ "$FUNC_TRACE" == "ON" ]]; then
    validation_mode="debug"
fi
if [[ "$STRICT_TYPE_VALIDATION" == "true" ]]; then
    validation_mode="strict"
fi

# MANDATORY type validation
print_colored "blue" "\n🔍 MANDATORY TYPE VALIDATION"

if [[ -n "$DATATYPES" && "$DATATYPES" != "all" && "$DATATYPES" != "ALL" ]]; then
    print_colored "cyan" "Validating specified datatypes: $DATATYPES"

    if ! validate_types "$DATATYPES" "$validation_mode"; then
        print_colored "red" "\n💥 BUILD HALTED: Type validation failed!"
        print_colored "yellow" "Use --show-types to see available types"
        exit 1
    fi

    # Show build impact and summary
    estimate_build_impact "$DATATYPES" "$BUILD"
    show_type_summary "$DATATYPES" "$BUILD" "$DEBUG_TYPE_PROFILE"

    # Export validated types to CMake
    export SD_TYPES_VALIDATED="true"
    export SD_VALIDATED_TYPES="$DATATYPES"
    DATATYPES_ARG="-DSD_TYPES_LIST=\"$DATATYPES\" -DSD_TYPES_VALIDATED=true"

    print_colored "green" "✓ Passing validated types to CMake: $DATATYPES"

else
    # Building with ALL types
    print_colored "cyan" "No selective datatypes specified - building with ALL types"
    show_type_summary "" "$BUILD" "$DEBUG_TYPE_PROFILE"

    export SD_TYPES_VALIDATED="false"
    export SD_VALIDATED_TYPES=""
    DATATYPES_ARG=""

    print_colored "cyan" "✓ Building with ALL types (default)"
fi

# Ensure CMake uses our validated types
CMAKE_ARGUMENTS="$CMAKE_ARGUMENTS $DATATYPES_ARG"

# Add strict validation mode to CMake if enabled
if [[ "$STRICT_TYPE_VALIDATION" == "true" ]]; then
    CMAKE_ARGUMENTS="$CMAKE_ARGUMENTS -DSD_STRICT_TYPE_VALIDATION=ON"
fi

# Add debug configuration
if [[ "$FUNC_TRACE" == "ON" ]]; then
    CMAKE_ARGUMENTS="$CMAKE_ARGUMENTS -DSD_GCC_FUNCTRACE=ON"
fi

# Final validation check
print_colored "blue" "\n🔍 FINAL PRE-BUILD VALIDATION"

# Show the actual configuration being used
if [[ "${SD_TYPES_VALIDATED:-false}" == "true" ]]; then
    print_colored "green" "✓ Types have been validated: ${SD_VALIDATED_TYPES:-none}"
    print_colored "cyan" "✓ Building with SELECTIVE types"
else
    print_colored "cyan" "✓ Building with ALL types (default)"
fi

# Show what's being passed to CMake
if [[ -n "$DATATYPES_ARG" ]]; then
    print_colored "cyan" "CMake will receive validated types: $DATATYPES_ARG"
else
    print_colored "cyan" "CMake will receive: (all types - no type restrictions)"
fi

print_colored "green" "✓ All validations passed -"
print_colored "cyan" "=====================================\n"

print_colored "green" "\n✅ Type validation completed - proceeding with build"

if [ "$FUNC_TRACE" == "ON" ] && [ "$DEBUG_AUTO_REDUCE" == "true" ]; then
    echo "=== DEBUG BUILD TYPE REDUCTION ACTIVE ==="

    if [ -n "$DEBUG_TYPE_PROFILE" ]; then
        RESOLVED_TYPES=$(resolve_debug_types "$DEBUG_TYPE_PROFILE" "$DEBUG_CUSTOM_TYPES")
        # FIXED: Only use profile if no explicit datatypes were set
        if [ -z "$DATATYPES" ]; then
            DATATYPES="$RESOLVED_TYPES"
            echo "Debug Profile: $DEBUG_TYPE_PROFILE"
            echo "Resolved Types: $DATATYPES"
        else
            echo "Debug Profile: $DEBUG_TYPE_PROFILE (IGNORED - explicit datatypes set)"
            echo "Using explicit datatypes: $DATATYPES"
        fi
    elif [ -z "$DATATYPES" ]; then
        # No types specified and no profile - use minimal safe default
        DATATYPES=$(resolve_debug_types "MINIMAL_INDEXING" "")
        echo "Auto-selected MINIMAL_INDEXING profile for debug build"
        echo "Types: $DATATYPES"
    fi

    echo "============================================="
fi

HOST=$(uname -s | tr [A-Z] [a-z])
KERNEL=$HOST-$(uname -m | tr [A-Z] [a-z])

if [ "$(uname)" == "Darwin" ]; then
    HOST="macosx"
    KERNEL="darwin-x86_64"
    echo "RUNNING OSX CLANG"
elif [ "$(expr substr $(uname -s) 1 5)" == "MINGW" ] || [ "$(expr substr $(uname -s) 1 4)" == "MSYS" ]; then
    HOST="windows"
    KERNEL="windows-x86_64"
    echo "Running windows"
elif [ "$(uname -m)" == "ppc64le" ]; then
    if [ -z "$ARCH" ]; then
        ARCH="power8"
    fi
    KERNEL="linux-ppc64le"
fi

if [ -z "$OS" ]; then
    OS="$HOST"
fi

if [[ -z ${ANDROID_NDK:-} ]]; then
    export ANDROID_NDK=$HOME/Android/android-ndk/
fi

case "$OS" in
    linux-armhf)
        if [ -z "$ARCH" ]; then
            ARCH="armv7-a"
        fi
        if [ ! -z ${RPI_BIN+set} ]; then
            export CMAKE_COMMAND="$CMAKE_COMMAND -D CMAKE_TOOLCHAIN_FILE=cmake/rpi.cmake"
        fi
        export CMAKE_COMMAND="$CMAKE_COMMAND -DSD_ARM_BUILD=true -DSD_SANITIZE=OFF "
        ;;
    linux-arm64)
        if [ -z "$ARCH" ]; then
            ARCH="armv8-a"
        fi
        if [ ! -z ${RPI_BIN+set} ]; then
            export CMAKE_COMMAND="$CMAKE_COMMAND -D CMAKE_TOOLCHAIN_FILE=cmake/rpi.cmake"
        fi
        export CMAKE_COMMAND="$CMAKE_COMMAND -DSD_ARM_BUILD=true"
        ;;
    android-arm)
        if [ -z "$ARCH" ]; then
            ARCH="armv7-a"
        fi

        setandroid_defaults

        # Note here for android 32 bit prefix on the binutils is different
        # See https://developer.android.com/ndk/guides/other_build_systems
        export ANDROID_BIN="$ANDROID_NDK/toolchains/arm-linux-androideabi/prebuilt/$KERNEL/"
        export ANDROID_CPP="$ANDROID_NDK/sources/cxx-stl/llvm-libc++/"
        export ANDROID_CC="$ANDROID_NDK/toolchains/llvm/prebuilt/$KERNEL/bin/clang"
        export ANDROID_ROOT="$ANDROID_NDK/platforms/android-$ANDROID_VERSION/arch-arm/"
        export CMAKE_COMMAND="$CMAKE_COMMAND -DCMAKE_TOOLCHAIN_FILE=cmake/android-arm.cmake -DSD_ANDROID_BUILD=true"
        setwindows_msys
        ;;
    android-arm64)
        if [ -z "$ARCH" ]; then
            ARCH="armv8-a"
        fi

        setandroid_defaults

        echo "BUILDING ANDROID ARM with KERNEL $KERNEL"
        export ANDROID_BIN="$ANDROID_NDK/toolchains/aarch64-linux-android-4.9/prebuilt/$KERNEL/"
        export ANDROID_CPP="$ANDROID_NDK/sources/cxx-stl/llvm-libc++/"
        export ANDROID_CC="$ANDROID_NDK/toolchains/llvm/prebuilt/$KERNEL/bin/clang"
        export ANDROID_ROOT="$ANDROID_NDK/platforms/android-$ANDROID_VERSION/arch-arm64/"
        export CMAKE_COMMAND="$CMAKE_COMMAND -DCMAKE_TOOLCHAIN_FILE=cmake/android-arm64.cmake -DSD_ANDROID_BUILD=true"
        setwindows_msys
        ;;
    android-x86)
        if [ -z "$ARCH" ]; then
            ARCH="i686"
        fi

        setandroid_defaults
        export ANDROID_BIN="$ANDROID_NDK/toolchains/arm-linux-androideabi-4.9/prebuilt/$KERNEL/"
        export ANDROID_CPP="$ANDROID_NDK/sources/cxx-stl/llvm-libc++/"
        export ANDROID_CC="$ANDROID_NDK/toolchains/llvm/prebuilt/$KERNEL/bin/clang"
        export ANDROID_ROOT="$ANDROID_NDK/platforms/android-$ANDROID_VERSION/arch-x86/"
        export CMAKE_COMMAND="$CMAKE_COMMAND -DCMAKE_TOOLCHAIN_FILE=cmake/android-x86.cmake -DSD_ANDROID_BUILD=true"
        setwindows_msys
        ;;
    android-x86_64)

        if [ -z "$ARCH" ]; then
            ARCH="x86-64"
        fi
        echo "BUILDING ANDROID x86_64"

        setandroid_defaults


        export ANDROID_BIN="$ANDROID_NDK/toolchains/arm-linux-androideabi-4.9/prebuilt/$KERNEL/"
        export ANDROID_CPP="$ANDROID_NDK/sources/cxx-stl/llvm-libc++/"
        export ANDROID_CC="$ANDROID_NDK/toolchains/llvm/prebuilt/$KERNEL/bin/clang"
        export ANDROID_ROOT="$ANDROID_NDK/platforms/android-$ANDROID_VERSION/arch-x86_64/"
        export CMAKE_COMMAND="$CMAKE_COMMAND -DCMAKE_TOOLCHAIN_FILE=cmake/android-x86_64.cmake -DSD_ANDROID_BUILD=true"
        setwindows_msys
        ;;

    ios-x86_64)
        LIBTYPE="static"
        ARCH="x86-64"
        if xcrun --sdk iphoneos --show-sdk-version &> /dev/null; then
            export IOS_VERSION="$(xcrun --sdk iphoneos --show-sdk-version)"
        else
            export IOS_VERSION="10.3"
        fi
        XCODE_PATH="$(xcode-select --print-path)"
        export IOS_SDK="$XCODE_PATH/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator$IOS_VERSION.sdk"
        export CMAKE_COMMAND="$CMAKE_COMMAND -DCMAKE_TOOLCHAIN_FILE=cmake/ios-x86_64.cmake --debug-trycompile -DSD_IOS_BUILD=true"
        ;;

    ios-x86)
        LIBTYPE="static"
        ARCH="i386"
        if xcrun --sdk iphoneos --show-sdk-version &> /dev/null; then
            export IOS_VERSION="$(xcrun --sdk iphoneos --show-sdk-version)"
        else
            export IOS_VERSION="10.3"
        fi
        XCODE_PATH="$(xcode-select --print-path)"
        export IOS_SDK="$XCODE_PATH/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator$IOS_VERSION.sdk"
        export CMAKE_COMMAND="$CMAKE_COMMAND -DCMAKE_TOOLCHAIN_FILE=cmake/ios-x86.cmake --debug-trycompile -DSD_IOS_BUILD=true"
        ;;

    ios-arm64)
        LIBTYPE="static"
        ARCH="arm64"
        if xcrun --sdk iphoneos --show-sdk-version &> /dev/null; then
            export IOS_VERSION="$(xcrun --sdk iphoneos --show-sdk-version)"
        else
            export IOS_VERSION="10.3"
        fi
        XCODE_PATH="$(xcode-select --print-path)"
        export IOS_SDK="$XCODE_PATH/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS$IOS_VERSION.sdk"
        export CMAKE_COMMAND="$CMAKE_COMMAND -DCMAKE_TOOLCHAIN_FILE=cmake/ios-arm64.cmake --debug-trycompile -DSD_IOS_BUILD=true"
        ;;

    ios-arm)
        LIBTYPE="static"
        ARCH="armv7"
        if xcrun --sdk iphoneos --show-sdk-version &> /dev/null; then
            export IOS_VERSION="$(xcrun --sdk iphoneos --show-sdk-version)"
        else
            export IOS_VERSION="10.3"
        fi
        XCODE_PATH="$(xcode-select --print-path)"
        export IOS_SDK="$XCODE_PATH/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS$IOS_VERSION.sdk"
        export CMAKE_COMMAND="$CMAKE_COMMAND -DCMAKE_TOOLCHAIN_FILE=cmake/ios-arm.cmake --debug-trycompile -DSD_IOS_BUILD=true"
        ;;

    ios-armv7)
        # change those 2 parameters and make sure the IOS_SDK exists
        export iPhoneOS="iPhoneOS"
        export IOS_VERSION="10.3"
        LIBTYPE="static"
        ARCH="armv7"
        export IOS_SDK="/Applications/Xcode.app/Contents/Developer/Platforms/${iPhoneOS}.platform/Developer/SDKs/${iPhoneOS}${IOS_VERSION}.sdk"
        export CMAKE_COMMAND="$CMAKE_COMMAND -DCMAKE_TOOLCHAIN_FILE=cmake/ios-armv7.cmake --debug-trycompile -DSD_IOS_BUILD=true"
        ;;

    linux*)
        ;;

    macosx*)
        export CC=clang
        export CXX=clang++
        PARALLEL="true"
        export CMAKE_COMMAND="$CMAKE_COMMAND -DCMAKE_MACOSX_RPATH=ON -DSD_APPLE_BUILD=true"
        ;;

    windows*)
        # Do something under Windows NT platform
        if [ "$CHIP" == "cuda" ]; then
            export CMAKE_COMMAND="cmake -G \"Ninja\""
            export MAKE_COMMAND="ninja"
            export CC="cl.exe"
            export CXX="cl.exe"
            PARALLEL="true"
            VERBOSE_ARG="-v"
        else
            # NOTE when running windows, do NOT use the gcc compiler in usr/ always use the one in mingw/bin
            # Another note on this particular gcc: ensure the path is setup in msys2 with /c/msys64/mingw64/bin
            # prefixed. If the one in USR is used, errors like error: 'RTLD_LAZY' was not declared in this scope
            # may show up
            export CMAKE_COMMAND="cmake -G \"MSYS Makefiles\""
            export MAKE_COMMAND="make"
            export CC=gcc
            export CXX=g++
            PARALLEL="true"
        fi

        # Try some defaults for Visual Studio 2013 if user has not run vcvarsall.bat or something
        if [ -z "${VCINSTALLDIR:-}" ]; then
            echo "NEED TO SET DEFAULTS FOR VISUAL STUDIO, NO VCINSTALLDIR environment variable found"
            export VisualStudioVersion=12.0
            export VSINSTALLDIR="C:\\Program Files (x86)\\Microsoft Visual Studio $VisualStudioVersion"
            export VCINSTALLDIR="$VSINSTALLDIR\\VC"
            export WindowsSdkDir="C:\\Program Files (x86)\\Windows Kits\\8.1"
            export Platform=X64
            export INCLUDE="$VCINSTALLDIR\\INCLUDE;$WindowsSdkDir\\include\\shared;$WindowsSdkDir\\include\\um"
            export LIB="$VCINSTALLDIR\\LIB\\amd64;$WindowsSdkDir\\lib\\winv6.3\\um\\x64"
            export LIBPATH="$VCINSTALLDIR\\LIB\\amd64;$WindowsSdkDir\\References\\CommonConfiguration\\Neutral"
            export PATH="$PATH:$VCINSTALLDIR\\BIN\\amd64:$WindowsSdkDir\\bin\\x64:$WindowsSdkDir\\bin\\x86"
        fi
        # Make sure we are using 64-bit MinGW-w64
        export PATH=/mingw64/bin/:/mingw64/lib:$PATH
        # export GENERATOR="MSYS Makefiles"
        ;;
esac

if [ -v OPENBLAS_PATH ]; then
  echo "OPENBLAS_PATH is set."
else
  OPENBLAS_PATH=""
fi

# Fixed auto-detection for Android and ARM platforms
if [[ -z "$OPENBLAS_PATH" ]]; then
    JAVACPP_CACHE="$HOME/.javacpp/cache"
    if [[ -d "$JAVACPP_CACHE" ]]; then
        # Determine platform-specific JAR patterns based on OS variable
        case "$OS" in
            android-x86_64)
                JAR_PATTERNS=("openblas-*-android-x86_64.jar" "openblas-*-linux-x86_64.jar")
                OPENBLAS_SUBPATHS=("android-x86_64" "linux-x86_64")
                ;;
            android-arm64)
                JAR_PATTERNS=("openblas-*-android-arm64.jar" "openblas-*-linux-arm64.jar" "openblas-*-android-aarch64.jar" "openblas-*-linux-aarch64.jar")
                OPENBLAS_SUBPATHS=("android-arm64" "linux-arm64" "android-aarch64" "linux-aarch64")
                ;;
            linux-arm64)
                JAR_PATTERNS=("openblas-*-linux-arm64.jar" "openblas-*-linux-aarch64.jar")
                OPENBLAS_SUBPATHS=("linux-arm64" "linux-aarch64")
                ;;
            *)
                JAR_PATTERNS=("openblas-*-linux-x86_64.jar")
                OPENBLAS_SUBPATHS=("linux-x86_64")
                ;;
        esac

        # Try each pattern until we find a working JAR
        for pattern in "${JAR_PATTERNS[@]}"; do
            OPENBLAS_JAR=$(find "$JAVACPP_CACHE" -name "$pattern" | head -1)
            if [[ -n "$OPENBLAS_JAR" ]]; then
                # Try each subpath until we find cblas.h
                for subpath in "${OPENBLAS_SUBPATHS[@]}"; do
                    if [[ -f "$OPENBLAS_JAR/org/bytedeco/openblas/$subpath/include/cblas.h" ]]; then
                        export OPENBLAS_PATH="$OPENBLAS_JAR/org/bytedeco/openblas/$subpath"
                        echo "✅ Auto-detected OPENBLAS_PATH for $OS: $OPENBLAS_PATH"
                        break 2
                    fi
                done
            fi
        done

        if [[ -z "$OPENBLAS_PATH" ]]; then
            echo "⚠️  Could not auto-detect OpenBLAS for $OS platform"
        fi
    fi
fi


if [ ! -d "include/generated" ]; then
    mkdir -p "include/generated"
fi

if [ -f "$OP_OUTPUT_FILE" ]; then
    rm -f "${OP_OUTPUT_FILE}"
fi

if [ -z "$BUILD" ]; then
    BUILD="release"
fi

if [ -z "$CHIP" ]; then
    CHIP="cpu"
fi

if [ -z "$LIBTYPE" ]; then
    LIBTYPE="dynamic"
fi

if [ -z "$PACKAGING" ]; then
    PACKAGING="none"
fi

SOURCE_PATH="$DIR"
BUILD_DIR="$DIR/blasbuild/$CHIP"

export CMAKE_COMMAND="$CMAKE_COMMAND -DSD_SANITIZE=$SANITIZE -DSD_SANITIZERS=$SANITIZERS"

if [ "$CHIP_EXTENSION" == "avx512" ] || [ "$ARCH" == "avx512" ]; then
    CHIP_EXTENSION="avx512"
    ARCH="skylake-avx512"
elif [ "$CHIP_EXTENSION" == "avx2" ] || [ "$ARCH" == "avx2" ]; then
    CHIP_EXTENSION="avx2"
    ARCH="x86-64"
elif [ "$CHIP_EXTENSION" == "x86_64" ] || [ "$ARCH" == "x86_64" ]; then
    CHIP_EXTENSION="x86_64"
    ARCH="x86-64"
fi

if [ -z "$ARCH" ]; then
    ARCH="x86-64"
fi

if [ -z "$COMPUTE" ]; then
    COMPUTE="all"
fi

# Enable call stacking
if [ "$FUNC_TRACE" == "ON" ]; then
    export CMAKE_COMMAND="$CMAKE_COMMAND -DSD_GCC_FUNCTRACE=ON"
fi

OPERATIONS_ARG=

if [ -z "$OPERATIONS" ]; then
    OPERATIONS_ARG="-DSD_ALL_OPS=true"
else
    OPERATIONS_ARG="-DSD_OPS_LIST=\"$OPERATIONS\" -DSD_ALL_OPS=false"
fi

DATATYPES_ARG=

if [ -n "$DATATYPES" ]; then
    DATATYPES_ARG="-DSD_TYPES_LIST=\"$DATATYPES\""
fi

if [ -z "$EXPERIMENTAL" ]; then
    EXPERIMENTAL="no"
fi

if [ "$CHIP" == "cpu" ]; then
    BLAS_ARG="-DSD_CPU=true -DBLAS=TRUE"
elif [ "$CHIP" == "aurora" ]; then
    BLAS_ARG="-DSD_AURORA=true -DBLAS=TRUE"
elif [ "$CHIP" == "cuda" ]; then
    BLAS_ARG="-DSD_CUDA=true -DBLAS=TRUE"
fi

if [ -z "$NAME" ]; then
    if [ "$CHIP" == "cpu" ]; then
        NAME="nd4jcpu"
    elif [ "$CHIP" == "cuda" ]; then
        NAME="nd4jcuda"
    elif [ "$CHIP" == "aurora" ]; then
        NAME="nd4jaurora"
    fi
fi

if [ "$LIBTYPE" == "dynamic" ]; then
    SHARED_LIBS_ARG="-DSD_SHARED_LIB=ON -DSD_STATIC_LIB=OFF"
else
    SHARED_LIBS_ARG="-DSD_SHARED_LIB=OFF -DSD_STATIC_LIB=ON"
fi

# Set build type
if [ "$FUNC_TRACE" == "ON" ]; then
    BUILD_TYPE="-DCMAKE_BUILD_TYPE=none"
elif [ "$BUILD" == "release" ]; then
    BUILD_TYPE="-DCMAKE_BUILD_TYPE=Release"
else
    BUILD_TYPE="-DCMAKE_BUILD_TYPE=Debug"
fi

if [ "$PACKAGING" == "none" ]; then
    PACKAGING_ARG="-DPACKAGING=none"
fi

if [ "$PACKAGING" == "rpm" ]; then
    PACKAGING_ARG="-DPACKAGING=rpm"
fi

if [ "$PACKAGING" == "deb" ]; then
    PACKAGING_ARG="-DPACKAGING=deb"
fi

if [ "$PACKAGING" == "msi" ]; then
    PACKAGING_ARG="-DPACKAGING=msi"
fi

# Use parent of output file to mean source include directory
OP_OUTPUT_FILE_ARG="-DOP_OUTPUT_FILE=../${OP_OUTPUT_FILE}"

EXPERIMENTAL_ARG=""
MINIFIER_ARG="-DSD_BUILD_MINIFIER=false"
TESTS_ARG="-DSD_BUILD_TESTS=OFF"
NAME_ARG="-DSD_LIBRARY_NAME=$NAME"

if [ "$EXPERIMENTAL" == "yes" ]; then
    EXPERIMENTAL_ARG="-DSD_EXPERIMENTAL=yes"
fi

if [ "$MINIFIER" == "true" ]; then
    MINIFIER_ARG="-DSD_BUILD_MINIFIER=true"
fi

if [ "$TESTS" == "true" ]; then
    MINIFIER_ARG="-DSD_BUILD_MINIFIER=true"
    TESTS_ARG="-DSD_BUILD_TESTS=ON"
fi

ARCH_ARG="-DSD_ARCH=$ARCH -DSD_EXTENSION=$CHIP_EXTENSION"

CUDA_COMPUTE="-DCOMPUTE=\"$COMPUTE\""

if [ "$CHIP" == "cuda" ] && [ -n "$CHIP_VERSION" ]; then
    case $OS in
        linux*)
            if [ "${CUDA_PATH-}" == "" ]; then
                export CUDA_PATH="/usr/local/cuda-$CHIP_VERSION/"
            fi
            ;;
        macosx*)
            export CUDA_PATH="/Developer/NVIDIA/CUDA-$CHIP_VERSION/"
            ;;
        windows*)
            export CUDA_PATH="C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v$CHIP_VERSION/"
            ;;
    esac
fi



mkbuilddir() {
    if [ "$CLEAN" == "true" ]; then
        echo "Removing blasbuild"
        rm -Rf "$DIR/blasbuild"
    fi

    mkdir -p "$BUILD_DIR"
    cd "$BUILD_DIR"
}

HELPERS=""
if [ "$HELPER" == "" ]; then
    echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
    echo "!!                                                                                                           !!"
    echo "!!                                                                                                           !!"
    echo "!!                                                                                                           !!"
    echo "!!                                                                                                           !!"
    echo "!!                                                 WARNING!                                                  !!"
    echo "!!                                      No helper packages configured!                                       !!"
    echo "!!                          You can specify helper by using -h key. I.e. <-h onednn>                         !!"
    echo "!!                                                                                                           !!"
    echo "!!                                                                                                           !!"
    echo "!!                                                                                                           !!"
    echo "!!                                                                                                           !!"
    echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
else
    # If helpers were defined, we'll propagate them to CMake
    IFS=','
    read -ra HLP <<< "$HELPER"
    for i in "${HLP[@]}"; do
        HELPERS="${HELPERS} -DHELPERS_$i=true"
    done
    IFS=' '
fi

echo PACKAGING           = "${PACKAGING}"
echo BUILD               = "${BUILD}"
echo CHIP                = "${CHIP}"
echo ARCH                = "${ARCH}"
echo CHIP_EXTENSION      = "${CHIP_EXTENSION}"
echo CHIP_VERSION        = "${CHIP_VERSION}"
echo GPU_COMPUTE_CAPABILITY = "${COMPUTE}"
echo EXPERIMENTAL        = "${EXPERIMENTAL}"
echo LIBRARY TYPE        = "${LIBTYPE}"
echo OPERATIONS          = "${OPERATIONS_ARG}"
echo DATATYPES           = "${DATATYPES_ARG}"
echo MINIFIER            = "${MINIFIER_ARG}"
echo TESTS               = "${TESTS_ARG}"
echo NAME                = "${NAME_ARG}"
echo OPENBLAS_PATH       = "$OPENBLAS_PATH"
echo CHECK_VECTORIZATION = "$CHECK_VECTORIZATION"
echo HELPERS             = "$HELPERS"
echo OP_OUTPUT_FILE      = "$OP_OUTPUT_FILE"
echo USE_LTO             = "$USE_LTO"
echo SANITIZE            = "$SANITIZE"
echo FUNC_TRACE          = "$FUNC_TRACE"
echo LOG_OUTPUT          = "$LOG_OUTPUT"
echo KEEP_NVCC           = "$KEEP_NVCC"
echo PRINT_INDICES       = "$PRINT_INDICES"
echo PRINT_MATH          = "$PRINT_MATH"
echo PREPROCESS          = "$PREPROCESS"
echo BUILD_PPSTEP        = "$BUILD_PPSTEP"
echo MAKEJ               = "$MAKEJ"
mkbuilddir
pwd

# ----------------------- CMake Configuration -----------------------

# Configure compiler if specified
COMPILER_ARG=""
if [ -n "$COMPILER" ]; then
    case "$COMPILER" in
        clang|clang++)
            COMPILER_ARG="-DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++"
            print_colored "cyan" "Using Clang compiler"
            ;;
        gcc|g++)
            COMPILER_ARG="-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++"
            print_colored "cyan" "Using GCC compiler"
            ;;
        *)
            COMPILER_ARG="-DCMAKE_C_COMPILER=$COMPILER -DCMAKE_CXX_COMPILER=${COMPILER}++"
            print_colored "cyan" "Using custom compiler: $COMPILER"
            ;;
    esac
fi

# Configure CMake
echo "$CMAKE_COMMAND - -DSD_KEEP_NVCC_OUTPUT=$KEEP_NVCC -DSD_GCC_FUNCTRACE=$FUNC_TRACE $BLAS_ARG $ARCH_ARG $NAME_ARG $OP_OUTPUT_FILE_ARG -DSD_SANITIZERS=${SANITIZERS} -DSD_SANITIZE=${SANITIZE} -DSD_CHECK_VECTORIZATION=${CHECK_VECTORIZATION} $USE_LTO $HELPERS $SHARED_LIBS_ARG $MINIFIER_ARG $OPERATIONS_ARG $DATATYPES_ARG $BUILD_TYPE $PACKAGING_ARG $EXPERIMENTAL_ARG $TESTS_ARG $CUDA_COMPUTE -DOPENBLAS_PATH=$OPENBLAS_PATH -DDEV=FALSE -DCMAKE_NEED_RESPONSE=YES -DMKL_MULTI_THREADED=TRUE $COMPILER_ARG $SOURCE_PATH"

# Handle the PREPROCESS flag first - before any build
if [ "$PREPROCESS" == "ON" ]; then
    echo "Running preprocessing step..."
    if [ "$LOG_OUTPUT" == "none" ]; then
        eval "$CMAKE_COMMAND" \
            -DSD_PREPROCESS=ON \
            -DBUILD_PPSTEP="$BUILD_PPSTEP" \
            "$BLAS_ARG" \
            "$ARCH_ARG" \
            "$NAME_ARG" \
            "$OP_OUTPUT_FILE_ARG" \
            -DSD_SANITIZE="${SANITIZE}" \
            -DSD_BUILD_WITH_JAVA="${BUILD_WITH_JAVA}" \
            "$USE_LTO" \
            "$HELPERS" \
            "$SHARED_LIBS_ARG" \
            "$OPERATIONS_ARG" \
            "$DATATYPES_ARG" \
            "$BUILD_TYPE" \
            "$PACKAGING_ARG" \
            "$CUDA_COMPUTE" \
            -DOPENBLAS_PATH="$OPENBLAS_PATH" \
            -DDEV=FALSE \
            -DCMAKE_NEED_RESPONSE=YES \
            -DMKL_MULTI_THREADED=TRUE \
            $COMPILER_ARG \
            "$SOURCE_PATH"
    else
        eval "$CMAKE_COMMAND" \
            -DSD_PREPROCESS=ON \
            -DBUILD_PPSTEP="$BUILD_PPSTEP" \
            "$BLAS_ARG" \
            "$ARCH_ARG" \
            "$NAME_ARG" \
            "$OP_OUTPUT_FILE_ARG" \
            -DSD_SANITIZE="${SANITIZE}" \
            -DSD_BUILD_WITH_JAVA="${BUILD_WITH_JAVA}" \
            "$USE_LTO" \
            "$HELPERS" \
            "$SHARED_LIBS_ARG" \
            "$OPERATIONS_ARG" \
            "$DATATYPES_ARG" \
            "$BUILD_TYPE" \
            "$PACKAGING_ARG" \
            "$CUDA_COMPUTE" \
            -DOPENBLAS_PATH="$OPENBLAS_PATH" \
            -DDEV=FALSE \
            -DCMAKE_NEED_RESPONSE=YES \
            -DMKL_MULTI_THREADED=TRUE \
            $COMPILER_ARG \
            "$SOURCE_PATH" >> "$LOG_OUTPUT" 2>&1
    fi
    echo "Preprocessing complete - exiting"
    exit 0
fi

# For dry-run mode: Clear cache before cmake runs, then set CMAKE_ONLY to exit after cmake
if [ "$DRY_RUN" == "ON" ]; then
    print_colored "blue" "=========================================="
    print_colored "blue" "DRY RUN MODE - CMake Configuration Only"
    print_colored "blue" "=========================================="
    echo

    # Clear CMake cache to ensure fresh configuration
    BLASBUILD_DIR="$DIR/blasbuild/${CHIP}"
    if [ -d "$BLASBUILD_DIR" ]; then
        print_colored "yellow" "Clearing CMake cache for fresh configuration..."
        rm -rf "$BLASBUILD_DIR/CMakeCache.txt" "$BLASBUILD_DIR/CMakeFiles"
        print_colored "green" "✅ Cache cleared"
        echo
    fi

    print_colored "cyan" "CMake will now configure the build..."
    echo

    # Set CMAKE_ONLY to exit after CMake completes (and run validation then)
    CMAKE_ONLY="ON"
fi
# Normal build path
if [ "$LOG_OUTPUT" == "none" ]; then
    eval "$CMAKE_COMMAND" \
        -DPRINT_MATH="$PRINT_MATH" \
        -DPRINT_INDICES="$PRINT_INDICES" \
        -DSD_KEEP_NVCC_OUTPUT="$KEEP_NVCC" \
        -DSD_GCC_FUNCTRACE="$FUNC_TRACE" \
        -DSD_PTXAS="$PTXAS_INFO" \
        -DSD_EXTRACT_INSTANTIATIONS="$EXTRACT_INSTANTIATIONS" \
        -DSD_PARALLEL_COMPILE_JOBS="${MAKEJ}" \
        "$BLAS_ARG" \
        "$ARCH_ARG" \
        "$NAME_ARG" \
        "$OP_OUTPUT_FILE_ARG" \
        -DSD_SANITIZE="${SANITIZE}" \
        -DSD_CHECK_VECTORIZATION="${CHECK_VECTORIZATION}" \
        -DSD_BUILD_WITH_JAVA="${BUILD_WITH_JAVA}" \
        "$USE_LTO" \
        "$HELPERS" \
        "$SHARED_LIBS_ARG" \
        "$MINIFIER_ARG" \
        "$OPERATIONS_ARG" \
        "$DATATYPES_ARG" \
        "$BUILD_TYPE" \
        "$PACKAGING_ARG" \
        "$TESTS_ARG" \
        "$CUDA_COMPUTE" \
        -DOPENBLAS_PATH="$OPENBLAS_PATH" \
        -DDEV=FALSE \
        -DCMAKE_NEED_RESPONSE=YES \
        -DMKL_MULTI_THREADED=TRUE \
        $COMPILER_ARG \
        "$SOURCE_PATH"
else
    eval "$CMAKE_COMMAND" \
        -DPRINT_MATH="$PRINT_MATH" \
        -DPRINT_INDICES="$PRINT_INDICES" \
        -DSD_KEEP_NVCC_OUTPUT="$KEEP_NVCC" \
        -DSD_GCC_FUNCTRACE="$FUNC_TRACE" \
        -DSD_PTXAS="$PTXAS_INFO" \
        -DSD_EXTRACT_INSTANTIATIONS="$EXTRACT_INSTANTIATIONS" \
        -DSD_PARALLEL_COMPILE_JOBS="${MAKEJ}" \
        "$BLAS_ARG" \
        "$ARCH_ARG" \
        "$NAME_ARG" \
        "$OP_OUTPUT_FILE_ARG" \
        -DSD_SANITIZE="${SANITIZE}" \
        -DSD_CHECK_VECTORIZATION="${CHECK_VECTORIZATION}" \
        -DSD_BUILD_WITH_JAVA="${BUILD_WITH_JAVA}" \
        "$USE_LTO" \
        "$HELPERS" \
        "$SHARED_LIBS_ARG" \
        "$MINIFIER_ARG" \
        "$OPERATIONS_ARG" \
        "$DATATYPES_ARG" \
        "$BUILD_TYPE" \
        "$PACKAGING_ARG" \
        "$TESTS_ARG" \
        "$CUDA_COMPUTE" \
        -DOPENBLAS_PATH="$OPENBLAS_PATH" \
        -DDEV=FALSE \
        -DCMAKE_NEED_RESPONSE=YES \
        -DMKL_MULTI_THREADED=TRUE \
        $COMPILER_ARG \
        "$SOURCE_PATH" >> "$LOG_OUTPUT" 2>&1
fi


if [[ "$EXTRACT_INSTANTIATIONS" == "ON" ]]; then
    INST_DIR="${DIR}/blasbuild/${CHIP}/instantiation_analysis"
    
    # Always create the directory structure if it doesn't exist
    mkdir -p "$INST_DIR/reports"
    
    # Create a simple report even if no data was collected
    if [[ ! -f "$INST_DIR/all_missing.txt" ]]; then
        echo "No missing templates detected" > "$INST_DIR/all_missing.txt"
    fi
    if [[ ! -f "$INST_DIR/all_used.txt" ]]; then
        echo "No template usage data collected" > "$INST_DIR/all_used.txt"
    fi
    if [[ ! -f "$INST_DIR/all_provided.txt" ]]; then
        echo "No template provision data collected" > "$INST_DIR/all_provided.txt"
    fi
    
    # Generate a simple summary
    echo "=== Template Instantiation Analysis Complete ===" > "$INST_DIR/reports/summary.txt"
    echo "Date: $(date)" >> "$INST_DIR/reports/summary.txt"
    echo "Missing: $(wc -l < "$INST_DIR/all_missing.txt" 2>/dev/null || echo 0)" >> "$INST_DIR/reports/summary.txt"
    echo "Used: $(wc -l < "$INST_DIR/all_used.txt" 2>/dev/null || echo 0)" >> "$INST_DIR/reports/summary.txt"
    echo "Provided: $(wc -l < "$INST_DIR/all_provided.txt" 2>/dev/null || echo 0)" >> "$INST_DIR/reports/summary.txt"
    
    cat "$INST_DIR/reports/summary.txt"
    
    # Exit after extraction
    exit 0
fi


# IMPORTANT: CMake invocations happen below (lines ~1465-1550)
# The CMAKE_ONLY check must come AFTER those invocations

# Exit if cmake-only mode is enabled (this runs AFTER cmake completes)
if [ "$CMAKE_ONLY" == "ON" ]; then
    print_colored "green" "✅ CMake configuration completed - exiting without build"
    print_colored "cyan" "=== CMAKE CONFIGURATION SUMMARY ==="
    print_colored "cyan" "Build directory: $(pwd)"
    print_colored "cyan" "To inspect CMake cache: cmake -L"
    print_colored "cyan" "To inspect specific values: cmake -LA | grep <pattern>"
    print_colored "cyan" "To run build manually: $MAKE_COMMAND"
    echo

    # If this was a dry-run, run post-cmake validation
    if [ "$DRY_RUN" == "ON" ] && [ -d "$DIR/preflight-checks" ] && [ -x "$DIR/preflight-checks/validate_build_config.sh" ]; then
        echo
        print_colored "blue" "=========================================="
        print_colored "blue" "Running Post-CMake Validation"
        print_colored "blue" "=========================================="
        echo

        cd "$DIR/preflight-checks"
        if ./validate_build_config.sh --stage cmake --chip "$CHIP"; then
            print_colored "green" "✅ Configuration validation passed"
            echo
            print_colored "cyan" "Build configuration is ready!"
            print_colored "cyan" "To start the actual build, run:"
            print_colored "cyan" "  ./buildnativeoperations.sh <same-arguments-without-dry-run>"
        else
            print_colored "red" "❌ Configuration validation failed"
            print_colored "yellow" "Fix the issues above before building"
            exit 1
        fi
    else
        print_colored "yellow" "NEXT STEPS FOR SMOKE TEST:"
        print_colored "yellow" "1. Check CMake cache: cd blasbuild/${CHIP} && cmake -LA"
        print_colored "yellow" "2. Verify type configuration: grep 'SD_TYPES_LIST\\|SD_SELECTIVE_TYPES' CMakeCache.txt"
        print_colored "yellow" "3. Check selective rendering: cat include/system/selective_rendering.h | head -50"
        print_colored "yellow" "4. If values look correct, run build: cd ../.. && ./buildnativeoperations.sh"
    fi
    echo
    exit 0
fi


# =============================================================================
# HELPER FUNCTIONS
# =============================================================================

# Function to check template instantiation status
check_instantiation_status() {
    local inst_dir="instantiation_analysis"
    
    if [[ ! -d "$inst_dir" ]]; then
        print_colored "yellow" "No instantiation analysis found. Run with --extract-instantiations"
        return 1
    fi
    
    if [[ -f "$inst_dir/all_missing.txt" ]]; then
        local missing_count=$(wc -l < "$inst_dir/all_missing.txt")
        if [[ $missing_count -gt 0 ]]; then
            print_colored "red" "⚠️  $missing_count missing template instantiations from last analysis"
            print_colored "yellow" "Run with --extract-instantiations for updated analysis"
            return 1
        fi
    fi
    
    return 0
}

# Function to apply instantiation fixes
apply_instantiation_fixes() {
    local fixes_dir="instantiation_analysis/fixes"
    
    if [[ ! -d "$fixes_dir" ]]; then
        print_colored "yellow" "No instantiation fixes available"
        return 1
    fi
    
    if [[ -f "$fixes_dir/missing_instantiations.cpp" ]]; then
        print_colored "cyan" "Found instantiation fix file"
        # Add to source list or copy to appropriate location
        # This depends on your build system setup
        return 0
    fi
    
    return 1
}

# =============================================================================
# USAGE EXAMPLES
# =============================================================================

show_instantiation_help() {
    cat << EOF

TEMPLATE INSTANTIATION ANALYSIS OPTIONS:
  --extract-instantiations    Extract template usage and instantiation data
  --generate-fix-files        Generate C++ files to fix missing instantiations  
  --instantiation-report      Generate detailed HTML analysis report
  --instantiation-verbose     Enable verbose output during analysis
  --analyze-templates         Quick mode: analyze and generate report, then exit

EXAMPLES:
  # Basic analysis
  ./build.sh --extract-instantiations
  
  # Analysis with specific datatypes
  ./build.sh --extract-instantiations --datatypes "float32;double;int32;int64"
  
  # Generate fixes for missing instantiations
  ./build.sh --generate-fix-files
  
  # Full analysis with report
  ./build.sh --analyze-templates --datatypes "float32;double"
  
  # Check status of last analysis
  ./build.sh --check-instantiations

WORKFLOW:
  1. Run analysis: ./build.sh --extract-instantiations
  2. Check results in instantiation_analysis/
  3. If missing instantiations found, generate fixes:
     ./build.sh --generate-fix-files
  4. Add generated fix file to your build
  5. Rebuild normally

EOF
}
# Build the project


if [ "$BUILD_PPSTEP" == "ON" ]; then
    print_colored "cyan" "Building ppstep preprocessor tool..."
    
    if [ "$LOG_OUTPUT" == "none" ]; then
        eval "$CMAKE_COMMAND" \
            -DBUILD_PPSTEP=ON \
            "$BLAS_ARG" \
            "$ARCH_ARG" \
            "$NAME_ARG" \
            -DOPENBLAS_PATH="$OPENBLAS_PATH" \
            $COMPILER_ARG \
            "$SOURCE_PATH"
    else
        eval "$CMAKE_COMMAND" \
            -DBUILD_PPSTEP=ON \
            "$BLAS_ARG" \
            "$ARCH_ARG" \
            "$NAME_ARG" \
            -DOPENBLAS_PATH="$OPENBLAS_PATH" \
            $COMPILER_ARG \
            "$SOURCE_PATH" >> "$LOG_OUTPUT" 2>&1
    fi
    
    # Build ppstep
    if [ "$LOG_OUTPUT" == "none" ]; then
        eval "$MAKE_COMMAND" ppstep
    else
        eval "$MAKE_COMMAND" ppstep >> "$LOG_OUTPUT" 2>&1
    fi
    
    print_colored "green" "✅ ppstep build complete"
    print_colored "cyan" "Wrapper created at: blasbuild/$CHIP/ppstep-nd4j"
    echo "Usage: ./blasbuild/$CHIP/ppstep-nd4j <source_file.cpp>"
    
    # CRITICAL: EXIT EARLY like preprocess does
    exit 0
fi


# Link-only mode: skip compilation, only relink
if [ "$LINK_ONLY" == "ON" ]; then
    print_colored "cyan" "═══════════════════════════════════════════════════════════"
    print_colored "cyan" "LINK-ONLY MODE: Skipping compilation, relinking only"
    print_colored "cyan" "═══════════════════════════════════════════════════════════"

    # Check if build directory and objects exist
    if [ ! -d "blasbuild/$CHIP" ]; then
        print_colored "red" "❌ ERROR: Build directory blasbuild/$CHIP does not exist"
        print_colored "yellow" "   You must run a full build first before using --link-only"
        exit 1
    fi

    cd blasbuild/$CHIP

    # Check if object files exist
    OBJ_COUNT=$(find . -name "*.o" 2>/dev/null | wc -l)
    if [ "$OBJ_COUNT" -eq 0 ]; then
        print_colored "red" "❌ ERROR: No object files found in blasbuild/$CHIP"
        print_colored "yellow" "   You must run a full build first before using --link-only"
        cd ../..
        exit 1
    fi

    print_colored "green" "✓ Found $OBJ_COUNT compiled object files"
    print_colored "cyan" "Building library target only (no compilation)..."

    # Determine the library target name based on chip type
    if [ "$CHIP" == "cpu" ]; then
        LINK_TARGET="nd4jcpu"
    elif [ "$CHIP" == "cuda" ]; then
        LINK_TARGET="nd4jcuda"
    else
        LINK_TARGET="nd4j${CHIP}"
    fi

    print_colored "cyan" "Linking target: $LINK_TARGET"

    # Run make with the specific target (CMake will skip up-to-date compilation)
    if [ "$LOG_OUTPUT" == "none" ]; then
        eval "$MAKE_COMMAND" "$LINK_TARGET" && cd ../../..
    else
        eval "$MAKE_COMMAND" "$LINK_TARGET" >> "$LOG_OUTPUT" 2>&1 && cd ../../..
    fi

    LINK_EXIT_CODE=$?

    if [ $LINK_EXIT_CODE -eq 0 ]; then
        print_colored "green" "═══════════════════════════════════════════════════════════"
        print_colored "green" "✅ LINK-ONLY BUILD COMPLETE"
        print_colored "green" "═══════════════════════════════════════════════════════════"
        print_colored "cyan" "Library: blasbuild/$CHIP/lib${LINK_TARGET}.so"
        print_colored "yellow" "Note: Only linking was performed. No source files were recompiled."
    else
        print_colored "red" "═══════════════════════════════════════════════════════════"
        print_colored "red" "❌ LINK FAILED (exit code: $LINK_EXIT_CODE)"
        print_colored "red" "═══════════════════════════════════════════════════════════"
        exit $LINK_EXIT_CODE
    fi

    # Continue with post-build steps (flatc copy if needed)
    # Don't exit here - let the script continue to the flatc section
else
    # Normal build mode: full compilation and linking
    # Determine script location
    if [ "$LOG_OUTPUT" == "none" ]; then
        eval "$MAKE_COMMAND" "$MAKE_ARGUMENTS" && cd ../../..
    else
        eval "$MAKE_COMMAND" "$MAKE_ARGUMENTS" >> "$LOG_OUTPUT" 2>&1 && cd ../../..
    fi
fi

# Determine script location
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
# Find the libnd4j directory
if [[ "$SCRIPT_DIR" == */libnd4j* ]]; then
    # Already in or under libnd4j directory
    LIBND4J_DIR=$(echo "$SCRIPT_DIR" | sed 's/\(.*libnd4j\).*/\1/')
else
    # Check if we're in the parent deeplearning4j directory
    if [ -d "$SCRIPT_DIR/libnd4j" ]; then
        LIBND4J_DIR="$SCRIPT_DIR/libnd4j"
    else
        # Try going up one directory to see if libnd4j is there
        if [ -d "$SCRIPT_DIR/../libnd4j" ]; then
            LIBND4J_DIR="$SCRIPT_DIR/../libnd4j"
        else
            echo "Error: Could not locate libnd4j directory"
            exit 1
        fi
    fi
fi

# Save the original directory before potentially changing directories
ORIGINAL_DIR=$(pwd)

# cd to the script directory for the operations that need to be performed there
cd "$SCRIPT_DIR"

if [ "$GENERATE_FLATC" == "ON" ]; then
    echo "Copying flatc generated for java"
    # ensure proper flatc sources are in place
    bash "$LIBND4J_DIR/copy-flatc-java.sh"
fi

# Return to the original directory where the script was launched from
cd "$ORIGINAL_DIR"

echo "Build process completed successfully."