C_client.hpp

/*
 * Copyright 2026 Guillaume Guillet
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _FGE_C_CLIENT_HPP_INCLUDED
#define _FGE_C_CLIENT_HPP_INCLUDED
 
#include "FastEngine/fge_extern.hpp"
#include "C_identity.hpp"
#include "FastEngine/C_event.hpp"
#include "FastEngine/C_propertyList.hpp"
#include "FastEngine/network/C_netCommand.hpp"
#include "FastEngine/network/C_protocol.hpp"
#include <array>
#include <atomic>
#include <chrono>
#include <deque>
#include <memory>
#include <mutex>
#include <unordered_set>
 
#define FGE_NET_DEFAULT_LATENCY 20
#define FGE_NET_CLIENT_TIMESTAMP_MODULO 65536
#define FGE_NET_BAD_LATENCY std::numeric_limits<fge::net::Latency_ms>::max()
#define FGE_NET_LATENCY_PLANNER_MEAN 6
#define FGE_NET_DEFAULT_lOST_PACKET_THRESHOLD 15
#define FGE_NET_STATUS_DEFAULT_TIMEOUT                                                                                 \
    std::chrono::milliseconds                                                                                          \
    {                                                                                                                  \
        2000                                                                                                           \
    }
#define FGE_NET_STATUS_DEFAULT_CONNECTED_TIMEOUT                                                                       \
    std::chrono::milliseconds                                                                                          \
    {                                                                                                                  \
        6000                                                                                                           \
    }
#define FGE_NET_STATUS_DEFAULT_STATUS "none"
 
#define FGE_NET_DEFAULT_RETURN_PACKET_RATE                                                                             \
    std::chrono::milliseconds                                                                                          \
    {                                                                                                                  \
        500                                                                                                            \
    }
 
namespace fge::net
{

 
using Timestamp = uint16_t;          
using FullTimestamp = uint64_t;      
using FullTimestampOffset = int64_t; 
using Latency_ms = uint16_t; 

class FGE_API OneWayLatencyPlanner
{
public:
    OneWayLatencyPlanner() = default;
 
    enum Stats : uint8_t
    {
        HAVE_EXTERNAL_TIMESTAMP = 1 << 0
    };

    void pack(TransmitPacketPtr& tPacket);
    void unpack(ProtocolPacket* packet, Client& client);

    [[nodiscard]] std::optional<FullTimestampOffset> getClockOffset() const;
    [[nodiscard]] std::optional<Latency_ms> getLatency() const;
    [[nodiscard]] std::optional<Latency_ms> getOtherSideLatency() const;
    [[nodiscard]] std::optional<Latency_ms> getRoundTripTime() const;
 
private:
    std::optional<Latency_ms> g_latency;
    std::optional<Latency_ms> g_otherSideLatency;
 
    std::optional<FullTimestampOffset> g_meanClockOffset;
    std::array<FullTimestampOffset, FGE_NET_LATENCY_PLANNER_MEAN> g_clockOffsets{};
    std::size_t g_clockOffsetCount{0};
 
    std::optional<Latency_ms> g_roundTripTime;
 
    Timestamp g_externalStoredTimestamp{0};
    std::underlying_type_t<Stats> g_syncStat{0};
};
 
struct ClientContext
{
    PacketDefragmentation _defragmentation;
    PacketCache _cache;
    PacketReorderer _reorderer;
    CommandQueue _commands;
};
 
class FGE_API ClientStatus
{
public:
    enum class NetworkStatus
    {
        UNKNOWN,
 
        ACKNOWLEDGED,
        MTU_DISCOVERED,
        CONNECTED,
        AUTHENTICATED,
 
        DISCONNECTED,
        TIMEOUT,
    };
 
    ClientStatus() = default;
    explicit ClientStatus(std::string_view status, NetworkStatus networkStatus = NetworkStatus::UNKNOWN);
 
    [[nodiscard]] bool isInEncryptedState() const;
    [[nodiscard]] bool isDisconnected() const;
    [[nodiscard]] bool isConnected() const;
    [[nodiscard]] bool isConnecting() const;
    [[nodiscard]] bool isAuthenticated() const;
 
    [[nodiscard]] std::string const& getStatus() const;
    [[nodiscard]] NetworkStatus getNetworkStatus() const;
    [[nodiscard]] std::chrono::milliseconds getTimeout() const;
    [[nodiscard]] std::chrono::milliseconds getRemainingTimeout() const;
 
    void set(std::string_view status, NetworkStatus networkStatus);
    void setStatus(std::string_view status);
    void setNetworkStatus(NetworkStatus networkStatus);
 
    void setTimeout(std::chrono::milliseconds timeout);
    void resetTimeout();
    [[nodiscard]] bool isTimeout() const;
 
private:
    std::string g_status{FGE_NET_STATUS_DEFAULT_STATUS};
    std::atomic<NetworkStatus> g_networkStatus{NetworkStatus::UNKNOWN};
    std::chrono::milliseconds g_timeout{FGE_NET_STATUS_DEFAULT_TIMEOUT};
    std::chrono::steady_clock::time_point g_currentTimeout{std::chrono::steady_clock::now()};
};
 
struct FGE_API CryptInfo
{
    ~CryptInfo();
 
    void* _ssl{nullptr};
    void* _rbio{nullptr};
    void* _wbio{nullptr};
};

class FGE_API Client
{
public:
    Client();
    ~Client();
 
    enum class Targets
    {
        PEER,
        HOST
    };

    explicit Client(Latency_ms CTOSLatency, Latency_ms STOCLatency);

    void setCTOSLatency_ms(Latency_ms latency);
    void setSTOCLatency_ms(Latency_ms latency);
    Latency_ms getCTOSLatency_ms() const;
    Latency_ms getSTOCLatency_ms() const;
    Latency_ms getPing_ms() const;

    void setCorrectorTimestamp(Timestamp timestamp);
    std::optional<Timestamp> getCorrectorTimestamp() const;
    std::optional<Latency_ms> getCorrectorLatency() const;

    void resetLastPacketTimePoint();
    [[nodiscard]] std::chrono::milliseconds getLastPacketElapsedTime() const;
    [[nodiscard]] Latency_ms getLastPacketLatency() const;

    static Timestamp getTimestamp_ms();
    static Timestamp getTimestamp_ms(FullTimestamp fullTimestamp);
    static FullTimestamp getFullTimestamp_ms();
    static Latency_ms computeLatency_ms(Timestamp const& sentTimestamp, Timestamp const& receivedTimestamp);

    void clearPackets();
    void pushPacket(TransmitPacketPtr pck);
    void pushForcedFrontPacket(TransmitPacketPtr pck);
    [[nodiscard]] bool isReadyToAcceptMorePendingPackets() const;
    TransmitPacketPtr popPacket();
    bool isPendingPacketsEmpty() const;
    void allowMorePendingPackets(bool allow);
 
    void disconnect(bool pushDisconnectPacket = true);
 
    [[nodiscard]] ProtocolPacket::RealmType getCurrentRealm() const;
    [[nodiscard]] std::chrono::milliseconds getLastRealmChangeElapsedTime() const;
    void setCurrentRealm(ProtocolPacket::RealmType realm);
    ProtocolPacket::RealmType advanceCurrentRealm();
 
    [[nodiscard]] ProtocolPacket::CounterType getPacketCounter(Targets target) const;
    ProtocolPacket::CounterType advancePacketCounter(Targets target);
    void setPacketCounter(Targets target, ProtocolPacket::CounterType count);
 
    [[nodiscard]] ProtocolPacket::CounterType getReorderedPacketCounter(Targets target) const;
    ProtocolPacket::CounterType advanceReorderedPacketCounter(Targets target);
    void setReorderedPacketCounter(Targets target, ProtocolPacket::CounterType count);
 
    void resetAllCounters();
 
    void acknowledgeReception(ReceivedPacketPtr const& packet);
    [[nodiscard]] std::unordered_set<PacketCache::Label, PacketCache::Label::Hash> const& getAcknowledgedList() const;
    void clearAcknowledgedList();
 
    void clearLostPacketCount();
    uint32_t advanceLostPacketCount();
    void setLostPacketThreshold(uint32_t threshold);
    [[nodiscard]] uint32_t getLostPacketThreshold() const;
    [[nodiscard]] uint32_t getLostPacketCount() const;
 
    [[nodiscard]] ClientStatus const& getStatus() const;
    [[nodiscard]] ClientStatus& getStatus();
 
    [[nodiscard]] CryptInfo const& getCryptInfo() const;
    [[nodiscard]] CryptInfo& getCryptInfo();
 
    [[nodiscard]] uint16_t getMTU() const;
    void setMTU(uint16_t mtu);
 
    void setPacketReturnRate(std::chrono::milliseconds rate);
    [[nodiscard]] std::chrono::milliseconds getPacketReturnRate() const;
 
    CallbackHandler<Client&> _onThresholdLostPacket;
 
    Event _event;                         
    PropertyList _data;                   
    OneWayLatencyPlanner _latencyPlanner; 
    ClientContext _context;        
    bool _mtuFinalizedFlag{false}; 
 
private:
    mutable std::optional<Timestamp> g_correctorTimestamp;
    Latency_ms g_CTOSLatency_ms;
    Latency_ms g_STOCLatency_ms;
    std::chrono::steady_clock::time_point g_lastPacketTimePoint;
 
    std::deque<TransmitPacketPtr> g_pendingTransmitPackets;
    mutable std::recursive_mutex g_mutex;
 
    std::chrono::steady_clock::time_point g_lastRealmChangeTimePoint;
    ProtocolPacket::RealmType g_currentRealm{FGE_NET_DEFAULT_REALM};
 
    ProtocolPacket::CounterType g_hostPacketCounter{0};
    ProtocolPacket::CounterType g_hostReorderedPacketCounter{0};
    ProtocolPacket::CounterType g_peerPacketCounter{0};
    ProtocolPacket::CounterType g_peerReorderedPacketCounter{0};
 
    std::unordered_set<PacketCache::Label, PacketCache::Label::Hash> g_acknowledgedPackets;
    uint32_t g_lostPacketCount{0};
    uint32_t g_lostPacketThreshold{FGE_NET_DEFAULT_lOST_PACKET_THRESHOLD};
 
    std::chrono::milliseconds g_returnPacketRate{FGE_NET_DEFAULT_RETURN_PACKET_RATE};
 
    uint16_t g_mtu{0};
 
    ClientStatus g_status;
    CryptInfo g_cryptInfo;
 
    bool g_allowMorePackets{true};
};

 
} // namespace fge::net
 
#endif // _FGE_C_CLIENT_HPP_INCLUDED