// Archived legacy backend for hak_tiny_alloc_superslab_box().
// Not compiled by default; kept for reference/A-B restore.
// Source moved from core/superslab_backend.c after legacy path removal.

#include "../core/hakmem_tiny_superslab_internal.h"

void* hak_tiny_alloc_superslab_backend_legacy(int class_idx)
{
    if (class_idx < 0 || class_idx >= TINY_NUM_CLASSES_SS) {
        return NULL;
    }

    SuperSlabHead* head = g_superslab_heads[class_idx];
    if (!head) {
        head = init_superslab_head(class_idx);
        if (!head) {
            return NULL;
        }
        g_superslab_heads[class_idx] = head;
    }

    // LOCK expansion_lock to protect list traversal (vs remove_superslab_from_legacy_head)
    pthread_mutex_lock(&head->expansion_lock);

    SuperSlab* chunk = head->current_chunk ? head->current_chunk : head->first_chunk;

    while (chunk) {
        int cap = ss_slabs_capacity(chunk);
        for (int slab_idx = 0; slab_idx < cap; slab_idx++) {
            TinySlabMeta* meta = &chunk->slabs[slab_idx];

            // Skip slabs that belong to a different class (or are uninitialized).
            if (meta->class_idx != (uint8_t)class_idx && meta->class_idx != 255) {
                continue;
            }

            // Initialize slab on first use to populate class_map.
            if (meta->capacity == 0) {
                size_t block_size = g_tiny_class_sizes[class_idx];
                uint32_t owner_tid = (uint32_t)(uintptr_t)pthread_self();
                superslab_init_slab(chunk, slab_idx, block_size, owner_tid);
                meta = &chunk->slabs[slab_idx];
                meta->class_idx = (uint8_t)class_idx;
                chunk->class_map[slab_idx] = (uint8_t)class_idx;
            }

            if (meta->used < meta->capacity) {
                size_t stride = tiny_block_stride_for_class(class_idx);
                size_t offset = (size_t)meta->used * stride;
                uint8_t* base = (uint8_t*)chunk
                              + SUPERSLAB_SLAB0_DATA_OFFSET
                              + (size_t)slab_idx * SUPERSLAB_SLAB_USABLE_SIZE
                              + offset;

                meta->used++;
                atomic_fetch_add_explicit(&chunk->total_active_blocks, 1, memory_order_relaxed);

                // UNLOCK before return
                pthread_mutex_unlock(&head->expansion_lock);

                HAK_RET_ALLOC_BLOCK_TRACED(class_idx, base, ALLOC_PATH_BACKEND);
            }
        }
        chunk = chunk->next_chunk;
    }

    // UNLOCK before expansion (which takes lock internally)
    pthread_mutex_unlock(&head->expansion_lock);

    if (expand_superslab_head(head) < 0) {
        return NULL;
    }

    SuperSlab* new_chunk = head->current_chunk;
    if (!new_chunk) {
        return NULL;
    }

    int cap2 = ss_slabs_capacity(new_chunk);
    for (int slab_idx = 0; slab_idx < cap2; slab_idx++) {
        TinySlabMeta* meta = &new_chunk->slabs[slab_idx];

        // Initialize slab on first use to populate class_map.
        if (meta->capacity == 0) {
            size_t block_size = g_tiny_class_sizes[class_idx];
            uint32_t owner_tid = (uint32_t)(uintptr_t)pthread_self();
            superslab_init_slab(new_chunk, slab_idx, block_size, owner_tid);
            meta = &new_chunk->slabs[slab_idx];
            meta->class_idx = (uint8_t)class_idx;
            new_chunk->class_map[slab_idx] = (uint8_t)class_idx;
        }

        if (meta->used < meta->capacity) {
            size_t stride = tiny_block_stride_for_class(class_idx);
            size_t offset = (size_t)meta->used * stride;
            uint8_t* base = (uint8_t*)new_chunk
                          + SUPERSLAB_SLAB0_DATA_OFFSET
                          + (size_t)slab_idx * SUPERSLAB_SLAB_USABLE_SIZE
                          + offset;

            meta->used++;
            atomic_fetch_add_explicit(&new_chunk->total_active_blocks, 1, memory_order_relaxed);
            HAK_RET_ALLOC_BLOCK_TRACED(class_idx, base, ALLOC_PATH_BACKEND);
        }
    }

    return NULL;
}