import { useState, useEffect, useCallback } from 'react';
import { useAuth } from '../contexts/AuthContext';
import { useWebSocket } from './useWebSocket';
import { messageService, conversationService } from '../services/api';

export const useMessages = (conversationId) => {
  const [messages, setMessages] = useState([]);
  const [loading, setLoading] = useState(false);
  const [hasMore, setHasMore] = useState(true);
  const [page, setPage] = useState(1);
  const [typingUsers, setTypingUsers] = useState([]);
  const { user } = useAuth();

  const { sendMessage, subscribe, unsubscribe } = useWebSocket();

  // Load initial messages
  const loadMessages = useCallback(async (reset = false) => {
    if (!conversationId) return;

    try {
      setLoading(true);
      const currentPage = reset ? 1 : page;
      const response = await conversationService.getMessages(conversationId, currentPage);
      
      if (reset) {
        setMessages(response.messages);
        setPage(1);
      } else {
        setMessages(prev => [...response.messages, ...prev]);
      }
      
      setHasMore(response.messages.length === 50); // Assuming 50 per page
      if (!reset) {
        setPage(prev => prev + 1);
      }
    } catch (error) {
      console.error('Error loading messages:', error);
    } finally {
      setLoading(false);
    }
  }, [conversationId, page]);

  // Send message
  const sendNewMessage = useCallback(async (content, type = 'text', attachment = null, replyTo = null) => {
    if (!conversationId) return;

    const messageData = {
      conversationId,
      content,
      type,
      attachment,
      replyTo
    };

    // Optimistic update
    const tempMessage = {
      _id: `temp-${Date.now()}`,
      ...messageData,
      sender: user,
      status: 'sending',
      createdAt: new Date(),
      isOptimistic: true
    };

    setMessages(prev => [...prev, tempMessage]);

    // Send via socket
    sendMessage('message:send', messageData);
  }, [conversationId, user, sendMessage]);

  // Mark message as read
  const markAsRead = useCallback((messageId) => {
    if (!conversationId) return;

    sendMessage('message:read', {
      messageId,
      conversationId
    });

    // Update local state
    setMessages(prev =>
      prev.map(msg =>
        msg._id === messageId
          ? { ...msg, readBy: [...(msg.readBy || []), { user: user.id }] }
          : msg
      )
    );
  }, [conversationId, user?.id, sendMessage]);

  // Handle incoming messages
  useEffect(() => {
    if (!conversationId) return;

    const handleNewMessage = (message) => {
      setMessages(prev => {
        // Remove optimistic message if exists
        const filtered = prev.filter(msg => !msg.isOptimistic || msg._id !== `temp-${message._id}`);
        return [...filtered, message];
      });
    };

    const handleMessageRead = (data) => {
      setMessages(prev =>
        prev.map(msg =>
          msg._id === data.messageId
            ? {
                ...msg,
                readBy: [...(msg.readBy || []), { user: data.userId }]
              }
            : msg
        )
      );
    };

    const handleTypingStart = (data) => {
      if (data.userId !== user?.id) {
        setTypingUsers(prev => [...prev.filter(id => id !== data.userId), data.userId]);
      }
    };

    const handleTypingStop = (data) => {
      setTypingUsers(prev => prev.filter(id => id !== data.userId));
    };

    // Subscribe to events
    subscribe('message:receive', handleNewMessage);
    subscribe('message:read', handleMessageRead);
    subscribe('typing:start', handleTypingStart);
    subscribe('typing:stop', handleTypingStop);

    return () => {
      unsubscribe('message:receive', handleNewMessage);
      unsubscribe('message:read', handleMessageRead);
      unsubscribe('typing:start', handleTypingStart);
      unsubscribe('typing:stop', handleTypingStop);
    };
  }, [conversationId, user?.id, subscribe, unsubscribe]);

  // Load messages when conversation changes
  useEffect(() => {
    if (conversationId) {
      loadMessages(true);
    }
  }, [conversationId]);

  return {
    messages,
    loading,
    hasMore,
    typingUsers,
    sendMessage: sendNewMessage,
    loadMore: () => loadMessages(false),
    markAsRead,
    setTypingUsers
  };
};