const axios = require('axios');
const config = require('../config');
const { log, logError } = require('../middleware/logger');
const User = require('../models/User');
const { normalizeUsername } = require('../services/moderationAdmin');

const OWNER_USERNAMES = new Set(config.moderationOwnerUsernames || []);

const BOT_TOKEN = config.telegramBotToken;
const TELEGRAM_API = BOT_TOKEN ? `https://api.telegram.org/bot${BOT_TOKEN}` : null;

let isPolling = false;
let offset = 0;

const sendMessage = async (chatId, text, options = {}) => {
  if (!TELEGRAM_API) {
    log('warn', 'TELEGRAM_BOT_TOKEN не установлен, отправка сообщения невозможна');
    return null;
  }

  try {
    const response = await axios.post(`${TELEGRAM_API}/sendMessage`, {
      chat_id: chatId,
      text,
      parse_mode: 'HTML',
      ...options
    });
    return response.data;
  } catch (error) {
    logError('Ошибка отправки сообщения', error, { chatId, text: text.substring(0, 50) });
    return null;
  }
};

const sendMessageToAllUsers = async (messageText) => {
  if (!TELEGRAM_API) {
    throw new Error('TELEGRAM_BOT_TOKEN не установлен');
  }

  try {
    const users = await User.find({ banned: { $ne: true } }).select('telegramId');
    let sent = 0;
    let failed = 0;

    for (const user of users) {
      try {
        await sendMessage(user.telegramId, messageText);
        sent++;
        // Небольшая задержка, чтобы не превысить лимиты API
        await new Promise(resolve => setTimeout(resolve, 50));
      } catch (error) {
        failed++;
        logError('Ошибка отправки сообщения пользователю', error, { telegramId: user.telegramId });
      }
    }

    return { sent, failed, total: users.length };
  } catch (error) {
    logError('Ошибка массовой отправки сообщений', error);
    throw error;
  }
};

const requireAdmin = async (message) => {
  try {
    const telegramId = message.from?.id;
    if (!telegramId) return false;
    
    const user = await User.findOne({ telegramId }).select('role');
    const username = normalizeUsername(message.from?.username || '');
    
    return user && (user.role === 'admin' || OWNER_USERNAMES.has(username));
  } catch (error) {
    logError('Ошибка проверки прав админа', error);
    return false;
  }
};

const getStartMessage = () => {
  return `<b>Добро пожаловать в Nakama!</b>

📱 <b>Nakama</b> - социальная сеть для фурри и аниме сообщества.

<b>Основные возможности:</b>
• Создание постов с текстом и изображениями
• Поиск контента через e621 и Gelbooru
• Комментарии и лайки
• Подписки на пользователей
• Система уведомлений
• Фильтры и теги

<b>Как начать:</b>
1. Нажмите кнопку "Войти" ниже, чтобы запустить приложение
2. Создайте свой первый пост
3. Подписывайтесь на интересных пользователей

<b>Поддержка:</b>
Если возникли проблемы, напишите @NakamaReportbot

Приятного использования!`;
};

const handleCommand = async (message) => {
  const chatId = message.chat.id;
  const text = (message.text || '').trim();
  const args = text.split(/\s+/);
  const command = args[0].toLowerCase();

  if (command === '/start') {
    const startParam = message.text.split(' ')[1] || '';
    
    // Если есть start_param (например, post_12345 или ref_ABC123)
    // Это обрабатывается при открытии миниаппа, здесь просто показываем инструкцию
    const startMessage = getStartMessage();
    
    // Добавить кнопку для открытия миниаппа
    let botUsername = 'NakamaSpaceBot';
    if (config.telegramBotToken) {
      try {
        const botInfo = await axios.get(`${TELEGRAM_API}/getMe`);
        botUsername = botInfo.data.result.username || 'NakamaSpaceBot';
      } catch (error) {
        log('warn', 'Не удалось получить имя бота', { error: error.message });
      }
    }
    
    // Использовать web_app с правильным URL миниаппа
    const miniappUrl = 'https://nakama.glpshchn.ru/';
    await sendMessage(chatId, startMessage, {
      reply_markup: {
        inline_keyboard: [[
          {
            text: '🚀 Открыть Nakama',
            web_app: {
              url: miniappUrl
            }
          }
        ]]
      }
    });
    return;
  }

  if (command === '/broadcast') {
    // Проверка прав
    const isAdmin = await requireAdmin(message);
    if (!isAdmin) {
      await sendMessage(chatId, '❌ Команда доступна только администраторам.');
      return;
    }

    // Получить текст сообщения (все после /broadcast)
    const messageText = args.slice(1).join(' ').trim();
    
    if (!messageText) {
      await sendMessage(chatId, 'Использование: /broadcast <сообщение>\n\nПример: /broadcast Всем привет!');
      return;
    }

    // Отправить подтверждение
    await sendMessage(chatId, '📤 Начинаю рассылку сообщения всем пользователям...');
    
    try {
      const result = await sendMessageToAllUsers(messageText);
      await sendMessage(chatId, 
        `✅ Рассылка завершена!\n\n` +
        `📊 Статистика:\n` +
        `• Отправлено: ${result.sent}\n` +
        `• Ошибок: ${result.failed}\n` +
        `• Всего пользователей: ${result.total}`
      );
    } catch (error) {
      logError('Ошибка рассылки через команду', error);
      await sendMessage(chatId, `❌ Ошибка рассылки: ${error.message}`);
    }
    return;
  }

  // Игнорируем неизвестные команды
};

const handleInlineQuery = async (inlineQuery) => {
  if (!TELEGRAM_API) return;

  try {
    const query = inlineQuery.query || '';
    const queryId = inlineQuery.id;
    
    // Формат: "furry tag1 tag2" или "anime tag1 tag2"
    const parts = query.trim().split(/\s+/).filter(p => p.length > 0);
    
    if (parts.length === 0) {
      // Если нет запроса, вернуть пустой результат
      await axios.post(`${TELEGRAM_API}/answerInlineQuery`, {
        inline_query_id: queryId,
        results: []
      });
      return;
    }
    
    // Первое слово - источник (furry или anime)
    const source = parts[0].toLowerCase();
    const tags = parts.slice(1);
    
    if (source !== 'furry' && source !== 'anime') {
      // Если первый параметр не furry или anime, вернуть пустой результат
      await axios.post(`${TELEGRAM_API}/answerInlineQuery`, {
        inline_query_id: queryId,
        results: []
      });
      return;
    }
    
    if (tags.length === 0) {
      // Если нет тегов, вернуть пустой результат
      await axios.post(`${TELEGRAM_API}/answerInlineQuery`, {
        inline_query_id: queryId,
        results: []
      });
      return;
    }
    
    // Объединить теги в строку для поиска
    const tagsQuery = tags.join(' ');
    
    let searchResults = [];
    
    if (source === 'furry') {
      // Поиск через e621 API
      try {
        const config = require('../config');
        
        // Проверить наличие API ключа
        if (!config.e621ApiKey) {
          log('warn', 'e621 API ключ не настроен для inline query');
          await axios.post(`${TELEGRAM_API}/answerInlineQuery`, {
            inline_query_id: queryId,
            results: [],
            cache_time: 60
          });
          return;
        }
        
        const E621_USER_AGENT = 'NakamaApp/1.0 (by glpshchn on e621)';
        
        // e621 использует Basic Auth с username:api_key (как в документации)
        const username = config.e621Username || 'glpshchn';
        const auth = Buffer.from(`${username}:${config.e621ApiKey}`).toString('base64');
        
        const response = await axios.get('https://e621.net/posts.json', {
          params: {
            tags: tagsQuery,
            limit: 50
          },
          headers: {
            'User-Agent': E621_USER_AGENT,
            'Authorization': `Basic ${auth}`
          },
          timeout: 10000,
          validateStatus: (status) => status < 500 // Не бросать ошибку для 401/429
        });
        
        // Обработка ошибок авторизации
        if (response.status === 401) {
          log('warn', 'e621 API вернул 401 - неверные учетные данные для inline query');
          await axios.post(`${TELEGRAM_API}/answerInlineQuery`, {
            inline_query_id: queryId,
            results: [],
            cache_time: 60
          });
          return;
        }
        
        // Обработка rate limit
        if (response.status === 429) {
          log('warn', 'e621 rate limit (429) для inline query');
          await axios.post(`${TELEGRAM_API}/answerInlineQuery`, {
            inline_query_id: queryId,
            results: [],
            cache_time: 60
          });
          return;
        }
        
        let postsData = [];
        if (Array.isArray(response.data)) {
          postsData = response.data;
        } else if (response.data && Array.isArray(response.data.posts)) {
          postsData = response.data.posts;
        } else if (response.data && Array.isArray(response.data.data)) {
          postsData = response.data.data;
        }
        
        searchResults = postsData
          .filter(post => post && post.file && post.file.url)
          .slice(0, 50)
          .map(post => ({
            id: post.id,
            url: post.file.url,
            preview: post.preview && post.preview.url ? post.preview.url : post.file.url,
            tags: post.tags && post.tags.general ? post.tags.general : [],
            source: 'e621'
          }));
      } catch (error) {
        // Логировать только если это не 401/429 (они уже обработаны выше)
        if (error.response?.status !== 401 && error.response?.status !== 429) {
          logError('Ошибка поиска e621 для inline query', error);
        }
        // Вернуть пустой результат вместо падения
        searchResults = [];
      }
    } else if (source === 'anime') {
      // Поиск через Gelbooru API
      try {
        const config = require('../config');
        const response = await axios.get('https://gelbooru.com/index.php', {
          params: {
            page: 'dapi',
            s: 'post',
            q: 'index',
            json: 1,
            tags: tagsQuery,
            limit: 50,
            api_key: config.gelbooruApiKey,
            user_id: config.gelbooruUserId
          },
          headers: {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
          },
          timeout: 10000
        });
        
        let postsData = [];
        if (Array.isArray(response.data)) {
          postsData = response.data;
        } else if (response.data && response.data.post) {
          postsData = Array.isArray(response.data.post) ? response.data.post : [response.data.post];
        }
        
        searchResults = postsData
          .filter(post => post && post.file_url)
          .slice(0, 50)
          .map(post => ({
            id: post.id,
            url: post.file_url,
            preview: post.preview_url || post.thumbnail_url || post.file_url,
            tags: post.tags ? (typeof post.tags === 'string' ? post.tags.split(' ') : post.tags) : [],
            source: 'gelbooru'
          }));
      } catch (error) {
        logError('Ошибка поиска Gelbooru для inline query', error);
      }
    }
    
    // Получить username бота
    let botUsername = 'NakamaSpaceBot';
    try {
      const botInfo = await axios.get(`${TELEGRAM_API}/getMe`);
      botUsername = botInfo.data.result.username || 'NakamaSpaceBot';
    } catch (error) {
      log('warn', 'Не удалось получить имя бота для inline query', { error: error.message });
    }
    
    // Преобразовать результаты в InlineQueryResult
    const results = searchResults.map((post, index) => {
      const tagsStr = Array.isArray(post.tags) ? post.tags.slice(0, 10).join(' ') : '';
      let caption = '';
      
      if (tagsStr) {
        caption = `Tags: ${tagsStr}\n\nvia @${botUsername}`;
      } else {
        caption = `via @${botUsername}`;
      }
      
      return {
        type: 'photo',
        id: `${post.source}_${post.id}_${index}`,
        photo_url: post.url,
        thumb_url: post.preview || post.url,
        caption: caption.substring(0, 1024),
        parse_mode: 'HTML'
      };
    });
    
    await axios.post(`${TELEGRAM_API}/answerInlineQuery`, {
      inline_query_id: queryId,
      results: results,
      cache_time: 300 // 5 минут
    });
  } catch (error) {
    logError('Ошибка обработки inline query', error);
    // Отправить пустой результат при ошибке
    try {
      await axios.post(`${TELEGRAM_API}/answerInlineQuery`, {
        inline_query_id: inlineQuery.id,
        results: []
      });
    } catch (e) {
      // Игнорировать ошибку отправки пустого результата
    }
  }
};

const processUpdate = async (update) => {
  // Обработка inline query
  if (update.inline_query) {
    await handleInlineQuery(update.inline_query);
    return;
  }
  
  const message = update.message || update.edited_message;
  if (!message || !message.text) {
    return;
  }

  try {
    await handleCommand(message);
  } catch (error) {
    logError('Ошибка обработки команды основного бота', error, { 
      chatId: message.chat.id,
      text: message.text?.substring(0, 50)
    });
  }
};

const pollUpdates = async () => {
  if (!TELEGRAM_API) {
    log('warn', 'Основной бот не запущен: TELEGRAM_BOT_TOKEN не установлен');
    return;
  }

  if (isPolling) {
    return;
  }

  isPolling = true;
  log('info', 'Основной бот запущен, опрос обновлений...');

  // При первом запуске получить все обновления и установить offset на последний,
  // чтобы не отвечать на старые команды
  const initializeOffset = async () => {
    try {
      const response = await axios.get(`${TELEGRAM_API}/getUpdates`, {
        params: {
          timeout: 1,
          allowed_updates: ['message', 'inline_query']
        }
      });

      const updates = response.data.result || [];
      if (updates.length > 0) {
        // Установить offset на последний update_id + 1, чтобы пропустить все старые обновления
        offset = updates[updates.length - 1].update_id + 1;
        log('info', `Пропущено ${updates.length} старых обновлений, offset установлен на ${offset}`);
      }
    } catch (error) {
      log('warn', 'Не удалось инициализировать offset, начнем с 0', { error: error.message });
    }
  };

  const poll = async () => {
    try {
      const response = await axios.get(`${TELEGRAM_API}/getUpdates`, {
        params: {
          offset,
          timeout: 30,
          allowed_updates: ['message', 'inline_query']
        }
      });

      const updates = response.data.result || [];
      
      for (const update of updates) {
        offset = update.update_id + 1;
        await processUpdate(update);
      }

      // Продолжить опрос
      setTimeout(poll, 1000);
    } catch (error) {
      const errorData = error.response?.data || {};
      const errorCode = errorData.error_code;
      const errorDescription = errorData.description || error.message;

      // Обработка конфликта 409 - другой экземпляр бота уже опрашивает
      if (errorCode === 409) {
        // Не логируем 409 - это ожидаемая ситуация при конфликте экземпляров
        // Подождать дольше перед повторной попыткой
        setTimeout(poll, 10000);
      } else {
        logError('Ошибка опроса Telegram для основного бота', error);
        // Переподключиться через 5 секунд
        setTimeout(poll, 5000);
      }
    }
  };

  // Сначала инициализировать offset, затем начать опрос
  initializeOffset().then(() => {
    poll();
  });
};

const startMainBot = () => {
  if (!BOT_TOKEN) {
    log('warn', 'Основной бот не запущен: TELEGRAM_BOT_TOKEN не установлен');
    return;
  }

  pollUpdates();
};

module.exports = {
  startMainBot,
  sendMessageToAllUsers,
  sendMessage
};