// Lock-free / thread-local arenas
struct ArenaBlock {
    std::atomic<ArenaBlock*> next;
    char data[1]; // flexible array
};

struct Arena {
    size_t blockSize;
    std::atomic<ArenaBlock*> freeListHead;
    size_t totalBlocks;
    std::mutex expandMutex; // only for pool expansion
};

std::unordered_map<size_t, std::shared_ptr<Arena>> globalArenas;

// Thread-local arena access
thread_local static std::unordered_map<size_t, std::shared_ptr<Arena>> threadLocalArenas;
thread_local static std::unordered_set<void*> threadLocalAllocations;

bool productionBoundsCheck = true;

// ----------------------
// Lock-free allocation from arena
// ----------------------
void* allocate(size_t size, bool persistent = false) {
    ArenaBlock* block = nullptr;

    auto& arena = getOrCreateArena(size);

    // Try pop from lock-free free list
    while (true) {
        block = arena->freeListHead.load(std::memory_order_acquire);
        if (!block) break;
        ArenaBlock* next = block->next.load(std::memory_order_relaxed);
        if (arena->freeListHead.compare_exchange_weak(block, next)) {
            registerAllocation(block->data, persistent);
            return block->data;
        }
    }

    // Expand pool if empty
    std::lock_guard<std::mutex> lock(arena->expandMutex);
    size_t expandCount = 128; // batch allocate
    for (size_t i = 0; i < expandCount; ++i) {
        char* raw = new char[size + sizeof(ArenaBlock*)];
        auto* newBlock = reinterpret_cast<ArenaBlock*>(raw);
        newBlock->next.store(arena->freeListHead.load());
        arena->freeListHead.store(newBlock);
    }

    return allocate(size, persistent);
}

void deallocate(void* ptr, size_t size) {
    if (!ptr) return;
    unregisterAllocation(ptr);

    auto& arena = getOrCreateArena(size);
    auto* block = reinterpret_cast<ArenaBlock*>(
        reinterpret_cast<char*>(ptr) - offsetof(ArenaBlock, data)
    );

    // push back lock-free
    ArenaBlock* oldHead = arena->freeListHead.load();
    do {
        block->next.store(oldHead);
    } while (!arena->freeListHead.compare_exchange_weak(oldHead, block));
}

template<typename T>
T* allocateObject(bool persistent = false) {
    return reinterpret_cast<T*>(allocate(sizeof(T), persistent));
}

template<typename T>
void deallocateObject(T*& obj) {
    deallocate(obj, sizeof(T));
    obj = nullptr;
}

// ----------------------
// C-style allocation
// ----------------------
void* mallocAlloc(size_t size, bool persistent = false) {
    void* ptr = std::malloc(size);
    if (!ptr) throw std::bad_alloc();
    registerAllocation(ptr, persistent);
    return ptr;
}

void freeAlloc(void*& ptr, size_t size) {
    if (!ptr) return;
    unregisterAllocation(ptr);
    std::free(ptr);
    ptr = nullptr;
}

    if (localMap.find(size) != localMap.end())
        return *localMap[size];

    std::shared_ptr<Arena> arena;
    {
        std::shared_lock<std::shared_mutex> lock(allocMutex);
        if (globalArenas.find(size) != globalArenas.end())
            arena = globalArenas[size];
    }
    if (!arena) {
        std::unique_lock<std::shared_mutex> lock(allocMutex);
        arena = std::make_shared<Arena>();
        arena->blockSize = size;
        arena->freeListHead.store(nullptr);
        arena->totalBlocks = 0;
        globalArenas[size] = arena;
    }

    localMap[size] = arena;
    return *arena;
}

// ----------------------
// Allocation tracking
// ----------------------

void unregisterAllocation(void* ptr) {
    std::unique_lock<std::shared_mutex> lock(allocMutex);
    auto it = allocations.find(ptr);
    if (it == allocations.end())
        throw std::runtime_error("Double free / invalid free");
    allocations.erase(it);
    threadLocalAllocations.erase(ptr);
    persistentAllocations.erase(ptr);
}

void cleanupThreadLocal() {
    for (auto ptr : threadLocalAllocations) {
        unregisterAllocation(ptr);
        ::operator delete(ptr);
    }
    threadLocalAllocations.clear();
}

// ----------------------
// Bounds checking
// ----------------------
template<typename T>
void checkBounds(T* arr, size_t index, size_t size) {
    if (productionBoundsCheck && index >= size)
        throw std::out_of_range("Array index out of bounds");
}

// ----------------------
// RAII for OS / External resources
// ----------------------
class FileHandle {
    std::ofstream* file;
    HPMemoryManager& memMgr;
public:
    FileHandle(HPMemoryManager& mgr, const std::string& filename) : memMgr(mgr) {
        file = new std::ofstream(filename, std::ios::out);
        if (!file->is_open()) throw std::runtime_error("Failed to open file");
        memMgr.registerAllocation(file, true);
    }
    std::ofstream& get() { return *file; }
    ~FileHandle() {
        if (file && file->is_open()) file->close();
        memMgr.deallocateObject(file);
    }
};

// ----------------------
// Async task execution
// ----------------------
template<typename F>
void runAsync(F&& func) {
    std::thread([this, func]() {
        func();
        cleanupThreadLocal();
    }).detach();
}

// ----------------------
// Destructor
// ----------------------
~HPMemoryManager() {
    std::unique_lock<std::shared_mutex> lock(allocMutex);
    if (!allocations.empty()) {
        std::cerr << "Memory leaks detected: " << allocations.size() << "\n";
        for (auto ptr : allocations) ::operator delete(ptr);
    }
    for (auto& [size, arena] : globalArenas) {
        ArenaBlock* block = arena->freeListHead.load();
        while (block) {
            ArenaBlock* next = block->next.load();
            ::operator delete(block);
            block = next;
        }
    }
}

void cleanupGraph(std::unordered_set<SharedObject*>& visited) {
    if (visited.find(this) != visited.end()) return;
    visited.insert(this);
    for (auto& child : children) {
        if (child) child->cleanupGraph(visited);
    }
    children.clear();
}

try {
    // Single object
    int* a = mem.allocateObject<int>();
    *a = 42;
    std::cout << "Single object: " << *a << "\n";
    mem.deallocateObject(a);

    // Array allocation
    int* arr = reinterpret_cast<int*>(mem.allocate(sizeof(int) * 10));
    for (int i = 0; i < 10; i++) {
        mem.checkBounds(arr, i, 10);
        arr[i] = i * 5;
    }
    for (int i = 0; i < 10; i++) std::cout << arr[i] << " ";
    std::cout << "\n";
    mem.deallocate(arr, sizeof(int) * 10);

    // Persistent memory
    int* persistentInt = mem.allocateObject<int>(true);
    *persistentInt = 999;
    std::cout << "Persistent value: " << *persistentInt << "\n";

    // Async tasks
    mem.runAsync([&mem]() {
        int* tdata = mem.allocateObject<int>();
        *tdata = 777;
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        mem.deallocateObject(tdata);
    });
    std::this_thread::sleep_for(std::chrono::milliseconds(100));

    // RAII file demo
    {
        HPMemoryManager::FileHandle fh(mem, "highperf_safe.txt");
        fh.get() << "High-performance enterprise memory manager demo\n";
    }

    // DAG / cyclic references
    std::shared_ptr<SharedObject> parent = std::make_shared<SharedObject>();
    parent->setSelf(parent);
    std::shared_ptr<SharedObject> child = std::make_shared<SharedObject>();
    parent->addChild(child);
    std::unordered_set<SharedObject*> visited;
    parent->cleanupGraph(visited);

} catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << "\n";
}

return 0; // Destructor auto-cleans everything