// Header
auto send_packet(std::vector<uint8_t> data) -> VoidResult;

// Implementation
auto tcp_socket::async_send(
    std::vector<uint8_t> data,  // ❌ Copy happens here!
    std::function<void(std::error_code, std::size_t)> handler) -> void
{
    auto buffer = std::make_shared<std::vector<uint8_t>>(std::move(data));
    // data is moved INSIDE function, but parameter was already copied
}

// Header
auto send_packet(std::vector<uint8_t>&& data) -> VoidResult;

// Implementation
auto tcp_socket::async_send(
    std::vector<uint8_t>&& data,  // ✅ Rvalue ref - no copy!
    std::function<void(std::error_code, std::size_t)> handler) -> void
{
    auto buffer = std::make_shared<std::vector<uint8_t>>(std::move(data));
    // Zero-copy ownership transfer
}

// Usage
std::vector<uint8_t> payload = load_file("10MB.bin");
client->send_packet(std::move(payload));  // Explicit ownership transfer
// payload is now empty - ownership moved to send function

/*!
 * \class messaging_server
 * \brief TCP server managing incoming connections and sessions.
 *
 * ### Thread Safety
 * - All public methods are thread-safe.
 * - Internal state (is_running_, sessions_) is protected by atomics and ASIO's thread safety.
 * - Background thread runs io_context.run() independently.
 * - Multiple sessions can be active concurrently without blocking each other.
 * - Sessions vector is NOT protected by mutex - only accessed in single-threaded ASIO context.
 *
 * ### Threading Model
 * - Main thread: Application calls start_server(), stop_server()
 * - ASIO thread: Handles all async I/O callbacks (on_accept, on_error)
 * - Session threads: Each session's callbacks run on ASIO thread (serialized)
 */

/*!
 * \class messaging_client
 * \brief Asynchronous TCP client with thread-safe API.
 *
 * ### Thread Safety
 * - All public methods are thread-safe.
 * - Socket access is protected by socket_mutex_.
 * - Atomic flags (is_running_, is_connected_, stop_initiated_) prevent race conditions.
 * - send_packet() can be called from any thread safely.
 * - Connection state changes are serialized through ASIO's io_context.
 *
 * ### Concurrency Model
 * ```
 * Thread 1 (App):     send_packet(data1)  ──┐
 * Thread 2 (App):     send_packet(data2)  ──┼─> socket_mutex_ ─> ASIO queue
 * Thread 3 (ASIO):    on_connect()        ──┘
 *                     on_receive()
 * ```
 */

// Application threads (many)
client->send_packet(std::move(data1));  // ✅ Thread-safe
client->send_packet(std::move(data2));  // ✅ Thread-safe (queued)

// ASIO thread (one)
// - on_connect() callback executes here
// - on_receive() callback executes here
// ✅ Callbacks never block send_packet() calls

/*!
 * \class tcp_socket
 * \brief Low-level socket wrapper with async read/write.
 *
 * ### Thread Safety
 * - All public methods are thread-safe.
 * - Callback registration is protected by callback_mutex_.
 * - ASIO operations are serialized through io_context, ensuring read_buffer_
 *   is only accessed by one async operation at a time.
 * - Callbacks are invoked on ASIO worker thread - ensure your callback logic
 *   is thread-safe if it accesses shared data.
 *
 * ### Memory Safety
 * - read_buffer_ is thread-local to ASIO event loop (no data races)
 * - async_send() captures data in shared_ptr for lifetime management
 * - Callbacks hold shared_from_this() to prevent dangling references
 */

/*!
 * \brief Sends data over the connection (moved for efficiency).
 * \param data The buffer to send (moved, not copied).
 *
 * ### Example
 * \code
 * std::vector<uint8_t> message = {1, 2, 3, 4};
 * auto result = client->send_packet(std::move(message));  // Explicit move
 * if (!result) {
 *     std::cerr << "Send failed: " << result.error_message() << "\n";
 * }
 * // message is now empty (ownership transferred)
 * assert(message.empty());
 * \endcode
 *
 * \note This is async - actual send happens in background.
 * \note Data is moved (not copied) for zero-copy efficiency.
 * \note After call, original vector will be empty.
 */
auto send_packet(std::vector<uint8_t>&& data) -> VoidResult;

TEST(NetworkSystem, SendPacketMovesData) {
    auto client = create_test_client();

    std::vector<uint8_t> data = {1, 2, 3, 4, 5};
    size_t original_size = data.size();  // 5

    auto result = client->send_packet(std::move(data));

    EXPECT_TRUE(result);              // ✅ Send succeeded
    EXPECT_EQ(data.size(), 0);        // ✅ Data was moved (now empty)
    EXPECT_EQ(original_size, 5);      // ✅ Original size unchanged
}

TEST(NetworkSystem, ConcurrentSendsAreThreadSafe) {
    auto client = create_test_client();
    std::atomic<int> success_count{0};

    // Spawn 100 concurrent senders
    std::vector<std::thread> threads;
    for (int i = 0; i < 100; ++i) {
        threads.emplace_back([&, i]() {
            std::vector<uint8_t> msg(1024, static_cast<uint8_t>(i));
            if (client->send_packet(std::move(msg))) {
                success_count++;
            }
        });
    }

    for (auto& t : threads) t.join();

    EXPECT_EQ(success_count, 100);  // ✅ All sends succeeded
    // ✅ No crashes, no data corruption
}

const int NUM_MESSAGES = 1000;
const size_t MESSAGE_SIZE = 1 * 1024 * 1024;  // 1 MB

auto client = create_test_client();
auto start = std::chrono::high_resolution_clock::now();

for (int i = 0; i < NUM_MESSAGES; ++i) {
    std::vector<uint8_t> msg(MESSAGE_SIZE, 0);
    client->send_packet(std::move(msg));  // Move!
}

auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);

std::cout << "Throughput: "
          << (NUM_MESSAGES * MESSAGE_SIZE / (duration.count() / 1000.0) / 1e6)
          << " MB/s\n";

// ❌ Old code (will not compile)
std::vector<uint8_t> data = {1, 2, 3};
client->send_packet(data);  // Error: cannot bind lvalue to rvalue ref

// ✅ New code (explicit move)
std::vector<uint8_t> data = {1, 2, 3};
client->send_packet(std::move(data));  // OK: explicit ownership transfer

// ✅ Alternative (if you don't need data afterward)
client->send_packet({1, 2, 3});  // OK: temporary, automatically moved

// Copy version (expensive)
void send(std::vector<uint8_t> data) {
    // Runtime cost:
    // 1. malloc(data.size())       ← Heap allocation
    // 2. memcpy(src, dst, size)    ← O(n) copy
    // 3. Constructor overhead
    // Result: O(n) time, O(n) space
}

// Move version (nearly free)
void send(std::vector<uint8_t>&& data) {
    // Runtime cost:
    // 1. Swap 3 pointers           ← 3 mov instructions
    // 2. Nullify source pointers   ← 3 store instructions
    // Result: O(1) time, O(1) space
}