const router = require('express').Router();
const { getSupabaseClient } = require('./supabaseClient');
const { moderationText } = require('./chat-ai-agent/chat-moderation'); // Импортируем функцию модерации
const MODERATION_CONFIG = require('./chat-ai-agent/moderation-config'); // Импортируем конфигурацию модерации


// Добавляем middleware для логирования всех запросов к messages роутеру

// Тестовый эндпоинт для проверки работы роутера
router.get('/messages/test', (req, res) => {
  res.json({ 
    status: 'OK', 
    message: 'Messages router работает', 
    timestamp: new Date().toISOString(),
    moderation_config: MODERATION_CONFIG
  });
});

// Получить все сообщения в чате с информацией о пользователе
router.get('/messages', async (req, res) => {
  try {
    const { chat_id, limit = 50, offset = 0 } = req.query;

    if (!chat_id) {
      return res.status(400).json({ error: 'chat_id is required' });
    }

    const supabase = getSupabaseClient();
    
    const { data, error } = await supabase
      .from('messages')
      .select(`
        *,
        user_profiles (
          id,
          full_name,
          avatar_url
        )
      `)
      .eq('chat_id', chat_id)
      .order('created_at', { ascending: true })
      .range(offset, offset + limit - 1);

    if (error) {
      return res.status(500).json({ error: 'Failed to fetch messages' });
    }

    // Получаем уникальные ID пользователей из сообщений, у которых нет профиля
    const messagesWithoutProfiles = data.filter(msg => !msg.user_profiles);
    const userIds = [...new Set(messagesWithoutProfiles.map(msg => msg.user_id))];
    
    if (userIds.length > 0) {
      const { data: profiles, error: profilesError } = await supabase
        .from('user_profiles')
        .select('id, full_name, avatar_url')
        .in('id', userIds);

      if (!profilesError && profiles) {
        // Добавляем профили к сообщениям
        data.forEach(message => {
          if (!message.user_profiles) {
            message.user_profiles = profiles.find(profile => profile.id === message.user_id) || null;
          }
        });
      }
    }

    res.json(data);
  } catch (err) {
    res.status(500).json({ error: 'Unexpected error occurred' });
  }
});

// Создать новое сообщение
router.post('/messages', async (req, res) => {
  
  let supabase;
  try {
    supabase = getSupabaseClient();
  } catch (error) {
    console.error(`❌ [Message Send] Ошибка получения Supabase клиента:`, error);
    return res.status(500).json({ error: 'Database connection error' });
  }
  
  const { chat_id, user_id, text } = req.body;
  
  
  if (!chat_id || !user_id || !text) {
    console.log(`❌ [Message Send] Отклонен: отсутствуют обязательные поля`);
    console.log(`❌ [Message Send] chat_id: ${chat_id}, user_id: ${user_id}, text: ${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) {
    console.error(`❌ [Message Send] Ошибка сохранения в Supabase:`, error);
    return res.status(400).json({ error: error.message });
  }
  
  // Получаем профиль пользователя
  const { data: userProfile, error: profileError } = await supabase
    .from('user_profiles')
    .select('id, full_name, avatar_url')
    .eq('id', user_id)
    .single();
    
  if (profileError) {
    console.log(`⚠️ [Message Send] Профиль пользователя не найден:`, profileError);
  }
  
  // Объединяем сообщение с профилем
  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;