connection.h

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <vector>
 
#include "net/wire/protocol.h"
#include "platform/net/net_address.h"
#include "platform/net/udp_socket.h"
 
namespace Vkm::Engine {

bool isNewerSequence(uint16_t a, uint16_t b);

class NetConnection {
    public:
        static constexpr size_t HEADER_BYTES = 8;

        static constexpr size_t MAX_PAYLOAD = UdpSocket::MAX_DATAGRAM - HEADER_BYTES;

        static constexpr float TIMEOUT_SECONDS = 5.0f;

        static constexpr uint16_t NO_SEQUENCE = 0;
 
    public:
        NetConnection() = default;
        ~NetConnection() = default;
 
        NetConnection(const NetConnection& other) = delete;
        NetConnection& operator=(const NetConnection& other) = delete;
 
        NetConnection(NetConnection && other) = delete;
        NetConnection& operator=(NetConnection && other) = delete;
 
    public:
        void open(const NetAddress& peer);

        void frame(const uint8_t* payload, size_t size, std::vector<uint8_t>& out);

        bool accept(
            const uint8_t* bytes,
            size_t size,
            std::vector<uint8_t>& payload,
            std::vector<uint16_t>& acknowledged
        );

        void refuse();

        void advance(float seconds);
 
        bool timedOut() const { return m_silent > TIMEOUT_SECONDS; }

        uint16_t nextSequence() const { return m_outgoing; }

        float roundTrip() const { return m_roundTrip; }

        float lossFraction() const {
            const uint64_t seen = m_arrived + m_missed;
            return seen == 0 ? 0.0f : static_cast<float>(m_missed) / static_cast<float>(seen);
        }

        float roundTripVariation() const { return m_variation; }
 
        const NetAddress& peer() const { return m_peer; }
 
    private:
        struct Sent {
            uint16_t sequence = 0;
            float    age      = 0.0f;
        };
 
    private:
        void recordTrip(uint16_t acknowledged, std::vector<uint16_t>& reported);
 
    private:
        NetAddress m_peer;
 
        uint16_t m_outgoing = NO_SEQUENCE + 1;  
        uint16_t m_newest   = 0;                
        uint32_t m_seen     = 0;                
        bool     m_heard    = false;
 
        uint16_t m_wasNewest = 0;  
        uint32_t m_wasSeen   = 0;
        bool     m_wasHeard  = false;
 
        float m_silent = 0.0f;  
 
        uint64_t m_arrived = 0;  
        uint64_t m_missed  = 0;  
 
        float m_roundTrip = 0.0f;
        float m_variation = 0.0f;
 
        std::vector<Sent> m_sent;
};
 
} // namespace Vkm::Engine