private Mono<Message> processAndSendMessage(Chat chat, Message message) {
    String text = message.getContent();

    if (text.equals("/get_chat_id")) {
      Id id = chat.getId();
      Mono<Message> monoMessage = chat.sendMessage("Chat ID: " + id.asLong());
      return monoMessage;
    }

package nexus.io.gpt.translator.config;

import java.time.LocalDateTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import nexus.io.annotation.AConfiguration;
import nexus.io.annotation.Initialization;
import nexus.io.gpt.translator.services.ScheduledPushService;
import nexus.io.jfinal.aop.Aop;

import lombok.extern.slf4j.Slf4j;

@AConfiguration
@Slf4j
public class SchedulerConfig {

  private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

  @Initialization
  public void startScheduledTask() {
    ScheduledPushService scheduledPushService = Aop.get(ScheduledPushService.class);
    // 设定任务在每天的固定时间执行，例如每天上午9点
    long initialDelay = computeInitialDelay(9, 00); // 9:00 AM
    long period = TimeUnit.DAYS.toSeconds(1);

    scheduler.scheduleAtFixedRate(scheduledPushService::pushArticleToGroup, initialDelay, period, TimeUnit.SECONDS);
    log.info("定时推送任务已启动，每天上午9点执行。");
  }

  /**
   * 计算从当前时间到目标时间的初始延迟（秒）
   */
  private long computeInitialDelay(int targetHour, int targetMinute) {
    LocalDateTime now = LocalDateTime.now();
    LocalDateTime nextRun = now.withHour(targetHour).withMinute(targetMinute).withSecond(0).withNano(0);
    if (now.compareTo(nextRun) > 0) {
      nextRun = nextRun.plusDays(1);
    }
    return java.time.Duration.between(now, nextRun).getSeconds();
  }
}

package nexus.io.gpt.translator.services;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

import nexus.io.gpt.translator.client.TelegramClient;

import lombok.extern.slf4j.Slf4j;
import reactor.core.publisher.Mono;
import telegram4j.core.object.Message;
import telegram4j.core.object.chat.Chat;
import telegram4j.core.spec.SendMessageSpec;
import telegram4j.core.util.Id;

@Slf4j
public class ScheduledPushService {

  // 群组的 Chat ID，请在前面步骤中获取
  private final Long groupChatId = 4679160257L;

  /**
   * 推送文章到群组
   */
  public void pushArticleToGroup() {
    String article = getDailyArticle();
    try {
      sendMessageToGroup(article).subscribe();
      log.info("成功向群组推送文章。");
    } catch (Exception e) {
      log.error("推送文章到群组时发生异常", e);
    }
  }

  /**
   * 获取当天要推送的文章
   *
   * @return 文章内容
   */
  public String getDailyArticle() {
    // 示例：根据日期生成文章标题
    LocalDate today = LocalDate.now();
    String formattedDate = today.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"));
    String article = String.format("📅 **每日一文** - %s\n\n这里是今天的文章内容。请大家阅读并讨论！", formattedDate);
    return article;
  }

  /**
   * 通过 MTProto 客户端发送消息到指定群组
   */
  private Mono<Message> sendMessageToGroup(String message) {
    Id chatId = Id.ofChat(groupChatId);
    Mono<Chat> monoChat = TelegramClient.client.getChatById(chatId);
    Mono<Message> monoMessage = monoChat.flatMap(chat -> chat.sendMessage(SendMessageSpec.of(message)));
    return monoMessage;
  }
}

package nexus.io.gpt.translator.config;

import java.nio.file.Path;
import java.time.Duration;
import java.util.function.Function;

import nexus.io.annotation.AConfiguration;
import nexus.io.annotation.Initialization;
import nexus.io.gpt.translator.client.TelegramClient;
import nexus.io.gpt.translator.predicate.UserPredicate;
import nexus.io.gpt.translator.tgfunc.TranslateFunction;
import nexus.io.tio.boot.server.TioBootServer;
import nexus.io.tio.utils.environment.EnvUtils;

import lombok.extern.slf4j.Slf4j;
import reactor.util.retry.Retry;
import telegram4j.core.MTProtoBootstrap;
import telegram4j.core.MTProtoTelegramClient;
import telegram4j.core.event.domain.message.SendMessageEvent;
import telegram4j.mtproto.RpcException;
import telegram4j.mtproto.store.FileStoreLayout;
import telegram4j.mtproto.store.StoreLayoutImpl;

@Slf4j
@AConfiguration
public class TelegramTranslateBot {

  @Initialization
  public void config() {
    // 从环境变量获取 Telegram API 配置信息
    int apiId = EnvUtils.getInt("telegram.api.id");
    String apiHash = EnvUtils.getStr("telegram.api.hash");
    String botAuthToken = EnvUtils.getStr("telegram.bot.auth.token");

    String botId = botAuthToken.split(":")[0];
    // 创建并连接 MTProto Telegram 客户端
    MTProtoBootstrap bootstrap = MTProtoTelegramClient.create(apiId, apiHash, botAuthToken);

    StoreLayoutImpl storeLayoutImpl = new StoreLayoutImpl(Function.identity());
    FileStoreLayout storeLayout = new FileStoreLayout(storeLayoutImpl, Path.of("t4j-bot_" + botId + ".bin"));
    bootstrap.setStoreLayout(storeLayout);

    MTProtoTelegramClient client = bootstrap.connect().block();
    if (client == null) {
      log.error("Failed to connect to Telegram MTProto client.");
      return;
    }

    // 获取自己的id
    long selfId = client.getSelfId().asLong();
    log.info("self id:{}", selfId);

    // 配置事件监听器：接收 SendMessageEvent，过滤用户消息，并应用翻译功能
    client.on(SendMessageEvent.class)
        //
        .filter(new UserPredicate(selfId)::test).flatMap(new TranslateFunction()::apply)
        //
        .delayElements(Duration.ofSeconds(1)) // 每秒最多发送一条消息
        //
        .doOnError(e -> log.error("处理消息时发生错误", e))
        //
        .retryWhen(Retry.backoff(5, Duration.ofSeconds(1)).filter(e -> e instanceof RpcException))
        //
        .subscribe();

    TelegramClient.client = client;

    // 防止主线程阻塞，监控客户端断开连接
    //    TioThreadUtils.submit(() -> {
    //      client.onDisconnect().block();
    //      log.info("Telegram client disconnected.");
    //    });

    // 在服务器关闭时，断开 Telegram 客户端连接
    HookCan.me().addDestroyMethod(client::disconnect);

    log.info("Telegram MTProto client configured and connected.");
  }
}

package nexus.io.gpt.translator.client;

import telegram4j.core.MTProtoTelegramClient;

public class TelegramClient {

  public static MTProtoTelegramClient client = null;

}

package nexus.io.gpt.translator.controller;

import nexus.io.annotation.RequestPath;
import nexus.io.gpt.translator.services.ScheduledPushService;
import nexus.io.jfinal.aop.Aop;
import nexus.io.model.body.RespBodyVo;

@RequestPath("/test")
public class TestController {

  public RespBodyVo push() {
    Aop.get(ScheduledPushService.class).pushArticleToGroup();
    return RespBodyVo.ok();
  }
}

package nexus.io.gpt.translator.services;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

import nexus.io.gpt.translator.client.TelegramClient;

import lombok.extern.slf4j.Slf4j;
import reactor.core.publisher.Mono;
import telegram4j.core.object.Message;
import telegram4j.core.spec.SendMessageSpec;
import telegram4j.core.util.Id;

@Slf4j
public class ScheduledPushService {

  // 普通群组的 Chat ID
  private final Long groupChatId = 8888888L;

  // 超级群组的 Channel ID
  private final Long supergroupChannelId = 999999999L;

  /**
   * 推送文章到群组和超级群组
   */
  public void pushArticleToGroup() {
    SendMessageSpec messageSpec = SendMessageSpec.of(getDailyArticle());

    try {
      // 推送到超级群组
      sendMessageToGroup(supergroupChannelId, true, messageSpec).doOnSuccess(msg -> log.info("成功向超级群组推送文章。")).doOnError(e -> log.error("向超级群组推送文章时发生异常", e)).subscribe();

      // 推送到普通群组
      sendMessageToGroup(groupChatId, false, messageSpec).doOnSuccess(msg -> log.info("成功向普通群组推送文章。")).doOnError(e -> log.error("向普通群组推送文章时发生异常", e)).subscribe();

      log.info("推送任务已完成。");
    } catch (Exception e) {
      log.error("推送文章到群组时发生异常", e);
    }
  }

  /**
   * 获取当天要推送的文章
   *
   * @return 文章内容
   */
  public String getDailyArticle() {
    LocalDate today = LocalDate.now();
    String formattedDate = today.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"));
    String article = String.format("📅 **每日一文** - %s\n\n这里是今天的文章内容。请大家阅读并讨论！", formattedDate);
    return article;
  }

  /**
   * 通过 MTProto 客户端发送消息到指定群组或超级群组
   *
   * @param id        群组 ID 或频道 ID
   * @param isChannel 是否为频道（超级群组）
   * @param messageSpec 消息规范
   * @return Mono<Message>
   */
  private Mono<Message> sendMessageToGroup(Long id, boolean isChannel, SendMessageSpec messageSpec) {
    Id chatId;
    if (isChannel) {
      chatId = Id.ofChannel(id);
    } else {
      chatId = Id.ofChat(id);
    }

    return TelegramClient.client.getChatById(chatId).flatMap(chat -> {
      log.info("尝试发送消息到 {}: {}", isChannel ? "超级群组" : "普通群组", id);
      return chat.sendMessage(messageSpec).doOnNext(msg -> log.info("消息发送成功: {}", msg)).doOnError(e -> log.error("消息发送失败: ", e));
    });
  }
}