// mid_hotbox_v3.c - Mid/Pool HotBox v3 Implementation
//
// Phase MID-V3-1: Stub implementation (skeleton only)
// Phase MID-V3-4/5: Full implementation

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#ifndef likely
#define likely(x)   __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
#endif

#include "box/mid_hotbox_v3_box.h"
#include "box/mid_hotbox_v3_env_box.h"
#include "box/mid_cold_iface_v3.h"
#include "box/region_id_v6_box.h"

// ============================================================================
// TLS Context
// ============================================================================

static __thread MidHotBoxV3 g_mid_hot_ctx_v3;
static __thread int g_mid_hot_ctx_v3_init = 0;

MidHotBoxV3* mid_hot_box_v3_get(void) {
    if (unlikely(!g_mid_hot_ctx_v3_init)) {
        memset(&g_mid_hot_ctx_v3, 0, sizeof(g_mid_hot_ctx_v3));
        g_mid_hot_ctx_v3.flags = MID_CTX_FLAG_INIT;
        g_mid_hot_ctx_v3_init = 1;
    }
    return &g_mid_hot_ctx_v3;
}

// ============================================================================
// Allocation Fast Path (MID-V3-4 stub)
// ============================================================================

void* mid_hot_v3_alloc(MidHotBoxV3* hot, int class_idx) {
    if (unlikely(!mid_v3_class_enabled((uint8_t)class_idx))) {
        return NULL;  // Class not enabled
    }

    if (!hot) {
        hot = mid_hot_box_v3_get();
    }

    MidLaneV3* lane = &hot->lanes[class_idx];

    // L0: TLS freelist cache hit
    if (likely(lane->freelist_head)) {
        void* blk = lane->freelist_head;
        void* next = NULL;
        memcpy(&next, blk, sizeof(void*));
        lane->freelist_head = next;
        lane->freelist_count--;
        lane->alloc_count++;
        return blk;
    }

    // L0 miss: slow path
    return NULL;  // Stub: MID-V3-4 will implement slow path
}

// ============================================================================
// Free Fast Path (MID-V3-5 stub)
// ============================================================================

void mid_hot_v3_free(void* ptr) {
    if (unlikely(!ptr)) return;
    if (unlikely(!mid_v3_enabled())) return;

    // RegionIdBox lookup
    RegionLookupV6 lk = region_id_lookup_cached_v6(ptr);

    // Stub: MID-V3-5 will implement full free path
    (void)lk;
}

// ============================================================================
// Ownership Check
// ============================================================================

int mid_hotbox_v3_can_own(int class_idx, void* ptr) {
    if (unlikely(!mid_v3_class_enabled((uint8_t)class_idx))) {
        return 0;
    }
    if (!ptr) return 0;

    // RegionIdBox lookup
    RegionLookupV6 lk = region_id_lookup_v6(ptr);

    // Check if this is a MID v3 region
    // Stub: For now, always return 0 until MID-V3-3 implements registration
    (void)lk;
    return 0;
}

// ============================================================================
// Cold Interface Stubs (MID-V3-4/5)
// ============================================================================

MidPageDescV3* mid_cold_v3_refill_page(MidHotBoxV3* hot, uint32_t class_idx) {
    (void)hot;
    (void)class_idx;
    // Stub: MID-V3-4 will implement
    return NULL;
}

void mid_cold_v3_retire_page(MidHotBoxV3* hot, MidPageDescV3* page) {
    (void)hot;
    (void)page;
    // Stub: MID-V3-5 will implement
}

bool mid_cold_v3_remote_push(MidPageDescV3* page, void* ptr, uint32_t tid) {
    (void)page;
    (void)ptr;
    (void)tid;
    // Stub: MID-V3-5 will implement
    return false;
}

void mid_cold_v3_remote_drain(MidHotBoxV3* hot) {
    (void)hot;
    // Stub: MID-V3-5 will implement
}

// ============================================================================
// Segment Operations Stubs
// ============================================================================

MidSegmentV3* mid_segment_v3_acquire(int class_idx) {
    (void)class_idx;
    // Stub: MID-V3-4 will implement
    return NULL;
}

MidPageDescV3* mid_segment_v3_carve_page(MidSegmentV3* seg, int class_idx) {
    (void)seg;
    (void)class_idx;
    // Stub: MID-V3-4 will implement
    return NULL;
}

void mid_segment_v3_return_page(MidSegmentV3* seg, MidPageDescV3* page) {
    (void)seg;
    (void)page;
    // Stub: MID-V3-5 will implement
}

// ============================================================================
// Lane Operations Stubs
// ============================================================================

void mid_lane_refill_from_page(MidLaneV3* lane, MidPageDescV3* page, uint32_t batch_size) {
    (void)lane;
    (void)page;
    (void)batch_size;
    // Stub: MID-V3-4 will implement
}

void mid_lane_flush_to_page(MidLaneV3* lane, MidPageDescV3* page) {
    (void)lane;
    (void)page;
    // Stub: MID-V3-5 will implement
}

// ============================================================================
// Page Operations Stubs
// ============================================================================

void* mid_page_build_freelist(MidPageDescV3* page) {
    (void)page;
    // Stub: MID-V3-4 will implement
    return NULL;
}

void mid_page_push_free(MidPageDescV3* page, void* ptr) {
    (void)page;
    (void)ptr;
    // Stub: MID-V3-5 will implement
}

void* mid_page_pop_free(MidPageDescV3* page) {
    (void)page;
    // Stub: MID-V3-4 will implement
    return NULL;
}

// ============================================================================
// Debug
// ============================================================================

void mid_hot_v3_dump_stats(void) {
    if (!mid_v3_debug_enabled()) return;

    MidHotBoxV3* hot = mid_hot_box_v3_get();
    fprintf(stderr, "[MID_V3] HotBox stats:\n");

    for (int i = 0; i < MID_V3_NUM_CLASSES; i++) {
        if (!mid_v3_class_enabled((uint8_t)i)) continue;

        MidLaneV3* lane = &hot->lanes[i];
        fprintf(stderr, "  C%d: page_idx=%u freelist_count=%u alloc=%u free=%u\n",
                i, lane->page_idx, lane->freelist_count,
                lane->alloc_count, lane->free_count);
    }
}