import fs from "node:fs";

import type { Message } from "grammy/types";

import { formatLocationText } from "openclaw/plugin-sdk/channel-inbound";

import {

parseStrictNonNegativeInteger,

parseStrictPositiveInteger,

} from "openclaw/plugin-sdk/number-runtime";

import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";

import type { MsgContext } from "openclaw/plugin-sdk/reply-runtime";

import { logVerbose } from "openclaw/plugin-sdk/runtime-env";

import { appendRegularFileSync, replaceFileAtomicSync } from "openclaw/plugin-sdk/security-runtime";

getTelegramTextParts,

normalizeForwardedContext,

} from "./bot/helpers.js";

import { parseTelegramMessageThreadId } from "./outbound-params.js";

import { getOptionalTelegramRuntime } from "./runtime.js";

export type TelegramReplyChainEntry = NonNullable<MsgContext["ReplyChain"]>[number];

const forwardedFrom = normalizeForwardedContext(msg);

const replyMessage = resolveReplyMessage(msg);

const body = resolveMessageBody(msg);

const threadId = normalizeTelegramCacheThreadId(params.threadId);

return {

sourceMessage: msg,

messageId: String(msg.message_id),

...(forwardedFrom?.fromId ? { forwardedFromId: forwardedFrom.fromId } : {}),

...(forwardedFrom?.fromUsername ? { forwardedFromUsername: forwardedFrom.fromUsername } : {}),

...(forwardedFrom?.date ? { forwardedDate: forwardedFrom.date * 1000 } : {}),

...(params.threadId != null ? { threadId: String(params.threadId) } : {}),

...(threadId !== undefined ? { threadId: String(threadId) } : {}),

};

}

function resolveMessageThreadId(msg: Message): number | undefined {

const threadId = (msg as { message_thread_id?: unknown }).message_thread_id;

return typeof threadId === "number" && Number.isFinite(threadId)

? Math.trunc(threadId)

: undefined;

return normalizeTelegramCacheThreadId(threadId);

}

function normalizeMessageNodes(

}

function parseCachedThreadId(value: unknown): number | undefined {

return parseStrictNonNegativeInteger(value);

return normalizeTelegramCacheThreadId(value);

}

function normalizeTelegramCacheThreadId(value: unknown): number | undefined {

return parseTelegramMessageThreadId(value);

}

function isTelegramSourceMessage(value: unknown): value is Message {

}) => {

await hydrateMessageCacheBucket(bucket, maxMessages, scopeKey);

const prefix = telegramMessageCacheKeyPrefix({ scopeKey, ...params });

const threadId = params.threadId != null ? String(params.threadId) : undefined;

const normalizedThreadId = normalizeTelegramCacheThreadId(params.threadId);

if (params.threadId != null && normalizedThreadId === undefined) {

return [];

}

const threadId = normalizedThreadId !== undefined ? String(normalizedThreadId) : undefined;

return Array.from(messages, ([key, node]) => ({ key, node }))

.filter(({ key, node }) => {

if (!key.startsWith(prefix)) {