// 일반적인 접근 방식 - 매번 새로운 버퍼 할당
void SendData(const char* data, size_t size) {
    // 매 전송마다 새 메모리 할당
    char* buffer = new char[size];
    memcpy(buffer, data, size);
    
    // 비동기 전송 시작
    asio::async_write(socket, asio::buffer(buffer, size),
        [buffer](const std::error_code& ec, std::size_t length) {
            // 전송 완료 후 메모리 해제
            delete[] buffer;
        });
}

class SendBufferChunk : public std::enable_shared_from_this<SendBufferChunk>
{
public:
    enum { SEND_BUFFER_CHUNK_SIZE = 65536 }; // 64KB 청크

    SendBufferChunk() {
        _buffer.resize(SEND_BUFFER_CHUNK_SIZE);
    }
    
    // 청크 초기화
    void Reset() {
        _open = false;
        _usedSize = 0;
    }
    
    // 버퍼 할당
    std::shared_ptr<SendBuffer> Open(uint32_t allocSize) {
        if (allocSize > FreeSize())
            return nullptr;
            
        _open = true;
        return std::make_shared<SendBuffer>(shared_from_this(), Buffer(), allocSize);
    }
    
    // 버퍼 반환 시 사용
    void Close(uint32_t writeSize) {
        _open = false;
        _usedSize += writeSize;
    }
    
    bool IsOpen() const { return _open; }
    BYTE* Buffer() { return &_buffer[_usedSize]; }
    uint32_t FreeSize() const { return static_cast<uint32_t>(_buffer.size()) - _usedSize; }

private:
    std::vector<BYTE> _buffer;  // 실제 메모리 청크
    bool _open = false;         // 사용 중 플래그
    uint32_t _usedSize = 0;     // 청크 내 사용된 메모리 크기
};

class SendBuffer
{
public:
    SendBuffer(std::shared_ptr<SendBufferChunk> owner, BYTE* buffer, uint32_t allocSize)
        : _owner(owner), _buffer(buffer), _allocSize(allocSize) {}
        
    BYTE* Buffer() { return _buffer; }
    uint32_t AllocSize() const { return _allocSize; }
    uint32_t WriteSize() const { return _writeSize; }
    
    // 실제 사용한 크기 설정
    void Close(uint32_t writeSize) {
        _writeSize = writeSize;
        _owner->Close(writeSize);
    }

private:
    BYTE* _buffer;       // 버퍼 시작 위치
    uint32_t _allocSize; // 할당된 크기
    uint32_t _writeSize = 0; // 실제 기록된 크기
    std::shared_ptr<SendBufferChunk> _owner; // 소유자 청크
};

class SendBufferManager
{
public:
    std::shared_ptr<SendBuffer> Open(uint32_t size) {
        // 스레드 로컬 버퍼 청크 확인/할당
        if (LSendBufferChunk == nullptr) {
            LSendBufferChunk = Pop();
            LSendBufferChunk->Reset();
        }
        
        // 청크 내 공간이 부족하면 새 청크 할당
        if (LSendBufferChunk->FreeSize() < size) {
            Push(LSendBufferChunk);
            LSendBufferChunk = Pop();
            LSendBufferChunk->Reset();
        }
        
        // 버퍼 열기
        return LSendBufferChunk->Open(size);
    }

private:
    // 사용 가능한 청크 가져오기
    std::shared_ptr<SendBufferChunk> Pop() {
        std::lock_guard<std::mutex> lock(_lock);
        
        if (!_sendBufferChunks.empty()) {
            std::shared_ptr<SendBufferChunk> chunk = _sendBufferChunks.back();
            _sendBufferChunks.pop_back();
            return chunk;
        }
        
        // 없으면 새로 생성
        return std::shared_ptr<SendBufferChunk>(new SendBufferChunk(), PushGlobal);
    }
    
    // 사용한 청크 반환
    void Push(std::shared_ptr<SendBufferChunk> buffer) {
        if (LSendBufferChunk == buffer)
            return;
            
        std::lock_guard<std::mutex> lock(_lock);
        _sendBufferChunks.push_back(buffer);
    }
    
    // 청크 소멸 시 자동으로 호출되는 정적 함수
    static void PushGlobal(SendBufferChunk* buffer) {
        GSendBufferManager->Push(std::shared_ptr<SendBufferChunk>(buffer, PushGlobal));
    }

private:
    std::mutex _lock;
    std::vector<std::shared_ptr<SendBufferChunk>> _sendBufferChunks;
};

// 스레드별 전용 청크 할당
thread_local std::shared_ptr<SendBufferChunk> LSendBufferChunk;

// 1. 송신 버퍼 할당
std::shared_ptr<SendBuffer> sendBuffer = GSendBufferManager->Open(1024);

// 2. 데이터 기록
char* buffer = reinterpret_cast<char*>(sendBuffer->Buffer());
memcpy(buffer, "Hello World", 11);
sendBuffer->Close(11);  // 실제 사용된 크기 설정

// 3. 비동기 전송
session->Send(sendBuffer);

void Session::Send(std::shared_ptr<SendBuffer> sendBuffer)
{
    if (!IsConnected())
        return;

    bool registerSend = false;
    {
        // 전송 대기열에 추가
        std::lock_guard<std::mutex> lock(_sendLock);
        _sendQueue.push(sendBuffer);
        
        // 전송 중이 아니면 전송 시작
        if (_sendRegistered.exchange(true) == false)
            registerSend = true;
    }

    if (registerSend)
        RegisterSend();
}

class alignas(64) SendBufferChunk { ... };

// 다양한 크기의 청크 풀 관리
std::vector<std::shared_ptr<SendBufferChunk>> _smallChunks;  // 4KB
std::vector<std::shared_ptr<SendBufferChunk>> _mediumChunks; // 16KB
std::vector<std::shared_ptr<SendBufferChunk>> _largeChunks;  // 64KB

void SendBufferManager::Init(size_t poolSize)
{
    for (size_t i = 0; i < poolSize; i++) {
        _sendBufferChunks.push_back(
            std::make_shared<SendBufferChunk>()
        );
    }
}