app.js

require('dotenv').config();
const Centrifuge = require('centrifuge');
const WebSocket = require('ws');
global.XMLHttpRequest = require("xmlhttprequest").XMLHttpRequest;

// Функция для форматирования даты в UTC+3
function getTimestamp() {
  const now = new Date();
  // Устанавливаем UTC+3 (Московское время)
  const utcOffset = 3; // UTC+3
  const localTime = new Date(now.getTime() + (utcOffset * 60 * 60 * 1000));
  
  const year = localTime.getUTCFullYear();
  const month = String(localTime.getUTCMonth() + 1).padStart(2, '0');
  const day = String(localTime.getUTCDate()).padStart(2, '0');
  const hours = String(localTime.getUTCHours()).padStart(2, '0');
  const minutes = String(localTime.getUTCMinutes()).padStart(2, '0');
  const seconds = String(localTime.getUTCSeconds()).padStart(2, '0');
  
  return `[${year}-${month}-${day} ${hours}:${minutes}:${seconds}]`;
}

// Переопределяем console.log
const originalLog = console.log;
const originalError = console.error;
const originalWarn = console.warn;

console.log = function(...args) {
  originalLog(getTimestamp(), ...args);
};

console.error = function(...args) {
  originalError(getTimestamp(), ...args);
};

console.warn = function(...args) {
  originalWarn(getTimestamp(), ...args);
};

async function sendWebhook(data) {
  const url = process.env.WEBHOOK_URL;
  
  if (!url) {
    console.error('URL-адрес Webhook не найден в переменных окружения');
    return false;
  }

  try {
    const lib = url.startsWith('https://') ? require('https') : require('http');
    
    // Проверяем, что данные валидны
    const jsonData = JSON.stringify(data);
    if (!jsonData) {
      console.error('Некорректные данные для отправки');
      return false;
    }

    const options = {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Content-Length': Buffer.byteLength(jsonData)
      },
      timeout: 10000 // 10 секунд таймаут
    };

    return new Promise((resolve, reject) => {
      const req = lib.request(url, options, (res) => {
        let responseData = '';
        
        res.on('data', (chunk) => {
          responseData += chunk;
        });
        
        res.on('end', () => {
          if (res.statusCode >= 200 && res.statusCode < 300) {
            console.log(`Webhook успешно отправлен (${res.statusCode})`);
            resolve(true);
          } else {
            console.error(`Ошибка webhook: ${res.statusCode} - ${responseData}`);
            reject(new Error(`HTTP ${res.statusCode}: ${responseData}`));
          }
        });
      });

      req.on('error', (error) => {
        console.error('Ошибка отправки webhook:', error.message);
        reject(error);
      });

      req.on('timeout', () => {
        req.destroy();
        console.error('Таймаут отправки webhook');
        reject(new Error('Request timeout'));
      });

      req.write(jsonData);
      req.end();
    });
  } catch (error) {
    console.error('Ошибка при отправке webhook:', error);
    return false;
  }
}

// Функция для повторных попыток
async function sendWebhookWithRetry(data, maxRetries = 3, delay = 1000) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const result = await sendWebhook(data);
      if (result) return true;
    } catch (error) {
      console.error(`Попытка ${attempt} не удалась:`, error.message);
      if (attempt < maxRetries) {
        await new Promise(resolve => setTimeout(resolve, delay * attempt));
      }
    }
  }
  console.error(`Не удалось отправить webhook после ${maxRetries} попыток`);
  return false;
}

const access_token = process.env.DONATION_ALERTS_ACCESS_TOKEN;
const socket_token = process.env.DONATION_ALERTS_SOCKET_TOKEN;
const aUrl = 'wss://centrifugo.donationalerts.com/connection/websocket';

// Проверка наличия всех необходимых переменных
if (!access_token || !socket_token || !process.env.DONATION_ALERTS_USER_ID) {
  console.error('Отсутствуют необходимые переменные окружения');
  process.exit(1);
}

let centrifuge = new Centrifuge(aUrl, {
  websocket: WebSocket,
  subscribeEndpoint: 'https://www.donationalerts.com/api/v1/centrifuge/subscribe',
  subscribeHeaders: {
    'Authorization': `Bearer ${access_token}`
  }
});

centrifuge.setToken(socket_token);
centrifuge.connect();

centrifuge.on('connect', async function(context) {
  let clientID = context.client;
  console.log('Вы подключились!', clientID);
  
  centrifuge.subscribe('$alerts:donation_' + process.env.DONATION_ALERTS_USER_ID, async (message) => {
    try {
      console.log('Получен новый донат:', message.data);
      
      // Проверяем данные
      if (!message.data || typeof message.data !== 'object') {
        console.error('Некорректные данные доната');
        return;
      }
      
      // Отправляем с повторными попытками
      const sent = await sendWebhookWithRetry(message.data);
      if (sent) {
        console.log('Донат успешно обработан');
      } else {
        console.error('Не удалось обработать донат');
      }
    } catch (error) {
      console.error('Ошибка при обработке доната:', error);
    }
  });
});

centrifuge.on('disconnect', function(context) {
  console.log('Вы отключились :(', context);
  process.exit(1); // переподключимся через перезагрузку у PM2
});

// Обработка ошибок подключения
centrifuge.on('error', function(error) {
  console.error('Ошибка центрифуги:', error);
  process.exit(1);
});