Это скрипт для моей таблицы на Google Таблицах:

function updateAllStats() {
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getActiveSheet();
    const headerRow = sheet.getRange(1, 1, 1, sheet.getLastColumn()).getValues()[0];
  
  // Получаем индексы столбцов по названиям
  const columnIndices = {
    name: headerRow.indexOf('name') + 1,
    gameVer: headerRow.indexOf('gameVer') + 1,
    modrinthId: headerRow.indexOf('modrinthId') + 1,
    curseforgeId: headerRow.indexOf('curseforgeId') + 1,
    follows: headerRow.indexOf('follows') + 1,
    mrDownloads: headerRow.indexOf('mrDownloads') + 1,
    cfDownloads: headerRow.indexOf('cfDownloads') + 1,
    popularity: headerRow.indexOf('popularity') + 1
  };

  const lastRow = sheet.getLastRow();
  
  for (let row = 2; row <= lastRow; row++) {
    const modrinthId = sheet.getRange(row, columnIndices.modrinthId).getValue();
    const curseforgeId = sheet.getRange(row, columnIndices.curseforgeId).getValue();

        // Проверяем, является ли значение ID FALSE или false, и пропускаем такие строки
    if ((modrinthId === false || modrinthId === "FALSE") && (curseforgeId === false || curseforgeId === "FALSE")) {
      continue; // Пропускаем итерацию, если оба идентификатора равны FALSE
    }

    let follows = 0, mrDownloads = 0, cfDownloads = 0;

    if (modrinthId && modrinthId !== false && modrinthId !== "FALSE") {
      const modrinthData = fetchModrinthStats(modrinthId);
      follows = modrinthData.followersCount;
      mrDownloads = modrinthData.downloadsCount;
      sheet.getRange(row, columnIndices.mrDownloads).setValue(mrDownloads);
      sheet.getRange(row, columnIndices.follows).setValue(follows); 
    }
    
    if (curseforgeId && curseforgeId !== false && curseforgeId !== "FALSE") {
      cfDownloads = fetchCurseForgeDownloads(curseforgeId);
      sheet.getRange(row, columnIndices.cfDownloads).setValue(cfDownloads);
    }

    // Вычисляем популярность, деля на количество столбцов с не нулевыми значениями
    const values = [follows, mrDownloads, cfDownloads];
    const nonZeroValues = values.filter(value => value > 0);
    let popularity = 0;

    if (nonZeroValues.length > 0) {
      popularity = nonZeroValues.reduce((acc, val) => acc + val, 0) / nonZeroValues.length;
    }
    
    sheet.getRange(row, columnIndices.popularity).setValue(popularity);
  }

  sortByColumns(sheet, columnIndices.gameVer, columnIndices.popularity, columnIndices.name);
}

function fetchModrinthStats(projectId) {
  const url = `https://api.modrinth.com/v2/project/${projectId}`;
  try {
    const response = UrlFetchApp.fetch(url);
    const data = JSON.parse(response.getContentText());
    return {
      downloadsCount: data.downloads || 0,
      followersCount: data.followers || 0
    };
  } catch (error) {
    Logger.log(`Error fetching data for Modrinth project ID ${projectId}: ${error}`);
    return {
      downloadsCount: 0,
      followersCount: 0
    };
  }
}

function fetchCurseForgeDownloads(projectId) {
  const apiKey = '$2a$10$Urj8j4d0C3ctaItu3WOUNex3LZJ2WBRj0q5mYojEpuGmjYZCUNas. '; // API Key
  const url = `https://api.curseforge.com/v1/mods/${projectId}`;
  const headers = {
    'accept': 'application/json',
    'x-api-key': apiKey
  };

  try {
    const response = UrlFetchApp.fetch(url, { headers: headers });
    const data = JSON.parse(response.getContentText());
    return data.data.downloadCount || 0;
  } catch (error) {
    Logger.log(`Error fetching data for CurseForge project ID ${projectId}: ${error}`);
    return 0;
  }
}

function sortByColumns(sheet, gameVer, popularity, name) {
  const range = sheet.getRange(2, 1, sheet.getLastRow() - 1, sheet.getLastColumn());
  range.sort([
    { column: gameVer, ascending: false },     // По версии игры
    { column: popularity, ascending: false }, // По популярности
    { column: name, ascending: true }        // По имени мода
  ]);
}

Добавь в скрипт возможность определять наличие в моде определённых языков. В моём случае это ru_ru, tt_ru, be_by, uk_ua.
Скрипт должен обращать внимание на версию в столбце gameVer и выбрать последнюю вышедшую версию мода под неё. В приоритете загрузчик модов Fabric, но если его нет, выбирается последняя версия для любого загрузчика модов. Мод скачивается и скрипт перемещается по пути \assets[id]\lang\ внутри архива мода, где хранятся языковые файлы. Они там в формате «ru_ru.json», «ru_ru.lang» или «ru_RU.lang». Скрипт сверяет языковые файлы с тем набором языков, что я упомянул ранее, и записывает в столбец translatedTo те определённые языки, что обнаружил. Если не обнаружено ни одного языка, в столбец вставляется FALSE.

Можешь реализовать серверную часть действий через моего дискорд-бота на Kotlin. Вот его основной класс:

@file:Suppress("UNUSED_VARIABLE")

package ru.deflecta.auroomy

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.serialization.json.Json
import net.dv8tion.jda.api.JDABuilder
import net.dv8tion.jda.api.entities.channel.concrete.NewsChannel
import net.dv8tion.jda.api.entities.MessageEmbed
import net.dv8tion.jda.api.events.session.ReadyEvent
import net.dv8tion.jda.api.hooks.ListenerAdapter
import net.dv8tion.jda.api.utils.FileUpload
import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.engine.cio.*
import io.ktor.client.plugins.BodyProgress.Plugin.install
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.request.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.serialization.encodeToString
import net.dv8tion.jda.api.entities.channel.concrete.TextChannel
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
import net.dv8tion.jda.api.interactions.commands.build.Commands
import net.dv8tion.jda.api.requests.GatewayIntent
import java.io.*
import java.util.zip.ZipInputStream
import kotlin.system.exitProcess
import java.util.Timer
import java.util.TimerTask
import io.ktor.http.*
import io.ktor.server.engine.embeddedServer
import io.ktor.server.netty.Netty
import io.ktor.serialization.*
import java.io.File
import io.ktor.http.*
import io.ktor.server.engine.embeddedServer
import io.ktor.serialization.*
import io.ktor.server.application.*
import io.ktor.server.response.*
import io.ktor.server.routing.*

fun main() {
    val configContent = File("config.json").readText()
    val config = Json { ignoreUnknownKeys = true }.decodeFromString<Config>(configContent)

    val jda = JDABuilder.createDefault(config.discordToken, GatewayIntent.GUILD_MESSAGES, GatewayIntent.MESSAGE_CONTENT)
        .addEventListeners(BotListener(config))
        .build()
}

class BotListener(private val config: Config) : ListenerAdapter() {
    private val googlePlayTimer = Timer()
    private val modsTimer = Timer()

    private val publisher = GooglePlayPublisher()
    private val langFiles = mutableMapOf<String, ModLanguageData>()
    private val mutex = Mutex()

    private val messageCache = MessageCache()

    private lateinit var googlePlayChannel: NewsChannel
    private lateinit var modsChannel: NewsChannel

    private lateinit var russianFeedChannel: TextChannel
    private lateinit var englishFeedChannel: TextChannel

    private val e621Timer = Timer()

    // Создаем сет для хранения ID отправленных постов
    private val sentE621Posts = mutableSetOf<Long>()
    private val e621PostsFile = "e621posts.json"

    override fun onReady(event: ReadyEvent) {
        println("Бот запущен!")

        // Получаем каналы
        googlePlayChannel = event.jda.getNewsChannelById(config.googlePlayChannelId)
            ?: run {
                println("Канал Google Play с ID ${config.googlePlayChannelId} не найден!")
                exitProcess(1)
            }

        modsChannel = event.jda.getNewsChannelById(config.modsChannelId)
            ?: run {
                println("Канал модов с ID ${config.modsChannelId} не найден!")
                exitProcess(1)
            }

        // Инициализация: загрузка текущих языковых файлов модов
        CoroutineScope(Dispatchers.IO).launch {
            for (mod in config.mods) {
                try {
                    val newLanguageData = getLanguageFiles(mod, client, config.curseForgeApiKey)
                    if (newLanguageData != null) {
                        var shouldNotify = false
                        var previousData: ModLanguageData? = null
                        var ruChanged = false
                        var enChanged = false

                        mutex.withLock {
                            previousData = langFiles[mod.name]
                            if (previousData == null) {
                                langFiles[mod.name] = newLanguageData
                                shouldNotify = true
                                ruChanged = newLanguageData.ruRu != null
                                enChanged = newLanguageData.enUs != null
                            } else {
                                ruChanged = !newLanguageData.ruRu.contentEquals(previousData!!.ruRu)
                                enChanged = !newLanguageData.enUs.contentEquals(previousData!!.enUs)
                                if (ruChanged || enChanged) {
                                    langFiles[mod.name] = newLanguageData
                                    shouldNotify = true
                                }
                            }
                        }

                        if (shouldNotify) {
                            val cacheKey = "mod_${mod.name}_${newLanguageData.modVersion}"
                            val dataForCache =
                                (newLanguageData.ruRu ?: ByteArray(0)) + (newLanguageData.enUs ?: ByteArray(0))
                            if (!messageCache.isAlreadySent(cacheKey, dataForCache)) {
                                withContext(Dispatchers.IO) {
                                    sendLanguageUpdateEmbed(
                                        modsChannel,
                                        mod.name,
                                        newLanguageData,
                                        ruChanged,
                                        enChanged,
                                        cacheKey,
                                        dataForCache
                                    )
                                }
                            }
                        }
                    }
                } catch (e: Exception) {
                    println("Ошибка при проверке мода ${mod.name}: ${e.message}")
                }
            }
        }

        // Остальные таймеры инициализации, если они не зависят от e621, можно оставить вне корутины
        // Периодическая задача проверки обновлений Google Play
        googlePlayTimer.scheduleAtFixedRate(
            object : TimerTask() {
                override fun run() {
                    checkGooglePlayUpdates()
                }
            }, 0, 5 * 60 * 1000 // Каждые 5 минут
        )

        // Периодическая задача проверки обновлений модов
        modsTimer.scheduleAtFixedRate(
            object : TimerTask() {
                override fun run() {
                    checkModsUpdates()
                }
            }, 0, 10 * 60 * 1000 // Каждые 10 минут
        )

        // Инициализируем каналы
        russianFeedChannel = event.jda.getTextChannelById(config.russianFeedChannelId)
            ?: throw IllegalStateException("Канал с ID ${config.russianFeedChannelId} не найден")

        englishFeedChannel = event.jda.getTextChannelById(config.englishFeedChannelId)
            ?: throw IllegalStateException("Канал с ID ${config.englishFeedChannelId} не найден")

        // Запускаем корутину
        CoroutineScope(Dispatchers.IO).launch {
            // Загружаем отправленные посты
            loadSentE621Posts()

            // Запускаем таймер для проверки новых артов после завершения загрузки
            e621Timer.scheduleAtFixedRate(
                object : TimerTask() {
                    override fun run() {
                        checkE621Updates()
                    }
                },
                0,
                10 * 60 * 1000 // Каждые 10 минут
            )
        }

        // Регистрация слэш-команды `/tontaro` на уровне гильдии
        event.jda.getGuildById("878019629925158932")?.let { guild ->
            guild.updateCommands().addCommands(
                Commands.slash("tontaro", "Найти случайный рисунок от Tontaro")
                // Здесь можно добавить опции, если необходимо
            ).queue()
        }

        event.jda.updateCommands().queue()

        val guildId = "878019629925158932" // Замените на ID вашей гильдии
        event.jda.getGuildById(guildId)?.let { guild ->
            guild.updateCommands().addCommands(
                Commands.slash("tontaro", "Search random Tontaro art"),
                Commands.slash("тонтаро", "Найти случайный арт Тонтаро")
            ).queue(
                { println("Команды успешно зарегистрированы в гильдии ${guild.name}") },
                { error -> println("Ошибка при регистрации команд: ${error.message}") }
            )
        } ?: println("Гильдия с ID $guildId не найдена")
    }

    private suspend fun loadSentE621Posts() {
        val file = File(e621PostsFile)
        if (file.exists()) {
            val jsonString = file.readText()
            val loadedPosts = Json.decodeFromString<Set<Long>>(jsonString)
            sentE621Posts.addAll(loadedPosts)
            println("Загружено ${sentE621Posts.size} отправленных постов из файла.")
        } else {
            println("Файл с сохраненными постами не найден. Инициализируем список отправленных постов.")
            try {
                val recentPosts = fetchRecentE621Posts()
                for (post in recentPosts) {
                    sentE621Posts.add(post.id)
                }
                // Сохраняем инициализированные посты в файл
                saveSentE621Posts()
                println("Инициализировано ${sentE621Posts.size} постов из e621.")
            } catch (e: Exception) {
                println("Ошибка при инициализации e621 постов: ${e.message}")
            }
        }
    }

    private fun saveSentE621Posts() {
        try {
            val jsonString = Json.encodeToString(sentE621Posts)
            File(e621PostsFile).writeText(jsonString)
            println("Сохранено ${sentE621Posts.size} отправленных постов в файл.")
        } catch (e: Exception) {
            println("Ошибка при сохранении постов e621: ${e.message}")
        }
    }

    private suspend fun fetchRecentE621Posts(): List<E621Post> {
        return retryIO {
            val response: E621Response = client.get("https://e621.net/posts.json") {
                header("User-Agent", config.e621UserAgent)
                parameter("tags", "tontaro -rating:explicit order:id_desc")
                parameter("limit", 50)
            }.body()

            response.posts
        }
    }

    private fun checkE621Updates() {
        CoroutineScope(Dispatchers.IO).launch {
            try {
                val newPosts = fetchNewE621Posts()
                for (post in newPosts) {
                    val imageUrl = post.file.url
                    if (imageUrl != null) {
                        val embed = net.dv8tion.jda.api.EmbedBuilder()
                            // .setTitle("Новый арт от Tontaro")
                            .setImage(imageUrl)
                            // .setUrl("https://e621.net/posts/${post.id}")
                            // .setFooter("Автор: Tontaro")
                            .setColor(0x50FA7B)
                            .build()

                        // Отправляем в русскоязычный канал
                        russianFeedChannel.sendMessageEmbeds(embed).queue()

                        // Отправляем в англоязычный канал
                        englishFeedChannel.sendMessageEmbeds(embed).queue()

                        // Добавляем ID поста в набор отправленных
                        sentE621Posts.add(post.id)
                    }
                }

                // После обработки новых постов сохраняем их в файл
                saveSentE621Posts()

            } catch (e: Exception) {
                println("Ошибка при проверке обновлений e621: ${e.message}")
            }
        }
    }

    private suspend fun fetchNewE621Posts(): List<E621Post> {
        val response: E621Response = client.get("https://e621.net/posts.json") {
            header("User-Agent", config.e621UserAgent)
            parameter("tags", "tontaro -rating:explicit order:id_asc")
            parameter("limit", 50)
        }.body()

        // Фильтруем только новые посты
        return response.posts.filter { post ->
            !sentE621Posts.contains(post.id) && (post.rating == "s" || post.rating == "q")
        }
    }

    private fun checkGooglePlayUpdates() {
        val latestRelease = publisher.getLatestRelease()
        latestRelease?.let { release ->
            val cacheKey = "googleplay_${release.versionCode}"
            val releaseData = release.releaseNotes.toByteArray()
            val cachedData = messageCache.getMessageData(cacheKey)
            val messageId = messageCache.getMessageId(cacheKey)

            if (cachedData == null || messageId == null) {
                // Сообщение не было отправлено ранее или нет информации о messageId
                sendGooglePlayUpdate(release, cacheKey, releaseData)
            } else if (!cachedData.contentEquals(releaseData)) {
                // Данные изменились, пытаемся обновить сообщение
                val messageExists = checkMessageExists(googlePlayChannel, messageId)
                if (messageExists) {
                    // Обновляем существующее сообщение
                    googlePlayChannel.editMessageEmbedsById(messageId, buildEmbed(release))
                        .setActionRow(
                            net.dv8tion.jda.api.interactions.components.buttons.Button.link(
                                "https://play.google.com/store/apps/details?id=ru.deflecta.fnwb",
                                "Скачать"
                            )
                        )
                        .queue()
                    // Обновляем кеш
                    messageCache.saveMessage(cacheKey, releaseData, messageId)
                } else {
                    // Сообщение удалено, отправляем заново
                    sendGooglePlayUpdate(release, cacheKey, releaseData)
                }
            } else {
                // Данные не изменились, но проверим, существует ли сообщение
                val messageExists = checkMessageExists(googlePlayChannel, messageId)
                if (!messageExists) {
                    // Сообщение было удалено, отправляем заново
                    sendGooglePlayUpdate(release, cacheKey, releaseData)
                }
            }
        }
    }

    private fun sendGooglePlayUpdate(release: ReleaseInfo, cacheKey: String, releaseData: ByteArray) {
        googlePlayChannel.sendMessageEmbeds(buildEmbed(release))
            .setActionRow(
                net.dv8tion.jda.api.interactions.components.buttons.Button.link(
                    "https://play.google.com/store/apps/details?id=ru.deflecta.fnwb",
                    "Скачать"
                )
            )
            .queue { message ->
                messageCache.saveMessage(cacheKey, releaseData, message.id)
            }
    }

    private fun checkModsUpdates() {
        CoroutineScope(Dispatchers.IO).launch {
            for (mod in config.mods) {
                try {
                    val newLanguageData = getLanguageFiles(mod, client, config.curseForgeApiKey)
                    if (newLanguageData != null) {
                        var shouldNotify = false
                        var previousData: ModLanguageData? = null
                        var ruChanged = false
                        var enChanged = false

                        mutex.withLock {
                            previousData = langFiles[mod.name]
                            if (previousData == null) {
                                langFiles[mod.name] = newLanguageData
                                shouldNotify = true
                                ruChanged = newLanguageData.ruRu != null
                                enChanged = newLanguageData.enUs != null
                            } else {
                                ruChanged = !newLanguageData.ruRu.contentEquals(previousData!!.ruRu)
                                enChanged = !newLanguageData.enUs.contentEquals(previousData!!.enUs)
                                if (ruChanged || enChanged) {
                                    langFiles[mod.name] = newLanguageData
                                    shouldNotify = true
                                }
                            }
                        }

                        if (shouldNotify) {
                            val cacheKey = "mod_${mod.name}_${newLanguageData.modVersion}"
                            val dataForCache =
                                (newLanguageData.ruRu ?: ByteArray(0)) + (newLanguageData.enUs ?: ByteArray(0))
                            val cachedData = messageCache.getMessageData(cacheKey)
                            val messageId = messageCache.getMessageId(cacheKey)

                            if (cachedData == null || messageId == null) {
                                // Сообщение не было отправлено ранее или нет информации о messageId
                                sendLanguageUpdateEmbed(
                                    modsChannel,
                                    mod.name,
                                    newLanguageData,
                                    ruChanged,
                                    enChanged,
                                    cacheKey,
                                    dataForCache
                                )
                            } else if (!cachedData.contentEquals(dataForCache)) {
                                // Данные изменились, пытаемся обновить сообщение
                                val messageExists = checkMessageExists(modsChannel, messageId)
                                if (messageExists) {
                                    // Обновляем существующее сообщение
                                    val embedBuilder =
                                        buildLanguageEmbed(mod.name, newLanguageData, ruChanged, enChanged)
                                    val attachments = buildAttachments(mod.name, newLanguageData)
                                    modsChannel.editMessageEmbedsById(messageId, embedBuilder.build())
                                        .setFiles(attachments)
                                        .queue()
                                    // Обновляем кеш
                                    messageCache.saveMessage(cacheKey, dataForCache, messageId)
                                } else {
                                    // Сообщение удалено, отправляем заново
                                    sendLanguageUpdateEmbed(
                                        modsChannel,
                                        mod.name,
                                        newLanguageData,
                                        ruChanged,
                                        enChanged,
                                        cacheKey,
                                        dataForCache
                                    )
                                }
                            } else {
                                // Данные не изменились, проверяем, существует ли сообщение
                                val messageExists = checkMessageExists(modsChannel, messageId)
                                if (!messageExists) {
                                    // Сообщение было удалено, отправляем заново
                                    sendLanguageUpdateEmbed(
                                        modsChannel,
                                        mod.name,
                                        newLanguageData,
                                        ruChanged,
                                        enChanged,
                                        cacheKey,
                                        dataForCache
                                    )
                                }
                            }
                        }
                    }
                } catch (e: Exception) {
                    println("Ошибка при проверке мода ${mod.name}: ${e.message}")
                }
            }
        }
    }

    private fun buildLanguageEmbed(
        modName: String,
        languageData: ModLanguageData,
        ruChanged: Boolean,
        enChanged: Boolean
    ): net.dv8tion.jda.api.EmbedBuilder {
        val embedBuilder = net.dv8tion.jda.api.EmbedBuilder()
            .setTitle("Мод $modName обновился!")
            .setDescription("Возможно вы захотите обновить свои переводы.")
            .addField("Версия мода", languageData.modVersion ?: "Неизвестно", true)
            .setColor(0x50FA7B)

        val changesDescription = when {
            ruChanged && enChanged -> "Изменились оба языковых файла: `ru_ru` и `en_us`."
            ruChanged -> "Изменился только `ru_ru`."
            enChanged -> "Изменился только `en_us`."
            else -> "Нет изменений в языковых файлах."
        }

        embedBuilder.addField("Какие из файлов изменились", changesDescription, false)
        return embedBuilder
    }

    private fun buildAttachments(modName: String, languageData: ModLanguageData): List<FileUpload> {
        val attachments = mutableListOf<FileUpload>()
        languageData.ruRu?.let {
            attachments.add(FileUpload.fromData(it, "${modName}_ru_ru.json"))
        }
        languageData.enUs?.let {
            attachments.add(FileUpload.fromData(it, "${modName}_en_us.json"))
        }
        return attachments
    }

    private fun checkMessageExists(channel: NewsChannel, messageId: String): Boolean {
        return try {
            val message = channel.retrieveMessageById(messageId).complete()
            message != null
        } catch (e: Exception) {
            // Сообщение не найдено или нет доступа
            false
        }
    }

    private fun sendLanguageUpdateEmbed(
        channel: NewsChannel,
        modName: String,
        languageData: ModLanguageData,
        ruChanged: Boolean,
        enChanged: Boolean,
        cacheKey: String,
        dataForCache: ByteArray
    ) {
        val embedBuilder = net.dv8tion.jda.api.EmbedBuilder()
            .setTitle("Мод $modName обновился!")
            .setDescription("Возможно вы захотите обновить свои переводы.")
            .addField("Версия мода", languageData.modVersion ?: "Неизвестно", true)
            .setColor(0x50FA7B)

        val changesDescription = when {
            ruChanged && enChanged -> "Изменились оба языковых файла: `ru_ru` и `en_us`."
            ruChanged -> "Изменился только `ru_ru`."
            enChanged -> "Изменился только `en_us`."
            else -> "Нет изменений в языковых файлах."
        }

        embedBuilder.addField("Какие из файлов изменились", changesDescription, false)

        // Прикрепляем файлы
        val attachments = mutableListOf<FileUpload>()
        languageData.ruRu?.let {
            attachments.add(FileUpload.fromData(it, "${modName}_ru_ru.json"))
        }
        languageData.enUs?.let {
            attachments.add(FileUpload.fromData(it, "${modName}_en_us.json"))
        }

        channel.sendMessageEmbeds(embedBuilder.build())
            .addFiles(attachments)
            .queue { message ->
                messageCache.saveMessage(cacheKey, dataForCache, message.id)
            }
    }

    private fun buildEmbed(release: ReleaseInfo): MessageEmbed {
        val releaseType = when (release.releaseType) {
            "internal" -> "Внутреннее тестирование"
            "alpha" -> "Альфа"
            "beta" -> "Бета"
            "production" -> "Релиз"
            else -> release.releaseType
        }
        val embedBuilder = net.dv8tion.jda.api.EmbedBuilder()
            .setTitle("Вышла новая версия для тестировщиков")
            .setDescription("Протестируйте её!")
            .addField("Версия", release.versionName, true)
            .addField("Тип выпуска", releaseType, true)
            .addField("Список изменений", release.releaseNotes, false)
            .setThumbnail("https://lh3.googleusercontent.com/g-SDH_bNyQg5IZgsO0Ft1enmz72Cm-e94nOb-wLu3JtSISKmQk-sO_2atrv8K8TAkg")
            .setColor(0x50FA7B)
        return embedBuilder.build()
    }

    private suspend fun getLanguageFiles(mod: ModConfig, client: HttpClient, apiKey: String): ModLanguageData? {
        // Попытка найти мод на Modrinth
        try {
            if (!mod.modrinthId.isNullOrBlank()) {
                val modrinthData = getModrinthLanguageFiles(mod.modrinthId, client)
                if (modrinthData != null) return modrinthData
            } else {
                val modrinthDataByName = searchModrinthByName(mod.name, client)
                if (modrinthDataByName != null) return modrinthDataByName
            }
        } catch (e: Exception) {
            println("Ошибка при обращении к Modrinth для мода ${mod.name}: ${e.message}")
            // Продолжаем к CurseForge
        }

        // Попытка найти мод на CurseForge
        try {
            if (!mod.curseForgeId.isNullOrBlank()) {
                val curseForgeData = getCurseForgeLanguageFiles(mod.curseForgeId, client, apiKey)
                if (curseForgeData != null) return curseForgeData
            } else {
                val curseForgeDataByName = searchCurseForgeByName(mod.name, client, apiKey)
                if (curseForgeDataByName != null) return curseForgeDataByName
            }
        } catch (e: Exception) {
            println("Ошибка при обращении к CurseForge для мода ${mod.name}: ${e.message}")
        }

        // Если ничего не найдено
        return null
    }

    private suspend fun getModrinthLanguageFiles(modrinthId: String, client: HttpClient): ModLanguageData? {
        // Получение версий мода
        val versions: List<ModrinthVersion> =
            client.get("https://api.modrinth.com/v2/project/$modrinthId/version").body()
        if (versions.isEmpty()) return null

        // Предполагаем, что первая версия самая новая
        val latestVersion = versions.first()
        val fileInfo = latestVersion.files.find { it.primary } ?: latestVersion.files.firstOrNull() ?: return null

        // Скачивание JAR-файла
        val jarBytes: ByteArray = client.get(fileInfo.url).body()

        // Извлечение языковых файлов
        val languageData = extractLanguageFiles(jarBytes)

        // Создаём новый экземпляр с обновлёнными данными
        val updatedLanguageData = languageData.copy(
            modVersion = latestVersion.version_number,
            releaseDate = latestVersion.date_published
        )

        return updatedLanguageData
    }

    private suspend fun searchModrinthByName(name: String, client: HttpClient): ModLanguageData? {
        val searchResponse: ModrinthSearchResponse = client.get("https://api.modrinth.com/v2/search") {
            parameter("query", name)
            parameter("limit", 1)
        }.body()

        if (searchResponse.hits.isEmpty()) return null

        return getModrinthLanguageFiles(searchResponse.hits[0].id, client)
    }

    private suspend fun getCurseForgeLanguageFiles(
        curseForgeId: String,
        client: HttpClient,
        apiKey: String
    ): ModLanguageData? {
        // Получение списка файлов мода
        val filesResponse: CurseForgeFileResponse =
            client.get("https://api.curseforge.com/v1/mods/$curseForgeId/files") {
                header("x-api-key", apiKey)
            }.body()

        if (filesResponse.data.isEmpty()) return null

        // Предполагаем, что первый файл самый последний
        val fileData = filesResponse.data.firstOrNull { !it.downloadUrl.isNullOrBlank() } ?: return null
        val downloadUrl = fileData.downloadUrl!!

        // Скачивание JAR-файла
        val jarBytes: ByteArray = client.get(downloadUrl).body()

        // Извлечение языковых файлов
        val languageData = extractLanguageFiles(jarBytes)

        // Создаём новый экземпляр с обновлёнными данными
        val updatedLanguageData = languageData.copy(
            modVersion = fileData.displayName,
            releaseDate = fileData.fileDate
        )

        return updatedLanguageData
    }

    private suspend fun searchCurseForgeByName(
        name: String,
        client: HttpClient,
        apiKey: String
    ): ModLanguageData? {
        val searchResponse: CurseForgeSearchResponse = client.get("https://api.curseforge.com/v1/mods/search") {
            header("x-api-key", apiKey)
            parameter("gameId", 432) // ID игры Minecraft
            parameter("searchFilter", name)
            parameter("pageSize", 1)
        }.body()

        if (searchResponse.data.isEmpty()) return null

        val modId = searchResponse.data.first().id
        return getCurseForgeLanguageFiles(modId.toString(), client, apiKey)
    }

    private fun extractLanguageFiles(jarBytes: ByteArray): ModLanguageData {
        val jarInputStream = ZipInputStream(jarBytes.inputStream())
        var ruRuBytes: ByteArray? = null
        var enUsBytes: ByteArray? = null
        var modVersion: String? = null
        var releaseDate: String? = null

        var entry = jarInputStream.nextEntry
        while (entry != null) {
            val name = entry.name.lowercase()
            when {
                name.matches(Regex(""".*/lang/ru_ru\.(json|lang|properties)$""")) -> {
                    val baos = ByteArrayOutputStream()
                    jarInputStream.copyTo(baos)
                    ruRuBytes = baos.toByteArray()
                }

                name.matches(Regex(""".*/lang/en_us\.(json|lang|properties)$""")) -> {
                    val baos = ByteArrayOutputStream()
                    jarInputStream.copyTo(baos)
                    enUsBytes = baos.toByteArray()
                }

                name.matches(Regex(""".*/mods\.toml$""")) -> {
                    // Извлекаем версию мода из mods.toml
                    val baos = ByteArrayOutputStream()
                    jarInputStream.copyTo(baos)
                    val modsTomlContent = baos.toString("UTF-8")
                    modVersion = parseModVersionFromModsToml(modsTomlContent)
                }
            }
            jarInputStream.closeEntry()
            if (ruRuBytes != null && enUsBytes != null && modVersion != null) {
                break // Нашли все необходимое
            }
            entry = jarInputStream.nextEntry
        }
        jarInputStream.close()
        return ModLanguageData(ruRuBytes, enUsBytes, modVersion, releaseDate)
    }

    private fun parseModVersionFromModsToml(modsTomlContent: String): String? {
        val versionRegex = Regex("""\s*version\s*=\s*"([^"]+)"""")
        val matchResult = versionRegex.find(modsTomlContent)
        return matchResult?.groups?.get(1)?.value
    }

    override fun onSlashCommandInteraction(event: SlashCommandInteractionEvent) {
        val commandName = event.name
        if (commandName == "tontaro" || commandName == "тонтаро") {
            // Проверяем ID канала
            val channelId = event.channel.id
            val allowedChannels = listOf("878021004838969376", "927956548200841286")
            if (channelId !in allowedChannels) {
                event.reply("Эта команда недоступна в этом канале.").setEphemeral(true).queue()
                return
            }

            // Обработка команды
            CoroutineScope(Dispatchers.IO).launch {
                try {
                    val post = fetchRandomE621Post()
                    if (post != null && post.file.url != null) {
                        val imageUrl = post.file.url
                        val embed = net.dv8tion.jda.api.EmbedBuilder()
                            // .setTitle("Случайный арт от Tontaro")
                            .setImage(imageUrl)
                            // .setUrl("https://e621.net/posts/${post.id}")
                            // .setFooter("Автор: Tontaro")
                            .setColor(0x50FA7B)
                            .build()

                        event.replyEmbeds(embed).queue()
                    } else {
                        event.reply("Не удалось получить арт. Попробуйте позже.").setEphemeral(true).queue()
                    }
                } catch (e: Exception) {
                    println("Ошибка при выполнении команды /$commandName: ${e.message}")
                    event.reply("Произошла ошибка. Попробуйте позже.").setEphemeral(true).queue()
                }
            }
        }
    }

    private suspend fun fetchRandomE621Post(): E621Post? {
        val response: E621Response = client.get("https://e621.net/posts.json") {
            header("User-Agent", config.e621UserAgent)
            parameter("tags", "tontaro -rating:explicit order:random")
            parameter("limit", 1)
        }.body()

        return response.posts.firstOrNull()
    }

    private suspend fun <T> retryIO(
        times: Int = 3,
        initialDelay: Long = 100,
        maxDelay: Long = 1000,
        factor: Double = 2.0,
        block: suspend () -> T
    ): T {
        var currentDelay = initialDelay
        repeat(times - 1) {
            try {
                return block()
            } catch (e: Exception) {
                println("Неудачная попытка: ${e.message}")
                delay(currentDelay)
                currentDelay = (currentDelay * factor).toLong().coerceAtMost(maxDelay)
            }
        }
        return block()
    }

    private val client = HttpClient(CIO) {
        install(ContentNegotiation) {
            json(Json { ignoreUnknownKeys = true })
        }
        // Увеличиваем тайм-ауты
        engine {
            requestTimeout = 10000 // 10 секунд
        }
    }
}