"use client";

import { useState, useEffect, useRef, useCallback } from "react";

export interface RealtimeMessage {
    id: string;
    conversationId: string;
    content: string;
    senderId: string;
    senderName: string;
    senderAvatar: string | null;
    senderRole: string;
    messageType: string;
    createdAt: string;
    attachments?: {
        id: string;
        filename: string;
        fileUrl: string;
        fileSize: number;
        mimeType: string;
        thumbnailUrl: string | null;
    }[];
}

interface TypingUser {
    userId: string;
    userName: string;
    conversationId: string;
    expiresAt: number; // timestamp when this typing indicator expires
}

interface UseRealtimeMessagesOptions {
    /** If provided, only listen for events on this conversation */
    conversationId?: string;
    /** Called when connection status changes */
    onConnectionChange?: (connected: boolean) => void;
}

export interface ReadReceiptEvent {
    conversationId: string;
    readerId: string;
    readerName: string;
    messageIds: string[];
    readAt: string;
}

export interface RealtimeAttachmentEvent {
    messageId: string;
    attachment: NonNullable<RealtimeMessage['attachments']>[0];
}

interface UseRealtimeMessagesReturn {
    /** New messages arriving in real-time */
    newMessages: RealtimeMessage[];
    /** New attachments arriving in real-time mapping to previous messages */
    newAttachments: RealtimeAttachmentEvent[];
    /** Clear new messages (e.g., after appending to thread) */
    clearMessages: () => void;
    /** Users currently typing */
    typingUsers: TypingUser[];
    /** Set of online user IDs */
    onlineUsers: Set<string>;
    /** Whether SSE connection is active */
    isConnected: boolean;
    /** Connection ID for subscribing to new conversations */
    connectionId: string | null;
    /** Send a typing indicator */
    sendTyping: (conversationId: string, isTyping: boolean) => void;
    /** Read receipts received from other users */
    readReceipts: ReadReceiptEvent[];
    /** Mark all messages in a conversation as read */
    markConversationRead: (conversationId: string) => void;
}

const RECONNECT_DELAYS = [1000, 3000, 10000, 30000]; // exponential backoff

export function useRealtimeMessages(
    options: UseRealtimeMessagesOptions = {}
): UseRealtimeMessagesReturn {
    const { conversationId, onConnectionChange } = options;

    const [newMessages, setNewMessages] = useState<RealtimeMessage[]>([]);
    const [typingUsers, setTypingUsers] = useState<TypingUser[]>([]);
    const [onlineUsers, setOnlineUsers] = useState<Set<string>>(new Set());
    const [isConnected, setIsConnected] = useState(false);
    const [connectionId, setConnectionId] = useState<string | null>(null);
    const [readReceipts, setReadReceipts] = useState<ReadReceiptEvent[]>([]);
    const [newAttachments, setNewAttachments] = useState<RealtimeAttachmentEvent[]>([]);

    const eventSourceRef = useRef<EventSource | null>(null);
    const reconnectAttemptRef = useRef(0);
    const reconnectTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
    const lastTypingRef = useRef<Record<string, number>>({}); // throttle typing events

    const clearMessages = useCallback(() => {
        setNewMessages([]);
    }, []);

    // Clean up expired typing indicators every second
    useEffect(() => {
        const interval = setInterval(() => {
            setTypingUsers((prev) =>
                prev.filter((t) => t.expiresAt > Date.now())
            );
        }, 1000);
        return () => clearInterval(interval);
    }, []);

    // SSE connection
    useEffect(() => {
        let isMounted = true;

        function connect() {
            if (!isMounted) return;

            // Close existing connection
            if (eventSourceRef.current) {
                eventSourceRef.current.close();
            }

            const es = new EventSource("/api/messages/stream");
            eventSourceRef.current = es;

            es.onopen = () => {
                if (!isMounted) return;
                reconnectAttemptRef.current = 0;
                setIsConnected(true);
                onConnectionChange?.(true);
            };

            es.onmessage = (event) => {
                if (!isMounted) return;

                try {
                    const parsed = JSON.parse(event.data);

                    switch (parsed.type) {
                        case "connected":
                            setConnectionId(parsed.data.connectionId);
                            break;

                        case "new_message": {
                            const msg = parsed.data as RealtimeMessage;
                            // If filtering by conversation, only accept matching messages
                            if (
                                conversationId &&
                                parsed.conversationId !== conversationId
                            ) {
                                break;
                            }
                            setNewMessages((prev) => [...prev, msg]);

                            // Remove typing indicator for sender
                            setTypingUsers((prev) =>
                                prev.filter(
                                    (t) =>
                                        t.userId !== msg.senderId ||
                                        t.conversationId !==
                                        parsed.conversationId
                                )
                            );
                            break;
                        }

                        case "typing_start": {
                            const { userId, userName, conversationId: convId } =
                                parsed.data;
                            if (
                                conversationId &&
                                convId !== conversationId
                            ) {
                                break;
                            }
                            setTypingUsers((prev) => {
                                // Update or add
                                const existing = prev.find(
                                    (t) =>
                                        t.userId === userId &&
                                        t.conversationId === convId
                                );
                                if (existing) {
                                    return prev.map((t) =>
                                        t.userId === userId &&
                                            t.conversationId === convId
                                            ? {
                                                ...t,
                                                expiresAt:
                                                    Date.now() + 10000,
                                            }
                                            : t
                                    );
                                }
                                return [
                                    ...prev,
                                    {
                                        userId,
                                        userName,
                                        conversationId: convId,
                                        expiresAt: Date.now() + 10000,
                                    },
                                ];
                            });
                            break;
                        }

                        case "typing_stop": {
                            const {
                                userId: stopUserId,
                                conversationId: stopConvId,
                            } = parsed.data;
                            setTypingUsers((prev) =>
                                prev.filter(
                                    (t) =>
                                        !(
                                            t.userId === stopUserId &&
                                            t.conversationId === stopConvId
                                        )
                                )
                            );
                            break;
                        }

                        case "presence": {
                            const { userId: presUserId, status } = parsed.data;
                            setOnlineUsers((prev) => {
                                const next = new Set(prev);
                                if (status === "online") {
                                    next.add(presUserId);
                                } else {
                                    next.delete(presUserId);
                                }
                                return next;
                            });
                            break;
                        }

                        case "read_receipt": {
                            const receipt = parsed.data as ReadReceiptEvent;
                            if (
                                conversationId &&
                                receipt.conversationId !== conversationId
                            ) {
                                break;
                            }
                            setReadReceipts((prev) => [...prev, receipt]);
                            break;
                        }

                        case "new_attachment": {
                            const { messageId, attachment } = parsed.data;
                            setNewAttachments((prev) => [...prev, { messageId, attachment }]);
                            break;
                        }

                        case "ping":
                            // Heartbeat, ignore
                            break;
                    }
                } catch {
                    // Ignore parse errors
                }
            };

            es.onerror = () => {
                if (!isMounted) return;
                setIsConnected(false);
                onConnectionChange?.(false);
                es.close();

                // Reconnect with exponential backoff
                const attempt = reconnectAttemptRef.current;
                const delay =
                    RECONNECT_DELAYS[
                    Math.min(attempt, RECONNECT_DELAYS.length - 1)
                    ];
                reconnectAttemptRef.current = attempt + 1;

                console.log(
                    `[Realtime] Reconnecting in ${delay}ms (attempt ${attempt + 1})`
                );
                reconnectTimerRef.current = setTimeout(connect, delay);
            };
        }

        connect();

        return () => {
            isMounted = false;
            if (eventSourceRef.current) {
                eventSourceRef.current.close();
            }
            if (reconnectTimerRef.current) {
                clearTimeout(reconnectTimerRef.current);
            }
        };
    }, [conversationId, onConnectionChange]);

    // Typing indicator sender (throttled to 1 per 3 seconds per conversation)
    const sendTyping = useCallback(
        (convId: string, isTyping: boolean) => {
            const now = Date.now();
            const key = `${convId}_${isTyping ? "start" : "stop"}`;

            // Throttle: don't send more than once per 3 seconds for start events
            if (isTyping && lastTypingRef.current[key]) {
                if (now - lastTypingRef.current[key] < 3000) return;
            }
            lastTypingRef.current[key] = now;

            fetch("/api/messages/typing", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify({
                    conversationId: convId,
                    isTyping,
                }),
            }).catch(() => {
                // Silently fail
            });
        },
        []
    );

    // Mark all messages in a conversation as read
    const markConversationRead = useCallback(
        (convId: string) => {
            fetch("/api/messages/read", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify({ conversationId: convId }),
            }).catch(() => {
                // Silently fail
            });
        },
        []
    );

    return {
        newMessages,
        newAttachments,
        clearMessages,
        typingUsers,
        onlineUsers,
        isConnected,
        connectionId,
        sendTyping,
        readReceipts,
        markConversationRead,
    };
}
