import { supabase } from "../../lib/supabase";

export type Message = {
  id: string;
  sender_id: string;
  receiver_id: string;
  content: string;
  read: boolean;
  created_at: string;
  sender_name?: string;
  sender_role?: string;
  receiver_name?: string;
  receiver_role?: string;
  subject?: string;
  sender_email?: string;
};

export type Conversation = {
  user_id: string;
  user_name: string;
  user_role: string;
  last_message: string;
  last_message_time: string;
  unread_count: number;
};

export const messageService = {
  /**
   * Busca conversas do usuário (lista de pessoas com quem conversou)
   */
  async getConversations(userId: string): Promise<Conversation[]> {
    try {
      // Busca mensagens onde o usuário é remetente ou destinatário
      const { data: messages, error } = await supabase
        .from("messages")
        .select("*")
        .or(`sender_id.eq.${userId},receiver_id.eq.${userId}`)
        .order("created_at", { ascending: false });

      if (error) throw error;

      // Agrupa por usuário (a outra pessoa da conversa)
      const conversationsMap = new Map<string, Conversation>();

      messages?.forEach((msg: any) => {
        const isReceiver = msg.receiver_id === userId;
        const otherUserId = isReceiver ? msg.sender_id : msg.receiver_id;

        if (!conversationsMap.has(otherUserId)) {
          conversationsMap.set(otherUserId, {
            user_id: otherUserId,
            user_name: "Usuário",
            user_role: "unknown",
            last_message: msg.content,
            last_message_time: msg.created_at,
            unread_count: 0,
          });
        }

        // Conta mensagens não lidas recebidas
        if (isReceiver && !msg.read) {
          const conv = conversationsMap.get(otherUserId)!;
          conv.unread_count++;
        }
      });

      return Array.from(conversationsMap.values()).sort((a, b) => 
        new Date(b.last_message_time).getTime() - new Date(a.last_message_time).getTime()
      );
    } catch (error) {
      console.error("Erro ao buscar conversas:", error);
      throw error;
    }
  },

  /**
   * Busca mensagens entre dois usuários
   */
  async getMessagesBetweenUsers(userId1: string, userId2: string): Promise<Message[]> {
    try {
      console.log('[messageService] Buscando mensagens entre:', { userId1, userId2 });
      
      // Buscar via Supabase client (mais seguro)
      const { data, error } = await supabase
        .from("messages")
        .select("*")
        .or(`and(sender_id.eq.${userId1},receiver_id.eq.${userId2}),and(sender_id.eq.${userId2},receiver_id.eq.${userId1})`)
        .order("created_at", { ascending: true });

      if (error) {
        console.error('[messageService] Erro ao buscar mensagens:', error);
        throw error;
      }

      console.log('[messageService] Mensagens encontradas:', data?.length || 0);
      return data || [];
    } catch (error) {
      console.error("Erro ao buscar mensagens:", error);
      return [];
    }
  },

  /**
   * Envia mensagem
   */
  async sendMessage(senderId: string, receiverId: string, content: string): Promise<Message> {
    try {
      console.log('[messageService] Enviando mensagem:', { senderId, receiverId, content: content.trim() });
      
      const { data, error } = await supabase
        .from("messages")
        .insert({
          sender_id: senderId,
          receiver_id: receiverId,
          content: content.trim(),
          read: false,
        })
        .select()
        .single();

      if (error) {
        console.error('[messageService] Erro ao enviar mensagem:', error);
        throw error;
      }

      console.log('[messageService] Mensagem enviada com sucesso:', data);
      return data;
    } catch (error) {
      console.error("Erro ao enviar mensagem:", error);
      throw error;
    }
  },

  /**
   * Marca mensagens como lidas
   */
  async markMessagesAsRead(userId: string, otherUserId: string): Promise<void> {
    try {
      const { error } = await supabase
        .from("messages")
        .update({ read: true })
        .eq("receiver_id", userId)
        .eq("sender_id", otherUserId)
        .eq("read", false);

      if (error) throw error;
    } catch (error) {
      console.error("Erro ao marcar mensagens como lidas:", error);
      throw error;
    }
  },

  /**
   * Busca mensagens recebidas (compatibilidade com código antigo)
   */
  async getReceivedMessages(userId: string): Promise<Message[]> {
    try {
      const { data, error } = await supabase
        .from("messages")
        .select("*")
        .eq("receiver_id", userId)
        .order("created_at", { ascending: false });

      if (error) throw error;

      return (data || []).map((msg: any) => ({
        id: msg.id,
        sender_id: msg.sender_id,
        receiver_id: msg.receiver_id,
        content: msg.content,
        read: msg.read,
        created_at: msg.created_at,
        sender_name: msg.sender?.nome,
        sender_role: msg.sender?.role,
        sender_email: msg.sender?.email,
        subject: "Mensagem",
      }));
    } catch (error) {
      console.error("Erro ao buscar mensagens recebidas:", error);
      return [];
    }
  },

  /**
   * Busca mensagens não lidas (compatibilidade com código antigo)
   */
  async getUnreadMessages(userId: string): Promise<Message[]> {
    try {
      const { data, error } = await supabase
        .from("messages")
        .select("*")
        .eq("receiver_id", userId)
        .eq("read", false)
        .order("created_at", { ascending: false });

      if (error) throw error;

      return (data || []).map((msg: any) => ({
        id: msg.id,
        sender_id: msg.sender_id,
        receiver_id: msg.receiver_id,
        content: msg.content,
        read: msg.read,
        created_at: msg.created_at,
        sender_name: msg.sender?.nome,
        sender_role: msg.sender?.role,
        sender_email: msg.sender?.email,
        subject: "Mensagem",
      }));
    } catch (error) {
      console.error("Erro ao buscar mensagens não lidas:", error);
      return [];
    }
  },

  /**
   * Marca uma mensagem como lida
   */
  async markAsRead(messageId: string): Promise<void> {
    try {
      const { error } = await supabase
        .from("messages")
        .update({ read: true })
        .eq("id", messageId);

      if (error) throw error;
    } catch (error) {
      console.error("Erro ao marcar como lida:", error);
      throw error;
    }
  },

  /**
   * Marca uma mensagem como não lida
   */
  async markAsUnread(messageId: string): Promise<void> {
    try {
      const { error } = await supabase
        .from("messages")
        .update({ read: false })
        .eq("id", messageId);

      if (error) throw error;
    } catch (error) {
      console.error("Erro ao marcar como não lida:", error);
      throw error;
    }
  },

  /**
   * Exclui uma mensagem
   */
  async delete(messageId: string): Promise<void> {
    try {
      const { error } = await supabase
        .from("messages")
        .delete()
        .eq("id", messageId);

      if (error) throw error;
    } catch (error) {
      console.error("Erro ao excluir mensagem:", error);
      throw error;
    }
  },

  /**
   * Inscreve-se para receber novas mensagens em tempo real
   * DESABILITADO temporariamente - WebSocket causando erros
   */
  subscribeToMessages(_userId: string, _callback: (message: Message) => void) {
    console.log('[messageService] Realtime desabilitado temporariamente');
    
    // Retorna função vazia para desinscrever
    return () => {
      console.log('[messageService] Nada para desinscrever');
    };
    
    /* WebSocket desabilitado até resolver autenticação
    const channel = supabase
      .channel(`messages:${userId}`)
      .on(
        "postgres_changes",
        {
          event: "INSERT",
          schema: "public",
          table: "messages",
          filter: `receiver_id=eq.${userId}`,
        },
        async (payload) => {
          const { data } = await supabase
            .from("messages")
            .select("*")
            .eq("id", payload.new.id)
            .single();

          if (data) {
            callback({
              id: data.id,
              sender_id: data.sender_id,
              receiver_id: data.receiver_id,
              content: data.content,
              read: data.read,
              created_at: data.created_at,
            });
          }
        }
      )
      .subscribe();

    return () => {
      supabase.removeChannel(channel);
    };
    */
  },
};
