using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Threading.Tasks;
namespace GameCult.Networking
{
///
/// Result of a bounded non-blocking RUDP schema-server drain.
///
public readonly struct RudpCultNetSchemaPollResult
{
public RudpCultNetSchemaPollResult(int transportItemsConsumed, int messagesDispatched)
{
TransportItemsConsumed = transportItemsConsumed;
MessagesDispatched = messagesDispatched;
}
/// Gets transport work consumed, including ACK and connection control packets.
public int TransportItemsConsumed { get; }
/// Gets application schema messages dispatched.
public int MessagesDispatched { get; }
}
///
/// Options for hosting schema-v0 messages over the native CultNet RUDP listener.
///
public sealed class RudpCultNetSchemaServerOptions
{
///
/// Gets or sets the runtime id advertised by the RUDP listener.
///
public string RuntimeId { get; set; } = "csharp-rudp-schema-server";
///
/// Gets or sets the UDP socket used by the listener. When omitted, a loopback socket is created.
///
public Socket? Socket { get; set; }
///
/// Gets or sets the accepted RUDP connection id.
///
public uint ConnectionId { get; set; } = 0x43554c54;
///
/// Gets or sets the first local packet sequence for each accepted peer.
///
public uint InitialSequence { get; set; } = 100;
///
/// Gets or sets the resend delay in milliseconds.
///
public long ResendDelayMs { get; set; } = 25;
///
/// Gets or sets the advertised transport id.
///
public string TransportId { get; set; } = "schema-rudp";
///
/// Gets or sets the maximum fragment size for schema-channel payloads.
///
public int? MaxFragmentBytes { get; set; } = 1024;
///
/// Gets or sets the maximum pending reliable packet count.
///
public int? MaxPendingReliablePackets { get; set; }
///
/// Gets or sets the payload sent with accept packets.
///
public byte[]? AcceptPayload { get; set; }
}
///
/// Peer context for a schema-v0 RUDP server.
///
public sealed class RudpCultNetSchemaServerPeer : ICultNetSchemaServerPeer
{
private readonly RudpCultNetSchemaServer _server;
internal RudpCultNetSchemaServerPeer(
RudpCultNetSchemaServer server,
CultNetRudpSocketServerPeer transportPeer)
{
_server = server;
TransportPeer = transportPeer;
}
///
/// Gets the underlying RUDP transport peer.
///
public CultNetRudpSocketServerPeer TransportPeer { get; }
///
/// Gets the UDP endpoint for this peer.
///
public EndPoint RemoteEndPoint => TransportPeer.RemoteEndPoint;
///
/// Sends a schema-v0 response to this peer.
///
public void SendCultNet(TMessage message)
where TMessage : ICultNetSchemaMessage
{
_server.SendCultNet(TransportPeer, message);
}
}
///
/// Multi-peer schema-v0 host over the native CultNet RUDP transport.
///
public sealed class RudpCultNetSchemaServer : ICultNetSchemaServer, IDisposable
{
private readonly Socket _socket;
private readonly CultNetRudpSocketTransportServer _transport;
private readonly ConcurrentDictionary _handlers = new();
private readonly ConcurrentDictionary _schemaPeerAdapters = new();
private bool _disposed;
///
/// Creates a schema-v0 RUDP server.
///
public RudpCultNetSchemaServer(RudpCultNetSchemaServerOptions? options = null)
{
options ??= new RudpCultNetSchemaServerOptions();
var socket = options.Socket;
if (socket == null)
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
socket.Bind(new IPEndPoint(IPAddress.Loopback, 0));
}
_socket = socket;
_transport = new CultNetRudpSocketTransportServer(new CultNetRudpSocketTransportServerOptions
{
RuntimeId = options.RuntimeId,
Socket = socket,
ConnectionId = options.ConnectionId,
InitialSequence = options.InitialSequence,
ResendDelayMs = options.ResendDelayMs,
TransportId = options.TransportId,
MaxFragmentBytes = options.MaxFragmentBytes,
MaxPendingReliablePackets = options.MaxPendingReliablePackets,
AcceptPayload = options.AcceptPayload
});
}
///
/// Gets the underlying RUDP listener profile.
///
public CultNetTransportProfile Profile => _transport.Profile;
///
/// Gets the local UDP endpoint.
///
public IPEndPoint LocalEndPoint => (IPEndPoint)_socket.LocalEndPoint!;
///
/// Gets a snapshot of the current transfer counters.
///
public CultNetTransportStats Stats => _transport.Stats;
///
/// Gets the currently tracked RUDP peers.
///
public IReadOnlyCollection Peers => _transport.Peers;
///
/// Registers a schema-v0 handler.
///
public void OnCultNet(Func callback)
where TMessage : ICultNetSchemaMessage
{
if (callback == null) throw new ArgumentNullException(nameof(callback));
_handlers.AddOrUpdate(
typeof(TMessage),
_ => callback,
(type, current) =>
{
var combined = Delegate.Combine(current, callback) as Func;
return combined ?? throw new InvalidOperationException($"Failed to combine delegates for {type.Name}.");
});
}
///
/// Registers a schema-v0 handler.
///
public void OnCultNet(Action callback)
where TMessage : ICultNetSchemaMessage
{
if (callback == null) throw new ArgumentNullException(nameof(callback));
OnCultNet((message, peer) =>
{
callback(message, peer);
return Task.CompletedTask;
});
}
///
public void OnCultNet(Func callback)
where TMessage : ICultNetSchemaMessage
{
if (callback == null) throw new ArgumentNullException(nameof(callback));
Func adapter = (message, peer) => callback(message, peer);
_schemaPeerAdapters[callback] = adapter;
OnCultNet(adapter);
}
///
public void RemoveCultNetMessageListener(Delegate callback)
where TMessage : ICultNetSchemaMessage
{
if (_schemaPeerAdapters.TryRemove(callback, out var adapter))
{
callback = adapter;
}
if (!_handlers.TryGetValue(typeof(TMessage), out var current))
{
return;
}
var next = Delegate.Remove(current, callback);
if (next == null)
{
_handlers.TryRemove(typeof(TMessage), out _);
}
else
{
_handlers[typeof(TMessage)] = next;
}
}
///
/// Sends a schema-v0 message to a transport peer.
///
public void SendCultNet(CultNetRudpSocketServerPeer peer, TMessage message)
where TMessage : ICultNetSchemaMessage
{
_transport.SendSchemaMessage(peer, message);
}
///
/// Polls one packet/frame and dispatches at most one schema-v0 message.
///
public async Task PollOnceAsync()
{
if (!_transport.TryReceiveOnce(out var delivered) || delivered == null)
{
return false;
}
return await DispatchAsync(delivered).ConfigureAwait(false);
}
///
/// Drains up to immediately available transport work items.
/// Control packets count as progress so callers only idle when the transport is actually empty.
///
public async Task PollAvailableAsync(int maxTransportItems)
{
if (maxTransportItems <= 0) throw new ArgumentOutOfRangeException(nameof(maxTransportItems));
var consumed = 0;
var dispatched = 0;
while (consumed < maxTransportItems && _transport.TryReceiveOnce(out var delivered))
{
consumed++;
if (delivered != null && await DispatchAsync(delivered).ConfigureAwait(false))
dispatched++;
}
return new RudpCultNetSchemaPollResult(consumed, dispatched);
}
private async Task DispatchAsync(CultNetRudpSocketServerFrame delivered)
{
if (!string.Equals(delivered.Frame.ChannelId, "schema", StringComparison.Ordinal))
return false;
var message = CultNetSchemaMessageSerialization.Deserialize(delivered.Frame.Payload);
if (!_handlers.TryGetValue(message.GetType(), out var handler) || handler == null)
{
return false;
}
var result = handler.DynamicInvoke(message, new RudpCultNetSchemaServerPeer(this, delivered.Peer));
if (result is Task task)
{
await task.ConfigureAwait(false);
}
return true;
}
///
/// Sends any reliable packets whose resend timers are due.
///
public void PollResends()
{
_transport.PollResends();
}
///
public void Dispose()
{
if (_disposed)
{
return;
}
_disposed = true;
_transport.Dispose();
}
}
}