// ntarra_avx512.cpp — IKNN-Rl1-A1 — Ntarra-DnA AVX-512 Kernel
// Version: v1.0
// Created: 2026-09-03T17:20:00+07:00
// Last Updated: 2026-09-03T17:20:00+07:00
// Status: PUBLISHABLE — EN ONLY — M1 Kernel Validation
// Repo: IKNN-Rl1-A1 — Integrated Knowledge-phase Neural Network — Recursive Language Iteration 1 — Architecture 1
// Hardware: Xeon AVX-512 — this sandbox

#include "ntarra_common.h"
#include <cstdint>
#include <immintrin.h>

namespace iknn {
namespace ntarra {
namespace avx512 {

inline __m512i compute_ntarra_block_avx512(__m512i activations, const uint8_t states[16]) {
    alignas(64) int32_t act_array[16];
    _mm512_store_si512(reinterpret_cast<__m512i*>(act_array), activations);
    alignas(64) int32_t result[16];
    for (int i = 0; i < 16; ++i) {
        result[i] = compute_ntarra_single(act_array[i], states[i]);
    }
    return _mm512_load_si512(reinterpret_cast<const __m512i*>(result));
}

inline __m512i compute_ntarra_shift_xor_avx512(__m512i x, __m512i shift, __m512i dir) {
    __m512i shifted = _mm512_sllv_epi32(x, shift);
    __mmask16 neg_mask = _mm512_cmpeq_epi32_mask(dir, _mm512_set1_epi32(-1));
    __m512i neg = _mm512_sub_epi32(_mm512_setzero_si512(), shifted);
    __m512i res = _mm512_mask_blend_epi32(neg_mask, shifted, neg);
    __mmask16 zero_mask = _mm512_cmpeq_epi32_mask(dir, _mm512_setzero_si512());
    res = _mm512_mask_blend_epi32(zero_mask, res, _mm512_setzero_si512());
    return res;
}

} // namespace avx512
} // namespace ntarra
} // namespace iknn

#ifdef NTARRA_AVX512_TEST
#include <random>
#include <iostream>

int main() {
    using namespace iknn::ntarra;
    using namespace iknn::ntarra::avx512;

    std::cout << "[Ntarra-DnA AVX-512 Test] 9-state 3.17-bit" << std::endl;

    // Packing test
    uint8_t d0 = 5, d1 = 8;
    uint8_t packed = pack_2x9(d0, d1);
    uint8_t ud0, ud1;
    unpack_2x9(packed, ud0, ud1);
    std::cout << "Pack 2x9: d0=" << (int)d0 << " d1=" << (int)d1 << " packed=" << (int)packed << " unpacked d0=" << (int)ud0 << " d1=" << (int)ud1 << " " << ((d0==ud0 && d1==ud1) ? "[PASS]" : "[FAIL]") << std::endl;

    // Compute tests
    int32_t act = 10;
    uint8_t state = encode_9state(Direction::POS, Phase::PHI0); // + shift0 => 10
    int32_t res = compute_ntarra_single(act, state);
    std::cout << "Compute + PHI0: " << res << " expected 10 " << (res==10 ? "[PASS]" : "[FAIL]") << std::endl;

    state = encode_9state(Direction::POS, Phase::PHI1); // + shift2 => 40
    res = compute_ntarra_single(act, state);
    std::cout << "Compute + PHI1 shift2: " << res << " expected 40 " << (res==40 ? "[PASS]" : "[FAIL]") << std::endl;

    state = encode_9state(Direction::POS, Phase::PHI2); // + shift4 => 160
    res = compute_ntarra_single(act, state);
    std::cout << "Compute + PHI2 shift4: " << res << " expected 160 " << (res==160 ? "[PASS]" : "[FAIL]") << std::endl;

    state = encode_9state(Direction::NEG, Phase::PHI1); // - shift2 => -40
    res = compute_ntarra_single(act, state);
    std::cout << "Compute - PHI1: " << res << " expected -40 " << (res==-40 ? "[PASS]" : "[FAIL]") << std::endl;

    state = encode_9state(Direction::ZERO, Phase::PHI0); // 0 => 0
    res = compute_ntarra_single(act, state);
    std::cout << "Compute ZERO: " << res << " expected 0 " << (res==0 ? "[PASS]" : "[FAIL]") << std::endl;

    // Entropy gate
    bool accept = entropy_gate(0.5f, 1.0f);
    std::cout << "Entropy gate 0.5 <= 1.0: " << (accept ? "accept" : "intercept") << " expected accept " << (accept ? "[PASS]" : "[FAIL]") << std::endl;
    accept = entropy_gate(2.0f, 1.0f);
    std::cout << "Entropy gate 2.0 <= 1.0: " << (accept ? "accept" : "intercept") << " expected intercept " << (!accept ? "[PASS]" : "[FAIL]") << std::endl;

    std::cout << "[Ntarra-DnA] All tests done" << std::endl;
    return 0;
}
#endif