SNote/Server/Security/PeerCache.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;

namespace SNote.Server.Security;

public class PeerCache
{
    // Mapping: PeerUrl (normalized) -> PeerDetails (SessionToken, PublicKeyPem)
    private readonly ConcurrentDictionary<string, PeerDetails> _downstreamPeers = new(StringComparer.OrdinalIgnoreCase);
    private readonly ConcurrentDictionary<string, DateTime> _recentBroadcastIds = new(StringComparer.OrdinalIgnoreCase);

    public void RegisterPeer(string peerUrl, string sessionToken, string publicKeyPem)
    {
        if (string.IsNullOrWhiteSpace(peerUrl) || string.IsNullOrWhiteSpace(sessionToken)) return;
        
        var cleanUrl = peerUrl.Trim().TrimEnd('/');
        var details = new PeerDetails(sessionToken, publicKeyPem.Trim());
        
        _downstreamPeers[cleanUrl] = details;
        Console.WriteLine($"[PeerCache] Registered downstream peer node: {cleanUrl} with secure session token.");
    }

    public void RemovePeer(string peerUrl)
    {
        if (string.IsNullOrWhiteSpace(peerUrl)) return;
        
        var cleanUrl = peerUrl.Trim().TrimEnd('/');
        if (_downstreamPeers.TryRemove(cleanUrl, out _))
        {
            Console.WriteLine($"[PeerCache] Evicted offline peer node: {cleanUrl}");
        }
    }

    public List<string> GetPeers()
    {
        return new List<string>(_downstreamPeers.Keys);
    }

    public string? GetToken(string peerUrl)
    {
        var cleanUrl = peerUrl.Trim().TrimEnd('/');
        return _downstreamPeers.TryGetValue(cleanUrl, out var details) ? details.SessionToken : null;
    }

    public string? GetPublicKey(string peerUrl)
    {
        var cleanUrl = peerUrl.Trim().TrimEnd('/');
        return _downstreamPeers.TryGetValue(cleanUrl, out var details) ? details.PublicKeyPem : null;
    }

    public bool VerifySessionToken(string peerUrl, string token)
    {
        if (string.IsNullOrEmpty(peerUrl) || string.IsNullOrEmpty(token)) return false;
        
        var cleanUrl = peerUrl.Trim().TrimEnd('/');
        if (_downstreamPeers.TryGetValue(cleanUrl, out var details))
        {
            return string.Equals(details.SessionToken, token, StringComparison.Ordinal);
        }
        return false;
    }

    public List<(string Url, string Token)> GetActivePeers()
    {
        var list = new List<(string Url, string Token)>();
        foreach (var kvp in _downstreamPeers)
        {
            list.Add((kvp.Key, kvp.Value.SessionToken));
        }
        return list;
    }

    public bool TryProcessBroadcast(string broadcastId)
    {
        if (string.IsNullOrWhiteSpace(broadcastId)) return false;

        // Clean up old entries to prevent infinite memory growth (older than 10 minutes)
        var cutoff = DateTime.UtcNow.AddMinutes(-10);
        foreach (var kvp in _recentBroadcastIds)
        {
            if (kvp.Value < cutoff)
            {
                _recentBroadcastIds.TryRemove(kvp.Key, out _);
            }
        }

        return _recentBroadcastIds.TryAdd(broadcastId, DateTime.UtcNow);
    }
}

public record PeerDetails(string SessionToken, string PublicKeyPem);