/*
 * server/session_registry.h — In-memory session, channel, and user registry.
 *
 * Tracks all authenticated sessions, the channel tree, user<→>channel assignments,
 * UDP endpoint bindings (M2), and SSRC<→>session mappings (M2).
 * Protected by a shared_mutex (many readers, few writers). All methods are thread-safe.
 */
#ifndef VOICECAT_SERVER_SESSION_REGISTRY_H
#define VOICECAT_SERVER_SESSION_REGISTRY_H

#ifdef VOICECAT_HAS_NET

#include <array>
#include <atomic>
#include <cstdint>
#include <memory>
#include <shared_mutex>
#include <string>
#include <unordered_map>
#include <vector>

#define ASIO_STANDALONE 1
#include <asio.hpp>

#include "proto/voicecat.pb.h"

namespace voicecat::server {

class ConnSession;

struct ChannelEntry {
    voicecat::v1::Channel proto;
};

struct UserEntry {
    voicecat::v1::User proto;
    uint64_t session_id{};
};

// Hashes asio::ip::udp::endpoint by "addr:port" string.
struct UdpEndpointHash {
    size_t operator()(const asio::ip::udp::endpoint& ep) const {
        std::string key = ep.address().to_string() + ':' + std::to_string(ep.port());
        return std::hash<std::string>{}(key);
    }
};

class SessionRegistry {
   public:
    SessionRegistry() = default;

    // Create the default "Lobby" channel (id=1, permanent). Call once at startup.
    void init_default_channels();

    // Register a session (before auth). Returns the assigned session_id.
    uint64_t register_session(std::weak_ptr<ConnSession> session);

    // Remove a session (called on disconnect).
    void unregister_session(uint64_t session_id);

    // Add a user once authenticated. Returns the assigned user_id.
    uint32_t add_user(uint64_t session_id, const voicecat::v1::User& user);

    // Remove a user (called on disconnect after auth).
    void remove_user(uint32_t user_id);

    // Move a user to a channel. Returns false if channel doesn't exist.
    bool set_user_channel(uint32_t user_id, uint32_t channel_id);

    // Snapshot for ServerStateSnapshot message.
    std::vector<voicecat::v1::Channel> channel_snapshot() const;
    std::vector<voicecat::v1::User>    user_snapshot() const;

    // Resolve target sessions for a text message relay.
    std::vector<std::shared_ptr<ConnSession>> resolve_text_targets(
        uint64_t sender_session_id, voicecat::v1::TextScope scope, uint32_t target_id) const;

    // Broadcast an envelope to all sessions except the excluded one.
    void broadcast(const voicecat::v1::Envelope& env, uint64_t exclude_session_id = 0) const;

    // ── M2: UDP / media ──────────────────────────────────────────────────────

    // Register a session's UDP token (called at auth success).
    void register_udp_token(const std::array<uint8_t, 16>& token, uint64_t session_id);

    // Locate a session by its UDP binding token (called by MediaRelay on UDP_BINDING).
    std::shared_ptr<ConnSession> find_by_udp_token(const std::array<uint8_t, 16>& token) const;

    // Associate a UDP endpoint with a session (called by MediaRelay after token verification).
    void register_udp_endpoint(asio::ip::udp::endpoint ep, uint64_t session_id);

    // Locate the session that owns a UDP sender endpoint (called per incoming voice packet).
    std::shared_ptr<ConnSession> find_by_udp_endpoint(const asio::ip::udp::endpoint& ep) const;

    // Assign an SSRC for a new stream. Returns the assigned SSRC.
    uint32_t assign_ssrc(uint64_t session_id);

    // Get all sessions in a channel except the one excluded (for SFU relay).
    std::vector<std::shared_ptr<ConnSession>> find_channel_sessions(
        uint32_t channel_id, uint64_t exclude_session_id = 0) const;

    // Return the channel_id of a user (0 if not found).
    uint32_t user_channel(uint32_t user_id) const;

   private:
    mutable std::shared_mutex mu_;

    uint64_t next_session_id_{1};
    uint32_t next_user_id_{1};
    uint32_t next_channel_id_{2};  // 1 is reserved for Lobby

    std::unordered_map<uint64_t, std::weak_ptr<ConnSession>> sessions_;
    std::unordered_map<uint32_t, UserEntry>                   users_;
    std::unordered_map<uint32_t, ChannelEntry>                channels_;

    // M2: token → session_id (populated at auth, cleared on disconnect)
    struct TokenHash {
        size_t operator()(const std::array<uint8_t, 16>& t) const {
            // FNV-1a over 16 bytes
            size_t h = 14695981039346656037ULL;
            for (auto b : t) { h ^= b; h *= 1099511628211ULL; }
            return h;
        }
    };
    std::unordered_map<std::array<uint8_t, 16>, uint64_t, TokenHash> udp_tokens_;

    // M2: UDP endpoint → session_id (populated after UDP binding packet arrives)
    std::unordered_map<asio::ip::udp::endpoint, uint64_t, UdpEndpointHash> udp_endpoints_;

    // M2: ssrc → session_id (populated when StreamAnnounce is processed)
    std::unordered_map<uint32_t, uint64_t> ssrc_to_session_;
    std::atomic<uint32_t> next_ssrc_{1};
};

}  // namespace voicecat::server

#endif  // VOICECAT_HAS_NET
#endif  // VOICECAT_SERVER_SESSION_REGISTRY_H