const router = require('express').Router();
const { getSupabaseClient } = require('./supabaseClient');

// Получить все сообщения в чате с информацией о пользователе
router.get('/messages', async (req, res) => {
  console.log('📬 [Server] GET /messages запрос получен');
  console.log('📬 [Server] Query параметры:', req.query);
  
  const supabase = getSupabaseClient();
  const { chat_id, limit = 50, offset = 0 } = req.query;
  
  if (!chat_id) {
    console.log('❌ [Server] Ошибка: chat_id обязателен');
    return res.status(400).json({ error: 'chat_id required' });
  }
  
  try {
    console.log('🔍 [Server] Выполняем запрос к Supabase для чата:', chat_id);
    
    // Получаем сообщения
    const { data: messages, error } = await supabase
      .from('messages')
      .select('*')
      .eq('chat_id', chat_id)
      .order('created_at', { ascending: false })
      .limit(limit)
      .range(offset, offset + limit - 1);
    
    if (error) {
      console.log('❌ [Server] Ошибка получения сообщений:', error);
      return res.status(400).json({ error: error.message });
    }
    
    // Получаем профили пользователей для всех уникальных user_id
    let data = messages || [];
    if (data.length > 0) {
      const userIds = [...new Set(data.map(msg => msg.user_id))];
      console.log('👥 [Server] Получаем профили для пользователей:', userIds);
      
      const { data: profiles, error: profilesError } = await supabase
        .from('user_profiles')
        .select('id, full_name, avatar_url')
        .in('id', userIds);
      
      if (!profilesError && profiles) {
        // Объединяем сообщения с профилями
        data = data.map(msg => ({
          ...msg,
          user_profiles: profiles.find(profile => profile.id === msg.user_id) || null
        }));
        console.log('✅ [Server] Профили пользователей добавлены к сообщениям');
      } else {
        console.log('⚠️ [Server] Ошибка получения профилей пользователей:', profilesError);
      }
         }
    
    console.log('✅ [Server] Сообщения получены:', data?.length || 0, 'шт.');
    res.json(data?.reverse() || []); // Возвращаем в хронологическом порядке
  } catch (err) {
    console.log('❌ [Server] Неожиданная ошибка:', err);
    res.status(500).json({ error: 'Internal server error' });
  }
});

// Создать новое сообщение
router.post('/messages', async (req, res) => {
  const supabase = getSupabaseClient();
  const { chat_id, user_id, text } = req.body;
  
  if (!chat_id || !user_id || !text) {
    return res.status(400).json({ 
      error: 'chat_id, user_id, and text are required' 
    });
  }
  
  // Создаем сообщение
  const { data: newMessage, error } = await supabase
    .from('messages')
    .insert({ chat_id, user_id, text })
    .select('*')
    .single();
    
  if (error) return res.status(400).json({ error: error.message });
  
  // Получаем профиль пользователя
  const { data: userProfile } = await supabase
    .from('user_profiles')
    .select('id, full_name, avatar_url')
    .eq('id', user_id)
    .single();
  
  // Объединяем сообщение с профилем
  const data = {
    ...newMessage,
    user_profiles: userProfile || null
  };
    
  res.json(data);
});

// Получить конкретное сообщение
router.get('/messages/:message_id', async (req, res) => {
  const supabase = getSupabaseClient();
  const { message_id } = req.params;
  
  // Получаем сообщение
  const { data: message, error } = await supabase
    .from('messages')
    .select('*')
    .eq('id', message_id)
    .single();
    
  if (error) return res.status(400).json({ error: error.message });
  
  // Получаем профиль пользователя
  const { data: userProfile } = await supabase
    .from('user_profiles')
    .select('id, full_name, avatar_url')
    .eq('id', message.user_id)
    .single();
  
  // Объединяем сообщение с профилем
  const data = {
    ...message,
    user_profiles: userProfile || null
  };
    
  res.json(data);
});

// Получить последние сообщения для каждого чата (для списка чатов)
router.get('/chats/last-messages', async (req, res) => {
  const supabase = getSupabaseClient();
  const { building_id } = req.query;
  
  if (!building_id) {
    return res.status(400).json({ error: 'building_id required' });
  }
  
  // Получаем чаты и их последние сообщения через обычные запросы
  const { data: chats, error: chatsError } = await supabase
    .from('chats')
    .select('*')
    .eq('building_id', building_id);
    
  if (chatsError) return res.status(400).json({ error: chatsError.message });
  
  // Для каждого чата получаем последнее сообщение
  const chatsWithMessages = await Promise.all(
    chats.map(async (chat) => {
      const { data: lastMessage } = await supabase
        .from('messages')
        .select(`
          *,
          user_profiles:user_id (
            id,
            full_name,
            avatar_url
          )
        `)
        .eq('chat_id', chat.id)
        .order('created_at', { ascending: false })
        .limit(1)
        .single();
        
      return {
        ...chat,
        last_message: lastMessage || null
      };
    })
  );
  
  res.json(chatsWithMessages);
});

// Удалить сообщение (только для автора)
router.delete('/messages/:message_id', async (req, res) => {
  const supabase = getSupabaseClient();
  const { message_id } = req.params;
  const { user_id } = req.body;
  
  if (!user_id) {
    return res.status(400).json({ error: 'user_id required' });
  }
  
  // Проверяем, что пользователь является автором сообщения
  const { data: message, error: fetchError } = await supabase
    .from('messages')
    .select('user_id')
    .eq('id', message_id)
    .single();
    
  if (fetchError) return res.status(400).json({ error: fetchError.message });
  
  if (message.user_id !== user_id) {
    return res.status(403).json({ error: 'You can only delete your own messages' });
  }
  
  const { error } = await supabase
    .from('messages')
    .delete()
    .eq('id', message_id);
    
  if (error) return res.status(400).json({ error: error.message });
  res.json({ success: true, message: 'Message deleted successfully' });
});



module.exports = router;