// hak_core_init.inc.h — Box: init/shutdown
#ifndef HAK_CORE_INIT_INC_H
#define HAK_CORE_INIT_INC_H

#include "hakmem_phase7_config.h"  // Phase 7 Task 3
#include "box/libm_reloc_guard_box.h"
#include "box/init_bench_preset_box.h"
#include "box/init_diag_box.h"
#include "box/init_env_box.h"
#include "../tiny_destructors.h"

// Debug-only SIGSEGV handler (gated by HAKMEM_DEBUG_SEGV)
static void hakmem_sigsegv_handler(int sig) {
    (void)sig;
    const char* msg = "\n[HAKMEM] Segmentation Fault\n";
    ssize_t written = write(2, msg, 29);
    (void)written;

#if !HAKMEM_BUILD_RELEASE
    // Dump Class 1 (16B) last push info for debugging
    tiny_debug_dump_last_push(1);
#endif

    // Restore default handler and re-raise
    signal(sig, SIG_DFL);
    raise(sig);
}

// Phase 7 Task 3: Pre-warm TLS cache helper
// Pre-allocate blocks to reduce first-allocation miss penalty
// Note: This function is defined later in hakmem.c after sll_refill_small_from_ss is available
// (moved out of header to avoid linkage issues)

static void hak_init_impl(void);
static pthread_once_t g_init_once = PTHREAD_ONCE_INIT;

void hak_init(void) {
    (void)pthread_once(&g_init_once, hak_init_impl);
}

static void hak_init_impl(void) {
    libm_reloc_guard_run();
    HAK_TRACE("[init_impl_enter]\n");
    g_init_thread = pthread_self();
    atomic_store_explicit(&g_initializing, 1, memory_order_release);

    // Phase 6.X P0 FIX (2025-10-24): Initialize Box 3 (Syscall Layer) FIRST!
    // This MUST be called before ANY allocation (Tiny/Mid/Large/Learner)
    // dlsym() initializes function pointers to real libc (bypasses LD_PRELOAD)
    hkm_syscall_init();
    HAK_TRACE("[init_impl_after_syscall_init]\n");

    // CRITICAL FIX (BUG #10): Pre-detect jemalloc ONCE during init, not on hot path!
    // This prevents infinite recursion: malloc → hak_jemalloc_loaded → dlopen → malloc → ...
    // We protect dlopen's internal malloc calls with g_hakmem_lock_depth
    extern int g_jemalloc_loaded;  // Declared in hakmem.c
    if (g_jemalloc_loaded < 0) {
        void* h = dlopen("libjemalloc.so.2", RTLD_NOLOAD | RTLD_NOW);
        if (!h) h = dlopen("libjemalloc.so.1", RTLD_NOLOAD | RTLD_NOW);
        g_jemalloc_loaded = (h != NULL) ? 1 : 0;
        if (h) dlclose(h);
        if (g_jemalloc_loaded) {
            HAKMEM_LOG("Detected jemalloc: will avoid interposing\n");
        }
    }
    HAK_TRACE("[init_impl_after_jemalloc_probe]\n");

    box_diag_install_sigsegv_handler(hakmem_sigsegv_handler);

    // NEW Phase 6.11.1: Initialize debug timing
    hkm_timing_init();

    // NEW Phase 6.11.1: Initialize whale fast-path cache
    hkm_whale_init();

    // NEW Phase Hybrid: Initialize Mid Range MT allocator (8-32KB, mimalloc-style)

    // NEW Phase 6.8: Initialize configuration system (replaces init_free_policy + init_thp_policy)
    hak_config_init();

    // Phase 6.16: Initialize FrozenPolicy (SACS-3)
    hkm_policy_init();

    box_init_env_flags();
    box_diag_record_baseline();

    HAKMEM_LOG("Initialized (PoC version)\n");
    HAKMEM_LOG("Sampling rate: 1/%d\n", SAMPLING_RATE);
    HAKMEM_LOG("Max sites: %d\n", MAX_SITES);

    box_diag_print_banner();
    box_init_bench_presets();

    // NEW Phase 6.8: Feature-gated initialization (check g_hakem_config flags)
    if (HAK_ENABLED_ALLOC(HAKMEM_FEATURE_POOL)) {
        hak_pool_init();
    }

    // NEW Phase 6.13: L2.5 LargePool (64KB-1MB allocations)
    hak_l25_pool_init();

    if (!g_bench_tiny_only && HAK_ENABLED_CACHE(HAKMEM_FEATURE_BIGCACHE)) {
        hak_bigcache_init();
        hak_bigcache_set_free_callback(bigcache_free_callback);
    }

    if (!g_bench_tiny_only && HAK_ENABLED_LEARNING(HAKMEM_FEATURE_ELO)) {
        hak_elo_init();
        // Phase 6.11.4 P0-2: Initialize cached strategy to default (strategy 0)
        atomic_store(&g_cached_strategy_id, 0);
    }

    if (!g_bench_tiny_only && HAK_ENABLED_MEMORY(HAKMEM_FEATURE_BATCH_MADVISE)) {
        hak_batch_init();
    }

    if (!g_bench_tiny_only && HAK_ENABLED_LEARNING(HAKMEM_FEATURE_EVOLUTION)) {
        hak_evo_init();
    }

    if (!g_bench_tiny_only) {
        // Phase 6.16: Initialize ACE stats (sampling) – default off
        hkm_ace_stats_init();
        // Phase 6.16: Initialize sampling profiler – default off
        hkm_prof_init();
        // Size histogram sampling (optional)
        hkm_size_hist_init();
    }

    if (!g_bench_tiny_only) {
        // Start CAP learner (optional, env-gated)
        hkm_learner_init();
    }

    // NEW Phase 6.10: Site Rules (MVP: always ON)
    // MT note: default disabled unless HAKMEM_SITE_RULES=1
    char* sr_env = getenv("HAKMEM_SITE_RULES");
    g_site_rules_enabled = (sr_env && atoi(sr_env) != 0);
    if (!g_bench_tiny_only && g_site_rules_enabled) {
        hak_site_rules_init();
    }

    // Phase 22: Tiny Pool initialization now LAZY (per-class on first use)
    // hak_tiny_init() moved to lazy_init_class() in hakmem_tiny_lazy_init.inc.h
    // OLD: hak_tiny_init(); (eager init of all 8 classes → 94.94% page faults)
    // NEW: Lazy init triggered by tiny_alloc_fast() → only used classes initialized

    tiny_destructors_configure_from_env();
    tiny_destructors_register_exit();

    // NEW Phase ACE: Initialize Adaptive Control Engine
    hkm_ace_controller_init(&g_ace_controller);
    if (g_ace_controller.enabled) {
        hkm_ace_controller_start(&g_ace_controller);
        HAKMEM_LOG("ACE Learning Layer enabled and started\n");
    }

    // Phase 20-1: Aggressive TLS SLL + SuperSlab prewarming (ChatGPT strategy)
    // Box SS-HotPrewarm: ENV-controlled per-class prewarm with page fault reduction
#if HAKMEM_TINY_PREWARM_TLS
    #include "box/ss_hot_prewarm_box.h"
    int total_prewarmed = box_ss_hot_prewarm_all();
    (void)total_prewarmed;
    HAKMEM_LOG("TLS cache pre-warmed: %d blocks total (Phase 20-1)\n", total_prewarmed);
    // After TLS prewarm, cascade some hot blocks into SFC to raise early hit rate
    {
        extern int g_sfc_enabled;
        if (g_sfc_enabled) {
            extern void sfc_cascade_from_tls_initial(void);
            sfc_cascade_from_tls_initial();
        }
    }
#endif

    atomic_store_explicit(&g_initializing, 0, memory_order_release);
    // Publish that initialization is complete
    atomic_thread_fence(memory_order_seq_cst);
    g_initialized = 1;
}

void hak_shutdown(void) {
    if (!g_initialized) return;

    // NEW Phase ACE: Shutdown Adaptive Control Engine FIRST (before other subsystems)
    hkm_ace_controller_destroy(&g_ace_controller);

    if (!g_bench_tiny_only) {
        HAKMEM_LOG("Shutting down...\n");
        hak_print_stats();
    }

    // NEW Phase 6.9: Shutdown L2 Pool
    if (!g_bench_tiny_only) hak_pool_shutdown();

    // NEW Phase 6.13: Shutdown L2.5 LargePool
    if (!g_bench_tiny_only) hak_l25_pool_shutdown();

    // NEW: Shutdown BigCache Box
    if (!g_bench_tiny_only) hak_bigcache_shutdown();

    // NEW Phase 6.2: Shutdown ELO Strategy Selection
    if (!g_bench_tiny_only) hak_elo_shutdown();

    // NEW Phase 6.3: Shutdown madvise Batching
    if (!g_bench_tiny_only) hak_batch_shutdown();

    // NEW Phase 6.10: Shutdown Site Rules
    if (!g_bench_tiny_only) hak_site_rules_shutdown();

    // NEW Phase 6.12: Print Tiny Pool statistics
    if (!g_bench_tiny_only) hak_tiny_print_stats();

    // NEW Phase 6.11.1: Print whale cache statistics
    if (!g_bench_tiny_only) {
        hkm_whale_dump_stats();
        // NEW Phase 6.11.1: Shutdown whale cache
        hkm_whale_shutdown();
    }

    // NEW Phase 6.11.1: Shutdown debug timing (must be last!)
    if (!g_bench_tiny_only) hkm_timing_shutdown();

    // Phase 6.16: Dump sampling profiler
    if (!g_bench_tiny_only) hkm_prof_shutdown();

    // Stop learner thread
    if (!g_bench_tiny_only) hkm_learner_shutdown();

    // Stop Tiny background components (e.g., Intelligence Engine)
    hak_tiny_shutdown();

    g_initialized = 0;
}



#endif // HAK_CORE_INIT_INC_H