/**
 * Real-Time Connection Store (Server-Side)
 *
 * In-memory store that tracks active SSE connections per user.
 * Enables pushing events to specific users or all participants
 * of a conversation without a separate WebSocket server.
 *
 * Note: This is per-process. For multi-instance deployment,
 * swap the Map for Redis pub/sub.
 */

export type RealtimeEventType =
    | "new_message"
    | "typing_start"
    | "typing_stop"
    | "presence"
    | "read_receipt"
    | "ping";

export interface RealtimeEvent {
    type: RealtimeEventType;
    data: Record<string, unknown>;
    conversationId?: string;
    timestamp: string;
}

interface Connection {
    userId: string;
    controller: ReadableStreamDefaultController;
    connectedAt: Date;
    conversationIds: Set<string>; // conversations user is subscribed to
}

// ─── Global Connection Pool (via globalThis for Next.js HMR safety) ──
// Next.js may re-import modules during HMR or across bundles.
// Using globalThis ensures all route handlers share one connection pool.
// This is the same pattern used by Prisma to avoid multiple client instances.

interface RealtimeGlobal {
    connections: Map<string, Connection>;
    userConnections: Map<string, Set<string>>;
    onlineUsers: Set<string>;
    connectionCounter: number;
}

const globalForRealtime = globalThis as unknown as {
    __realtimeStore?: RealtimeGlobal;
};

if (!globalForRealtime.__realtimeStore) {
    globalForRealtime.__realtimeStore = {
        connections: new Map(),
        userConnections: new Map(),
        onlineUsers: new Set(),
        connectionCounter: 0,
    };
}

const { connections, userConnections, onlineUsers } = globalForRealtime.__realtimeStore;

// ─── Connection Management ──────────────────────────────────────

export function addConnection(
    userId: string,
    controller: ReadableStreamDefaultController,
    conversationIds: string[] = []
): string {
    const connId = `conn_${userId}_${++globalForRealtime.__realtimeStore!.connectionCounter}_${Date.now()}`;

    const conn: Connection = {
        userId,
        controller,
        connectedAt: new Date(),
        conversationIds: new Set(conversationIds),
    };

    connections.set(connId, conn);

    // Track user's connections
    if (!userConnections.has(userId)) {
        userConnections.set(userId, new Set());
    }
    userConnections.get(userId)!.add(connId);

    // Mark user as online
    const wasOffline = !onlineUsers.has(userId);
    onlineUsers.add(userId);

    // Broadcast presence if user just came online
    if (wasOffline) {
        broadcastPresence(userId, "online");
    }

    console.log(
        `[Realtime] +Connection ${connId} for user ${userId} (total: ${connections.size})`
    );

    return connId;
}

export function removeConnection(connId: string): void {
    const conn = connections.get(connId);
    if (!conn) return;

    connections.delete(connId);

    // Remove from user tracking
    const userConns = userConnections.get(conn.userId);
    if (userConns) {
        userConns.delete(connId);
        if (userConns.size === 0) {
            userConnections.delete(conn.userId);
            onlineUsers.delete(conn.userId);
            broadcastPresence(conn.userId, "offline");
        }
    }

    console.log(
        `[Realtime] -Connection ${connId} for user ${conn.userId} (total: ${connections.size})`
    );
}

export function subscribeToConversation(
    connId: string,
    conversationId: string
): void {
    const conn = connections.get(connId);
    if (conn) {
        conn.conversationIds.add(conversationId);
    }
}

// ─── Event Pushing ──────────────────────────────────────────────

function sendSSE(
    controller: ReadableStreamDefaultController,
    event: RealtimeEvent
): boolean {
    try {
        const data = `data: ${JSON.stringify(event)}\n\n`;
        controller.enqueue(new TextEncoder().encode(data));
        return true;
    } catch {
        return false; // Connection is dead
    }
}

/** Push an event to a specific user (all their tabs/connections) */
export function pushToUser(userId: string, event: RealtimeEvent): void {
    const userConns = userConnections.get(userId);
    if (!userConns) return;

    const deadConns: string[] = [];
    for (const connId of userConns) {
        const conn = connections.get(connId);
        if (conn) {
            if (!sendSSE(conn.controller, event)) {
                deadConns.push(connId);
            }
        }
    }

    // Clean up dead connections
    deadConns.forEach(removeConnection);
}

/** Push an event to all participants of a conversation (except sender) */
export function pushToConversation(
    conversationId: string,
    event: RealtimeEvent,
    excludeUserId?: string
): void {
    for (const [connId, conn] of connections) {
        if (
            conn.conversationIds.has(conversationId) &&
            conn.userId !== excludeUserId
        ) {
            if (!sendSSE(conn.controller, { ...event, conversationId })) {
                removeConnection(connId);
            }
        }
    }
}

/** Push to ALL connections of users who share a conversation with userId */
export function pushToUserConversationPeers(
    userId: string,
    event: RealtimeEvent
): void {
    // Get all conversations this user is in
    const userConns = userConnections.get(userId);
    if (!userConns) return;

    const peerUserIds = new Set<string>();

    // Find all peers
    for (const [, conn] of connections) {
        if (conn.userId === userId) continue;
        // Check if this connection shares any conversation with the user
        for (const connId of userConns) {
            const userConn = connections.get(connId);
            if (userConn) {
                for (const convId of userConn.conversationIds) {
                    if (conn.conversationIds.has(convId)) {
                        peerUserIds.add(conn.userId);
                        break;
                    }
                }
            }
        }
    }

    // Push to all peers
    for (const peerId of peerUserIds) {
        pushToUser(peerId, event);
    }
}

// ─── Presence ───────────────────────────────────────────────────

function broadcastPresence(
    userId: string,
    status: "online" | "offline"
): void {
    const event: RealtimeEvent = {
        type: "presence",
        data: { userId, status },
        timestamp: new Date().toISOString(),
    };
    pushToUserConversationPeers(userId, event);
}

export function isUserOnline(userId: string): boolean {
    return onlineUsers.has(userId);
}

export function getOnlineUserIds(): string[] {
    return Array.from(onlineUsers);
}

// ─── Heartbeat ──────────────────────────────────────────────────

export function sendHeartbeat(connId: string): boolean {
    const conn = connections.get(connId);
    if (!conn) return false;
    return sendSSE(conn.controller, {
        type: "ping",
        data: {},
        timestamp: new Date().toISOString(),
    });
}

// ─── Stats (debugging) ─────────────────────────────────────────

export function getStats() {
    return {
        totalConnections: connections.size,
        onlineUsers: onlineUsers.size,
        userBreakdown: Array.from(userConnections.entries()).map(
            ([uid, conns]) => ({
                userId: uid,
                connections: conns.size,
            })
        ),
    };
}
