import { Telegraf, session } from 'telegraf';
import { message } from 'telegraf/filters';
import { code } from 'telegraf/format';
import config from 'config';
import { ogg } from './src/ogg.js';
import { openaiGPT } from './src/openai.js';
import { Client } from '@gradio/client';

const INITIAL_SESSION = {
  messages: [],
};

const BOT_TOKEN = config.get('TELEGRAM_TOKEN');
const bot = new Telegraf(BOT_TOKEN);

async function initGradioClient() {
  try {
    const gradioClient = await Client.connect('yuntian-deng/ChatGPT4');
    const app_info = await gradioClient.view_api();
    console.log('Доступные эндпоинты API:', app_info);
    return gradioClient;
  } catch (error) {
    console.error('Ошибка подключения клиента Gradio:', error);
    throw error;
  }
}

async function getPrediction(app, inputText, apiEndpoint) {
  try {
    console.log(`Проверка эндпоинта: ${apiEndpoint} с запросом:`, inputText);

    const predictionResult = await app.predict(apiEndpoint, [inputText]);

    if (predictionResult && predictionResult.data) {
      const responseMessage = predictionResult.data[0];
      console.log(`Ответ от ${apiEndpoint}:`, responseMessage);
      return responseMessage;
    }

    console.warn('Получены неожиданные данные формата.');
    return 'Получены неожиданные данные.';
  } catch (error) {
    console.error(`Ошибка при запросе ${apiEndpoint}:`, error);
    return 'Извините, произошла ошибка при обработке вашего запроса.';
  }
}

initGradioClient()
  .then(async (client) => {
    gradioClient = client;
    console.log('Gradio клиент инициализирован');
    // Пробуем получить ответ, чтобы диагностировать проблемы
    const responsePredict = await getPrediction(client, 'ты тут ?', '/predict');
    console.log('Ответ от /predict:', responsePredict);
  })
  .catch((error) => {
    console.error('Не удалось инициализировать Gradio клиент:', error);
  });

bot.use(session());

bot.command('new', async (ctx) => {
  ctx.session = INITIAL_SESSION;
  await ctx.reply('Жду вашего голосового или текстового сообщения');
});

bot.command('start', async (ctx) => {
  ctx.session = INITIAL_SESSION;
  await ctx.reply('Жду вашего голосового или текстового сообщения');
});

bot.on(message('voice'), async (ctx) => {
  ctx.session ??= INITIAL_SESSION;
  try {
    const link = await ctx.telegram.getFileLink(ctx.message.voice.file_id);
    const userId = String(ctx.message.from.id);
    const oggPath = await ogg.create(link.href, userId);
    const mp3Path = await ogg.toMp3(oggPath, userId);
    const name = ctx.from.first_name;
    const text = await openaiGPT.transcription(mp3Path);

    if (text.includes('Кеша') && gradioClient) {
      const textAsked = text.slice(5);
      await ctx.reply(code(`${name} Ваш запрос: ${textAsked}`));

      const responseMessage = await getPrediction(gradioClient, textAsked, '/predict');
      await ctx.reply(responseMessage);
    }
  } catch (error) {
    console.log('Ошибка при обработке голосового сообщения:', error.message);
  }
});

bot.on(message('text'), async (ctx) => {
  ctx.session ??= INITIAL_SESSION;
  const text = ctx.message.text;

  if (text.includes('Кеша') && gradioClient) {
    const textAsked = text.slice(5);
    try {
      await ctx.reply(code('Сообщение принял. Жду ответ от сервера...'));

      const responseMessage = await getPrediction(gradioClient, textAsked, '/predict');
      const name = ctx.from.first_name;
      await ctx.reply(`${name}, ${responseMessage}`);
    } catch (err) {
      console.log('Ошибка при обработке текстового сообщения:', err.message);
      const name = ctx.from.first_name;
      ctx.reply(
        `${name}, "Извините. Но из-за высокой нагрузки на сервер, я не смогу ответить Вам".`,
      );
    }
  }
});

bot.on('error', (error) => {
  console.log('Ошибка бота:', error);
});

bot.launch();

process.once('SIGINT', () => bot.stop('SIGINT'));
process.once('SIGTERM', () => bot.stop('SIGTERM')); $ node index.js
Доступные эндпоинты API: {
  named_endpoints: {
    '/enable_inputs': { parameters: [], returns: [], type: [Object] },
    '/reset_textbox': { parameters: [], returns: [Array], type: [Object] },
    '/predict': { parameters: [Array], returns: [Array], type: [Object] },
    '/reset_textbox_1': { parameters: [], returns: [Array], type: [Object] },
    '/predict_1': { parameters: [Array], returns: [Array], type: [Object] }
  },
  unnamed_endpoints: { '0': { parameters: [Array], returns: [Array], type: [Obje
ct] } }
}
Не удалось инициализировать Gradio клиент: ReferenceError: gradioClient is not d
efined
    at file:///E:/program/bot-tg/index.js:50:18
    at process.processTicksAndRejections (node:internal/process/task_queues:95:5
)
Unhandled error while processing {
  update_id: 924867498,
  message: {
    message_id: 1888,
    from: {
      id: 178999805,
      is_bot: false,
      first_name: 'Евгений',
      username: 'Skeptic',
      language_code: 'ru',
      is_premium: true
    },
    chat: {
      id: 178999805,
      first_name: 'Евгений',
      username: 'Skeptic',
      type: 'private'
    },
    date: 1729267873,
    text: 'Кеша ты nen &'
  }
}
file:///E:/program/bot-tg/index.js:98
  if (text.includes('Кеша') && gradioClient) {
                               ^

ReferenceError: gradioClient is not defined
    at file:///E:/program/bot-tg/index.js:98:32
    at E:\program\bot-tg\node_modules\telegraf\lib\composer.js:167:111
    at process.processTicksAndRejections (node:internal/process/task_queues:95:5
)
    at async execute (E:\program\bot-tg\node_modules\telegraf\lib\composer.js:48
5:17)
    at async E:\program\bot-tg\node_modules\telegraf\lib\composer.js:486:21
    at async execute (E:\program\bot-tg\node_modules\telegraf\lib\composer.js:48
5:17)
    at async E:\program\bot-tg\node_modules\telegraf\lib\composer.js:486:21
    at async execute (E:\program\bot-tg\node_modules\telegraf\lib\composer.js:48
5:17)
    at async E:\program\bot-tg\node_modules\telegraf\lib\composer.js:486:21
    at async execute (E:\program\bot-tg\node_modules\telegraf\lib\composer.js:48
5:17)

Node.js v20.16.0