#include <iostream>
#include <vector>
#include <string_view>
#include <concepts>

// C++20 Concepts: Compile-time type constraints with zero runtime overhead
template <typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

template <Numeric T>
constexpr T computeMovingAverage(const std::vector<T>& data, size_t window) {
    if (data.empty() || window == 0) return T{0};
    T sum = 0;
    size_t count = std::min(data.size(), window);
    for (size_t i = 0; i < count; ++i) {
        sum += data[i];
    }
    return sum / static_cast<T>(count);
}

// Rule of 5 Implementation: Custom High-Performance Raw Buffer Manager
class NetworkPacketBuffer {
private:
    char* m_data{nullptr};
    size_t m_size{0};

public:
    // 1. Constructor
    explicit NetworkPacketBuffer(size_t size) 
        : m_data(new char[size]), m_size(size) {}

    // 2. Destructor
    ~NetworkPacketBuffer() noexcept {
        delete[] m_data;
    }

    // 3. Copy Constructor (Deep Copy)
    NetworkPacketBuffer(const NetworkPacketBuffer& other) 
        : m_data(new char[other.m_size]), m_size(other.m_size) {
        std::copy(other.m_data, other.m_data + m_size, m_data);
    }

    // 4. Move Constructor (Zero-Copy Pointer Steal)
    NetworkPacketBuffer(NetworkPacketBuffer&& other) noexcept 
        : m_data(other.m_data), m_size(other.m_size) {
        other.m_data = nullptr;
        other.m_size = 0;
    }

    // 5. Move Assignment Operator
    NetworkPacketBuffer& operator=(NetworkPacketBuffer&& other) noexcept {
        if (this != &other) {
            delete[] m_data;
            m_data = other.m_data;
            m_size = other.m_size;
            other.m_data = nullptr;
            other.m_size = 0;
        }
        return *this;
    }
};

// Lock-Free Producer-Consumer Queue with Acquire-Release Semantics
#include <atomic>

struct LockFreeNode {
    int data;
    std::atomic<LockFreeNode*> next{nullptr};
};

std::atomic<int> g_flag{0};
int g_sharedData = 0;

void producerThread() {
    g_sharedData = 42; // Non-atomic payload write
    // release barrier: Guarantees g_sharedData is written to RAM before g_flag is set!
    g_flag.store(1, std::memory_order_release);
}

void consumerThread() {
    // acquire barrier: Guarantees reads after this point observe values written before release!
    while (g_flag.load(std::memory_order_acquire) == 0) {
        // Spin or yield CPU
    }
    std::cout << "Data received: " << g_sharedData << std::endl; // Always 42!
}