cmake_minimum_required(VERSION 3.20)

project(ling3_rknn VERSION 0.1.0 LANGUAGES CXX)

option(LING3_WITH_RKNN "Build the direct RKNN backend" OFF)
option(LING3_EXPERIMENTAL_MTP "Build experimental NEXTN/MTP probes (not production decoding)" OFF)
option(LING3_TUNE_A76 "Tune release builds for Cortex-A76" ON)
option(LING3_WITH_ICU "Use ICU for exact tokenizer normalization and splitting" ON)
set(RKNN_ROOT "" CACHE PATH "Local RKNPU2 root from https://github.com/airockchip/rknpu2 (contains include/ and lib/)")

add_library(ling3_core STATIC
    src/core_workers.cpp
    src/cpu_kernels.cpp
    src/decoder.cpp
    src/decoder_state.cpp
    src/execution_plan.cpp
    src/gdn_step.cpp
    src/layer0.cpp
    src/linear.cpp
    src/model_package.cpp
    src/mla_npu.cpp
    src/quantization.cpp
    src/rknn_backend.cpp
    src/router.cpp
    src/tokenizer.cpp
    src/w4_linear.cpp
)
target_include_directories(ling3_core PUBLIC include)
target_compile_features(ling3_core PUBLIC cxx_std_20)
target_compile_options(ling3_core PRIVATE -Wall -Wextra -Wpedantic)
target_compile_definitions(ling3_core PUBLIC LING3_WITH_RKNN=$<BOOL:${LING3_WITH_RKNN}>)
target_compile_definitions(ling3_core PUBLIC LING3_EXPERIMENTAL_MTP=$<BOOL:${LING3_EXPERIMENTAL_MTP}>)

if(LING3_WITH_ICU)
    find_package(ICU COMPONENTS uc i18n QUIET)
endif()
if(ICU_FOUND)
    target_compile_definitions(ling3_core PUBLIC LING3_WITH_ICU=1)
    target_link_libraries(ling3_core PUBLIC ICU::uc ICU::i18n)
else()
    target_compile_definitions(ling3_core PUBLIC LING3_WITH_ICU=0)
    message(STATUS "ICU development files not found; tokenizer uses a non-production fallback")
endif()

if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64)$" AND LING3_TUNE_A76)
    target_compile_options(ling3_core PRIVATE $<$<CONFIG:Release>:-mcpu=cortex-a76>)
endif()

if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64)$")
    include(CheckLibraryExists)
    check_library_exists(mvec _ZGVnN4v_expf "" LING3_HAS_VECTOR_EXP)
    if(LING3_HAS_VECTOR_EXP)
        target_compile_definitions(ling3_core PRIVATE LING3_WITH_VECTOR_EXP=1)
        target_link_libraries(ling3_core PUBLIC mvec)
    endif()
endif()

if(LING3_WITH_RKNN)
    # Support both a flattened SDK tree and the official rknpu2 checkout:
    # runtime/Linux/librknn_api/{include,aarch64}.
    find_path(RKNN_INCLUDE_DIR rknn_api.h
        HINTS "${RKNN_ROOT}"
        PATH_SUFFIXES include runtime/Linux/librknn_api/include
        REQUIRED)
    find_library(RKNN_LIBRARY rknnrt
        HINTS "${RKNN_ROOT}"
        PATH_SUFFIXES lib aarch64 runtime/Linux/librknn_api/aarch64
        REQUIRED)
    target_include_directories(ling3_core PRIVATE "${RKNN_INCLUDE_DIR}")
    target_link_libraries(ling3_core PUBLIC "${RKNN_LIBRARY}" pthread)
    if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64)$")
        add_executable(ling3-quant-loss-probe EXCLUDE_FROM_ALL tools/quant_loss_probe.cpp)
        add_executable(ling3-linear-bridge-check EXCLUDE_FROM_ALL tools/linear_bridge_check.cpp)
        target_link_libraries(ling3-linear-bridge-check PRIVATE ling3_core)
        target_include_directories(ling3-quant-loss-probe PRIVATE third_party/nlohmann)
        target_link_libraries(ling3-quant-loss-probe PRIVATE ling3_core)
        add_executable(ling3-mla-npu-probe EXCLUDE_FROM_ALL tools/mla_npu_probe.cpp)
        target_include_directories(ling3-mla-npu-probe PRIVATE src third_party/nlohmann "${RKNN_INCLUDE_DIR}")
        target_compile_options(ling3-mla-npu-probe PRIVATE -O3 -mcpu=cortex-a76 -Wall -Wextra)
        target_link_libraries(ling3-mla-npu-probe PRIVATE ling3_core)
    endif()
endif()

set_target_properties(ling3_core PROPERTIES INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)

add_executable(ling3-rknn
    src/main.cpp
    src/service.cpp
)
target_link_libraries(ling3-rknn PRIVATE ling3_core)

add_executable(mindnano-infer src/portable_main.cpp)
target_include_directories(mindnano-infer PRIVATE third_party/nlohmann)
target_link_libraries(mindnano-infer PRIVATE ling3_core)

include(CTest)
if(BUILD_TESTING)
    add_executable(ling3-decoder-state-test tests/decoder_state_test.cpp)
    target_link_libraries(ling3-decoder-state-test PRIVATE ling3_core)
    add_test(NAME ling3-decoder-state-test COMMAND ling3-decoder-state-test)
    add_executable(ling3-generation-control-test tests/generation_control_test.cpp)
    target_compile_features(ling3-generation-control-test PRIVATE cxx_std_20)
    target_include_directories(ling3-generation-control-test PRIVATE include third_party/nlohmann)
    target_link_libraries(ling3-generation-control-test PRIVATE pthread)
    add_test(NAME ling3-generation-control-test COMMAND ling3-generation-control-test)
    add_executable(ling3-precision-policy-test tests/precision_policy_test.cpp)
    target_link_libraries(ling3-precision-policy-test PRIVATE ling3_core)
    add_test(NAME ling3-precision-policy-test COMMAND ling3-precision-policy-test)
    if(LING3_WITH_RKNN)
        # Explicit model-backed test: run with MODEL.l3r, one model process at a time.
        add_executable(ling3-checkpoint-model-test tests/checkpoint_model_test.cpp)
        target_link_libraries(ling3-checkpoint-model-test PRIVATE ling3_core)
        add_executable(ling3-w4-workspace-test tests/w4_workspace_test.cpp)
        target_link_libraries(ling3-w4-workspace-test PRIVATE ling3_core)
        add_test(NAME ling3-w4-workspace-test COMMAND ling3-w4-workspace-test)
        set_tests_properties(ling3-w4-workspace-test PROPERTIES LABELS rknn_hardware)
    endif()
    add_executable(ling3-model-reclaim-test tests/model_reclaim_test.cpp)
    target_link_libraries(ling3-model-reclaim-test PRIVATE ling3_core)
    add_test(NAME ling3-model-reclaim-test COMMAND ling3-model-reclaim-test)
    add_executable(ling3-chat-protocol-test tests/chat_protocol_test.cpp)
    target_compile_features(ling3-chat-protocol-test PRIVATE cxx_std_20)
    target_include_directories(ling3-chat-protocol-test PRIVATE include third_party/nlohmann)
    add_test(NAME ling3-chat-protocol-test COMMAND ling3-chat-protocol-test)
    add_executable(ling3-router-test tests/router_test.cpp)
    target_link_libraries(ling3-router-test PRIVATE ling3_core)
    add_test(NAME ling3-router-test COMMAND ling3-router-test)

    add_executable(ling3-quantization-test tests/quantization_test.cpp)
    target_link_libraries(ling3-quantization-test PRIVATE ling3_core)
    add_test(NAME ling3-quantization-test COMMAND ling3-quantization-test)

    add_executable(ling3-activation-test tests/activation_test.cpp)
    target_link_libraries(ling3-activation-test PRIVATE ling3_core)
    add_test(NAME ling3-activation-test COMMAND ling3-activation-test)
    if(LING3_HAS_VECTOR_EXP)
        add_test(NAME ling3-vector-activation-test COMMAND ling3-activation-test)
        set_tests_properties(ling3-vector-activation-test PROPERTIES ENVIRONMENT "LING3_VECTOR_MATH=1")
    endif()
endif()