Reactions for your Telegram agent.

import { createHash } from "node:crypto";

export const REACTIONS = [
  "👍", "❤️", "😂", "🎉", "😮", "😢",
  "🤔", "🔥", "💀", "🙌", "👀", "💯",
];

export type ReactionOption = string | { id: string; description: string };
export type ContextMessage = { role: "user" | "assistant"; content: string; reaction?: string };
export type ReactionInput = {
  eventId: string; message: string; agent?: string;
  context?: ContextMessage[]; reactions?: ReactionOption[];
  frequency?: "reserved" | "balanced" | "expressive";
};

// Server only. eventId must identify this message across all your conversations.
export async function chooseReaction({
  eventId, message, agent, context = [], reactions = REACTIONS, frequency = "balanced",
}: ReactionInput): Promise<string> {
  const key = process.env.EMOTE_API_KEY;
  if (!key) throw new Error("Set EMOTE_API_KEY on your server.");
  if (!eventId) throw new Error("A stable eventId is required.");

  const response = await fetch("https://useemote.com/v1/react", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${key}`,
      "Content-Type": "application/json",
      "Idempotency-Key": createHash("sha256").update(eventId).digest("hex"),
    },
    body: JSON.stringify({ message, agent, context, reactions, frequency }),
    signal: AbortSignal.timeout(3000),
  });
  if (!response.ok) throw new Error(`Emote: HTTP ${response.status}`);
  const reaction = await response.json();
  const allowed = reactions.map((option) => typeof option === "string" ? option : option.id);
  if (typeof reaction !== "string" || (reaction !== "none" && !allowed.includes(reaction))) {
    throw new Error("Unexpected Emote response.");
  }
  return reaction;
}

type TelegramInput = Omit<ReactionInput, "eventId" | "message"> & {
  botId: number; chatId: number | string; messageId: number; text: string;
};

// Telegram accepts a fixed set of standard emoji, further restricted per chat.
export const TELEGRAM_REACTIONS = [
  "👍", "🎉", "🔥", "😢", "👀",
  { id: "❤", description: "Love, warmth, or heartfelt support." },
  { id: "😁", description: "A cheerful grin in response to something funny or happy." },
  { id: "🙏", description: "Gratitude, thanks, or a hopeful wish." },
];

// Call from your existing verified, deduplicated Telegram message worker.
export async function reactOnTelegram({
  botId, chatId, messageId, text, agent, context = [], reactions = TELEGRAM_REACTIONS, frequency = "balanced",
}: TelegramInput) {
  const token = process.env.TELEGRAM_BOT_TOKEN;
  if (!token) throw new Error("Set TELEGRAM_BOT_TOKEN.");
  if (!botId) throw new Error("Pass your bot's ID from getMe.");

  async function telegram(method: string, body: Record<string, unknown>) {
    // Telegram authenticates in the URL. Do not log URLs or raw fetch errors.
    let response;
    try {
      response = await fetch(`https://api.telegram.org/bot${token}/${method}`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(body),
        signal: AbortSignal.timeout(5000),
      });
    } catch {
      throw new Error(`Telegram ${method}: request failed`);
    }
    if (!response.ok) throw new Error(`Telegram ${method}: HTTP ${response.status}`);
    const data = await response.json();
    if (!data.ok) throw new Error(`Telegram ${method}: request rejected`);
    return data.result;
  }

  const chat = await telegram("getChat", { chat_id: chatId });
  const allowed: Array<{ type: string; emoji?: string }> | undefined = chat.available_reactions;
  const choices = allowed === undefined ? reactions : reactions.filter((option) => {
    const emoji = typeof option === "string" ? option : option.id;
    return allowed.some((reaction) => reaction.type === "emoji" && reaction.emoji === emoji);
  });
  if (choices.length === 0) return;

  const reaction = await chooseReaction({
    eventId: JSON.stringify(["telegram", botId, chatId, messageId]),
    message: text, agent, context, frequency, reactions: choices,
  });
  if (reaction === "none") return;

  return telegram("setMessageReaction", {
    chat_id: chatId,
    message_id: messageId,
    reaction: [{ type: "emoji", emoji: reaction }],
  });
}

// Inside your existing verified, deduplicated update worker.
// inbound is your normalized incoming text message.
const reactionTask = reactOnTelegram({
  botId: bot.id, // From your existing getMe result.
  chatId: inbound.chatId,
  messageId: inbound.messageId,
  text: inbound.text,
  agent: agentPersonality,
  context: recentMessages,
}).catch(() => console.error("Reaction failed; reply continues."));

// Your existing reply function runs independently.
const replyTask = Promise.resolve().then(() => replyToTelegram(inbound));
const [, reply] = await Promise.allSettled([reactionTask, replyTask]);
if (reply.status === "rejected") throw reply.reason;