/**
 * Telegram settings menu UI helpers
 * Zones: telegram ui, settings controls, menu composition
 * Owns hidden settings-menu rendering, settings callbacks, and persisted toggle wiring
 */

import type {
  TelegramActivityVerbosity,
  TelegramAssistantRenderingMode,
  TelegramTimeMode,
} from "./config.ts";
import type { TelegramInlineKeyboardMarkup } from "./keyboard.ts";
import type { TelegramModelMenuState } from "./menu-model.ts";
import type { MenuModel } from "./model.ts";
import {
  getTelegramExtensionSettingsRows,
  type TelegramSectionRegistry,
} from "./sections.ts";
import type { TelegramVoiceReplyMode } from "./voice.ts";

export type TelegramSettingsMenuReplyMarkup = TelegramInlineKeyboardMarkup;

export interface TelegramSettingsStateDeps {
  isProactivePushEnabled: () => boolean;
  areDraftPreviewsEnabled: () => boolean;
  getAssistantRenderingMode: () => TelegramAssistantRenderingMode;
  getActivityVerbosity: () => TelegramActivityVerbosity;
  getTimeInjectionMode: () => TelegramTimeMode;
  getVoiceReplyMode: () => TelegramVoiceReplyMode;
  isVoiceReplyModeConfigured: () => boolean;
  isAutomaticThreadCleanupEnabled: () => boolean;
}

export interface TelegramSettingsMutationDeps extends TelegramSettingsStateDeps {
  setProactivePushEnabled: (enabled: boolean) => Promise<void>;
  setDraftPreviewsEnabled: (enabled: boolean) => Promise<void>;
  setAssistantRenderingMode: (
    mode: TelegramAssistantRenderingMode,
  ) => Promise<void>;
  setActivityVerbosity: (
    verbosity: TelegramActivityVerbosity,
  ) => Promise<void>;
  setVoiceReplyMode: (
    mode: TelegramVoiceReplyMode | undefined,
  ) => Promise<void>;
  setTimeInjectionMode: (mode: TelegramTimeMode) => Promise<void>;
  setAutomaticThreadCleanupEnabled: (enabled: boolean) => Promise<void>;
}

export interface TelegramSettingsMenuOpenDeps<
  TModel extends MenuModel = MenuModel,
> extends TelegramSettingsStateDeps {
  getModelMenuState: () => Promise<TelegramModelMenuState<TModel>>;
  sendSettingsMenu: (
    state: TelegramModelMenuState<TModel>,
    text: string,
    replyMarkup: TelegramSettingsMenuReplyMarkup,
  ) => Promise<number | undefined>;
  storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
}

export interface TelegramSettingsMenuCallbackDeps extends TelegramSettingsMutationDeps {
  updateSettingsMessage: (
    text: string,
    replyMarkup: TelegramSettingsMenuReplyMarkup,
  ) => Promise<void>;
  answerCallbackQuery: (
    callbackQueryId: string,
    text?: string,
  ) => Promise<void>;
  sectionRegistry?: TelegramSectionRegistry;
}

export interface TelegramSettingsMenuRuntime<TContext> {
  openSettingsMenu: (
    chatId: number,
    replyToMessageId: number,
    ctx: TContext,
  ) => Promise<void>;
  handleCallbackQuery: (
    query: {
      id: string;
      data?: string;
      message?: {
        message_id?: number;
        message_thread_id?: number;
        chat?: { id?: number };
      };
    },
    ctx: TContext,
  ) => Promise<boolean>;
  updateSettingsMenuMessage: (
    state: TelegramModelMenuState,
    ctx: TContext,
  ) => Promise<void>;
}

export interface TelegramSettingsMenuMessageUpdateDeps extends TelegramSettingsStateDeps {
  updateSettingsMessage: (
    text: string,
    replyMarkup: TelegramSettingsMenuReplyMarkup,
  ) => Promise<void>;
}

export interface TelegramSettingsMenuRuntimeDeps<
  TContext,
  TModel extends MenuModel = MenuModel,
> extends TelegramSettingsMutationDeps {
  reloadConfig?: () => Promise<void>;
  getModelMenuState: (
    chatId: number,
    ctx: TContext,
    threadId?: number,
  ) => Promise<TelegramModelMenuState<TModel>>;
  getStoredModelMenuState: (
    messageId: number | undefined,
    chatId?: number,
  ) => TelegramModelMenuState<TModel> | undefined;
  storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
  editInteractiveMessage: (
    chatId: number,
    messageId: number,
    text: string,
    mode: "markdown" | "html" | "plain",
    replyMarkup: TelegramSettingsMenuReplyMarkup,
  ) => Promise<void>;
  sendInteractiveMessage: (
    chatId: number,
    text: string,
    mode: "markdown" | "html" | "plain",
    replyMarkup: TelegramSettingsMenuReplyMarkup,
  ) => Promise<number | undefined>;
  answerCallbackQuery: (
    callbackQueryId: string,
    text?: string,
  ) => Promise<void>;
}

export const SETTINGS_MENU_TITLE = "<b>⚙️ Settings:</b>";
export const AUTOMATIC_THREAD_CLEANUP_SETTINGS_TITLE =
  "<b>🧹 Thread cleanup:</b>";
export const PROACTIVE_PUSH_SETTINGS_TITLE = "<b>📌 Proactive push:</b>";
export const DRAFT_PREVIEWS_SETTINGS_TITLE = "<b>📝 Draft previews:</b>";
export const ASSISTANT_RENDERING_SETTINGS_TITLE =
  "<b>🧾 Assistant rendering:</b>";
export const ACTIVITY_VERBOSITY_SETTINGS_TITLE =
  "<b>🔬 Activity:</b>";
export const TIME_INJECTION_MODE_SETTINGS_TITLE =
  "<b>🕒 Time injection mode:</b>";
export const VOICE_REPLY_MODE_SETTINGS_TITLE = "<b>👄 Voice reply mode:</b>";

function getVoiceReplyModeLabel(mode: TelegramVoiceReplyMode): string {
  return mode;
}

function getTelegramSettingsStateValueLabel(value: string): string {
  return value.toLowerCase();
}

function getVoiceReplyModeSetting(
  mode: TelegramVoiceReplyMode,
  configured: boolean,
): TelegramVoiceReplyMode {
  return configured ? mode : "manual";
}

export function buildTelegramSettingsMenuText(): string {
  return SETTINGS_MENU_TITLE;
}

export function buildAutomaticThreadCleanupSettingsText(
  enabled: boolean,
): string {
  return [
    `${AUTOMATIC_THREAD_CLEANUP_SETTINGS_TITLE} <code>${enabled ? "on" : "off"}</code>`,
    "",
    "Delete this Pi instance's Telegram tab when Pi quits normally.",
    "",
    "<code>-</code> <code>on</code> (default): delete the bound thread and release Telegram authority on graceful quit.",
    "<code>-</code> <code>off</code>: preserve the tab as a restart hint; manual <code>/telegram-disconnect</code> still confirms and deletes it.",
  ].join("\n");
}

export function buildProactivePushSettingsText(
  proactivePushEnabled: boolean,
): string {
  return [
    `${PROACTIVE_PUSH_SETTINGS_TITLE} <code>${proactivePushEnabled ? "on" : "off"}</code>`,
    "",
    "Control whether public assistant output from local/autonomous work is projected to Telegram.",
    "",
    "<code>-</code> <code>on</code> (default): send each completed public block, including visible checkpoints and the final answer, while connected.",
    "<code>-</code> <code>off</code>: keep local/autonomous assistant blocks in Pi; Telegram-originated replies still use their normal delivery path.",
  ].join("\n");
}

export function buildDraftPreviewsSettingsText(enabled: boolean): string {
  return [
    `${DRAFT_PREVIEWS_SETTINGS_TITLE} <code>${enabled ? "on" : "off"}</code>`,
    "",
    "Show live answer drafts while the model is answering.",
    "",
    "<code>-</code> <code>on</code>: stream safe Telegram Rich Draft frames before the final answer.",
    "<code>-</code> <code>off</code> (default): show native active status, then send one final answer.",
  ].join("\n");
}

export function buildAssistantRenderingSettingsText(
  mode: TelegramAssistantRenderingMode,
): string {
  return [
    `${ASSISTANT_RENDERING_SETTINGS_TITLE} <code>${mode}</code>`,
    "",
    "Choose how final assistant Markdown answers are delivered.",
    "",
    "<code>-</code> <code>rich</code> (default): use Telegram Native Rich Markdown.",
    "<code>-</code> <code>html</code>: use the legacy Markdown-to-HTML renderer.",
  ].join("\n");
}

export function buildActivityVerbositySettingsText(
  verbosity: TelegramActivityVerbosity,
): string {
  return [
    `${ACTIVITY_VERBOSITY_SETTINGS_TITLE} <code>${verbosity}</code>`,
    "",
    "Choose how much technical model activity Telegram shows.",
    "",
    "<code>-</code> <code>quiet</code>: show no thinking or tool traffic.",
    "<code>-</code> <code>thinking</code>: show persistent collapsed thinking.",
    "<code>-</code> <code>tools</code>: show persistent Rich tool details.",
    "<code>-</code> <code>verbose</code> (default): show both thinking and tools.",
  ].join("\n");
}

export function buildVoiceReplyModeSettingsText(
  mode: TelegramVoiceReplyMode,
  configured = true,
): string {
  return [
    `${VOICE_REPLY_MODE_SETTINGS_TITLE} <code>${getVoiceReplyModeLabel(
      getVoiceReplyModeSetting(mode, configured),
    )}</code>`,
    "",
    "Controls when pi-telegram converts assistant text replies into Telegram voice messages.",
    "",
    "<code>-</code> <code>manual</code> (default): add no automatic voice context; explicit 'telegram_voice' actions still work.",
    "<code>-</code> <code>mirror</code>: voice input activates automatic voice delivery; text input follows 'manual' behavior.",
    "<code>-</code> <code>always</code>: activate automatic voice delivery for every reply.",
  ].join("\n");
}

export function buildTimeInjectionModeSettingsText(
  mode: TelegramTimeMode,
): string {
  return [
    `${TIME_INJECTION_MODE_SETTINGS_TITLE} <code>${mode}</code>`,
    "",
    "Controls whether Telegram-originated prompts include a compact wall-clock [time] line.",
    "",
    "<code>-</code> <code>hidden</code>: no time line is added to prompt context.",
    "<code>-</code> <code>always</code>: add time to every Telegram turn.",
    "<code>-</code> <code>interval</code> (default): add time at most once per chat interval (1 hour unless configured).",
  ].join("\n");
}

export function buildTelegramSettingsMenuReplyMarkup(
  proactivePushEnabled: boolean,
  draftPreviewsEnabled: boolean,
  assistantRenderingModeOrVoiceReplyMode:
    TelegramAssistantRenderingMode | TelegramVoiceReplyMode,
  voiceReplyModeOrTimeInjectionMode: TelegramVoiceReplyMode | TelegramTimeMode,
  timeInjectionModeOrSectionRegistry?:
    TelegramTimeMode | TelegramSectionRegistry,
  sectionRegistryOrVoiceReplyModeConfigured?: TelegramSectionRegistry | boolean,
  voiceReplyModeConfigured = true,
  automaticThreadCleanupEnabled = true,
  activityVerbosity: TelegramActivityVerbosity = "quiet",
): TelegramSettingsMenuReplyMarkup {
  const hasRenderingMode =
    assistantRenderingModeOrVoiceReplyMode === "rich" ||
    assistantRenderingModeOrVoiceReplyMode === "html";
  const assistantRenderingMode: TelegramAssistantRenderingMode =
    hasRenderingMode ? assistantRenderingModeOrVoiceReplyMode : "rich";
  const voiceReplyMode = hasRenderingMode
    ? (voiceReplyModeOrTimeInjectionMode as TelegramVoiceReplyMode)
    : (assistantRenderingModeOrVoiceReplyMode as TelegramVoiceReplyMode);
  const timeInjectionMode = hasRenderingMode
    ? (timeInjectionModeOrSectionRegistry as TelegramTimeMode)
    : (voiceReplyModeOrTimeInjectionMode as TelegramTimeMode);
  const sectionRegistry = hasRenderingMode
    ? (sectionRegistryOrVoiceReplyModeConfigured as
        TelegramSectionRegistry | undefined)
    : (timeInjectionModeOrSectionRegistry as
        TelegramSectionRegistry | undefined);
  const effectiveVoiceReplyModeConfigured = hasRenderingMode
    ? voiceReplyModeConfigured
    : typeof sectionRegistryOrVoiceReplyModeConfigured === "boolean"
      ? sectionRegistryOrVoiceReplyModeConfigured
      : true;
  const rows: Array<Array<{ text: string; callback_data: string }>> = [
    [{ text: "⬆️ Main menu", callback_data: "menu:back" }],
  ];
  const settingsButtons: Array<{ text: string; callback_data: string }> = [
    {
      text: `📝 Draft previews: ${draftPreviewsEnabled ? "on" : "off"}`,
      callback_data: "settings:open:draft-previews",
    },
    {
      text: `🧾 Rendering: ${assistantRenderingMode}`,
      callback_data: "settings:open:assistant-rendering",
    },
    {
      text: `👄 Voice reply: ${getTelegramSettingsStateValueLabel(
          getVoiceReplyModeLabel(
            getVoiceReplyModeSetting(
              voiceReplyMode,
              effectiveVoiceReplyModeConfigured,
            ),
          ),
        )}`,
      callback_data: "settings:open:voice-reply",
    },
    {
      text: `🔬 Activity: ${activityVerbosity}`,
      callback_data: "settings:open:activity-verbosity",
    },
    {
      text: `📌 Proactive push: ${proactivePushEnabled ? "on" : "off"}`,
      callback_data: "settings:open:proactive",
    },
    {
      text: `🕒 Time injection: ${getTelegramSettingsStateValueLabel(timeInjectionMode)}`,
      callback_data: "settings:open:time-injection",
    },
    {
      text: `🧹 Thread cleanup: ${automaticThreadCleanupEnabled ? "on" : "off"}`,
      callback_data: "settings:open:automatic-thread-cleanup",
    },
  ];
  if (sectionRegistry) {
    const extensionRows = getTelegramExtensionSettingsRows(sectionRegistry);
    settingsButtons.push(
      ...extensionRows.map((row) => ({
        text: row.label,
        callback_data: row.callback_data,
      })),
    );
  }
  rows.push(...settingsButtons.map((button) => [button]));
  return { inline_keyboard: rows };
}

export async function openTelegramSettingsMenu<
  TModel extends MenuModel = MenuModel,
>(
  deps: TelegramSettingsMenuOpenDeps<TModel>,
  sectionRegistry?: TelegramSectionRegistry,
): Promise<void> {
  const state = await deps.getModelMenuState();
  const messageId = await deps.sendSettingsMenu(
    state,
    buildTelegramSettingsMenuText(),
    buildTelegramSettingsMenuReplyMarkup(
      deps.isProactivePushEnabled(),
      deps.areDraftPreviewsEnabled(),
      deps.getAssistantRenderingMode(),
      deps.getVoiceReplyMode(),
      deps.getTimeInjectionMode(),
      sectionRegistry,
      deps.isVoiceReplyModeConfigured(),
      deps.isAutomaticThreadCleanupEnabled(),
      deps.getActivityVerbosity(),
    ),
  );
  if (messageId === undefined) return;
  state.messageId = messageId;
  state.mode = "settings";
  deps.storeModelMenuState(state);
}

export function buildAutomaticThreadCleanupSettingsReplyMarkup(
  enabled: boolean,
): TelegramSettingsMenuReplyMarkup {
  return {
    inline_keyboard: [
      [{ text: "⬆️ Back", callback_data: "settings:list" }],
      [
        {
          text: enabled ? "🟢 On" : "⚫️ On",
          callback_data: "settings:set:automatic-thread-cleanup:on",
        },
        {
          text: enabled ? "⚫️ Off" : "🟡 Off",
          callback_data: "settings:set:automatic-thread-cleanup:off",
        },
      ],
    ],
  };
}

export function buildProactivePushSettingsReplyMarkup(
  proactivePushEnabled: boolean,
): TelegramSettingsMenuReplyMarkup {
  return {
    inline_keyboard: [
      [{ text: "⬆️ Back", callback_data: "settings:list" }],
      [
        {
          text: proactivePushEnabled ? "🟢 On" : "⚫️ On",
          callback_data: "settings:set:proactive:on",
        },
        {
          text: proactivePushEnabled ? "⚫️ Off" : "🟡 Off",
          callback_data: "settings:set:proactive:off",
        },
      ],
    ],
  };
}

export function buildDraftPreviewsSettingsReplyMarkup(
  enabled: boolean,
): TelegramSettingsMenuReplyMarkup {
  return {
    inline_keyboard: [
      [{ text: "⬆️ Back", callback_data: "settings:list" }],
      [
        {
          text: enabled ? "🟢 On" : "⚫️ On",
          callback_data: "settings:set:draft-previews:on",
        },
        {
          text: enabled ? "⚫️ Off" : "🟡 Off",
          callback_data: "settings:set:draft-previews:off",
        },
      ],
    ],
  };
}

export function buildAssistantRenderingSettingsReplyMarkup(
  mode: TelegramAssistantRenderingMode,
): TelegramSettingsMenuReplyMarkup {
  const modes: TelegramAssistantRenderingMode[] = ["rich", "html"];
  return {
    inline_keyboard: [
      [{ text: "⬆️ Back", callback_data: "settings:list" }],
      ...modes.map((value) => [
        {
          text: `${value === mode ? "🟢 " : ""}${value}`,
          callback_data: `settings:set:assistant-rendering:${value}`,
        },
      ]),
    ],
  };
}

export function buildActivityVerbositySettingsReplyMarkup(
  verbosity: TelegramActivityVerbosity,
): TelegramSettingsMenuReplyMarkup {
  const values: TelegramActivityVerbosity[] = [
    "quiet",
    "thinking",
    "tools",
    "verbose",
  ];
  return {
    inline_keyboard: [
      [{ text: "⬆️ Back", callback_data: "settings:list" }],
      ...values.map((value) => [
        {
          text: `${value === verbosity ? "🟢 " : ""}${value}`,
          callback_data: `settings:set:activity-verbosity:${value}`,
        },
      ]),
    ],
  };
}

export function buildTimeInjectionModeSettingsReplyMarkup(
  mode: TelegramTimeMode,
): TelegramSettingsMenuReplyMarkup {
  const modes: TelegramTimeMode[] = ["hidden", "always", "interval"];
  return {
    inline_keyboard: [
      [{ text: "⬆️ Back", callback_data: "settings:list" }],
      ...modes.map((value) => [
        {
          text: `${value === mode ? "🟢 " : ""}${value}`,
          callback_data: `settings:set:time-injection:${value}`,
        },
      ]),
    ],
  };
}

export function buildVoiceReplyModeSettingsReplyMarkup(
  mode: TelegramVoiceReplyMode,
  configured = true,
): TelegramSettingsMenuReplyMarkup {
  const activeMode = getVoiceReplyModeSetting(mode, configured);
  const modes: TelegramVoiceReplyMode[] = ["manual", "mirror", "always"];
  return {
    inline_keyboard: [
      [{ text: "⬆️ Back", callback_data: "settings:list" }],
      ...modes.map((value) => [
        {
          text: `${value === activeMode ? "🟢 " : ""}${getVoiceReplyModeLabel(value)}`,
          callback_data: `settings:set:voice-reply:${value}`,
        },
      ]),
    ],
  };
}

export async function updateTelegramSettingsMenuMessage(
  deps: TelegramSettingsMenuMessageUpdateDeps,
  sectionRegistry?: TelegramSectionRegistry,
): Promise<void> {
  await deps.updateSettingsMessage(
    buildTelegramSettingsMenuText(),
    buildTelegramSettingsMenuReplyMarkup(
      deps.isProactivePushEnabled(),
      deps.areDraftPreviewsEnabled(),
      deps.getAssistantRenderingMode(),
      deps.getVoiceReplyMode(),
      deps.getTimeInjectionMode(),
      sectionRegistry,
      deps.isVoiceReplyModeConfigured(),
      deps.isAutomaticThreadCleanupEnabled(),
      deps.getActivityVerbosity(),
    ),
  );
}

export async function updateAutomaticThreadCleanupSettingsMessage(
  deps: TelegramSettingsMenuCallbackDeps,
): Promise<void> {
  const enabled = deps.isAutomaticThreadCleanupEnabled();
  await deps.updateSettingsMessage(
    buildAutomaticThreadCleanupSettingsText(enabled),
    buildAutomaticThreadCleanupSettingsReplyMarkup(enabled),
  );
}

export async function updateProactivePushSettingsMessage(
  deps: TelegramSettingsMenuCallbackDeps,
): Promise<void> {
  const proactivePushEnabled = deps.isProactivePushEnabled();
  await deps.updateSettingsMessage(
    buildProactivePushSettingsText(proactivePushEnabled),
    buildProactivePushSettingsReplyMarkup(proactivePushEnabled),
  );
}

export async function updateDraftPreviewsSettingsMessage(
  deps: TelegramSettingsMenuCallbackDeps,
): Promise<void> {
  const enabled = deps.areDraftPreviewsEnabled();
  await deps.updateSettingsMessage(
    buildDraftPreviewsSettingsText(enabled),
    buildDraftPreviewsSettingsReplyMarkup(enabled),
  );
}

export async function updateAssistantRenderingSettingsMessage(
  deps: TelegramSettingsMenuCallbackDeps,
): Promise<void> {
  const mode = deps.getAssistantRenderingMode();
  await deps.updateSettingsMessage(
    buildAssistantRenderingSettingsText(mode),
    buildAssistantRenderingSettingsReplyMarkup(mode),
  );
}

export async function updateActivityVerbositySettingsMessage(
  deps: TelegramSettingsMenuCallbackDeps,
): Promise<void> {
  const verbosity = deps.getActivityVerbosity();
  await deps.updateSettingsMessage(
    buildActivityVerbositySettingsText(verbosity),
    buildActivityVerbositySettingsReplyMarkup(verbosity),
  );
}

export async function updateTimeInjectionModeSettingsMessage(
  deps: TelegramSettingsMenuCallbackDeps,
): Promise<void> {
  const mode = deps.getTimeInjectionMode();
  await deps.updateSettingsMessage(
    buildTimeInjectionModeSettingsText(mode),
    buildTimeInjectionModeSettingsReplyMarkup(mode),
  );
}

export async function updateVoiceReplyModeSettingsMessage(
  deps: TelegramSettingsMenuCallbackDeps,
): Promise<void> {
  const mode = deps.getVoiceReplyMode();
  const configured = deps.isVoiceReplyModeConfigured();
  await deps.updateSettingsMessage(
    buildVoiceReplyModeSettingsText(mode, configured),
    buildVoiceReplyModeSettingsReplyMarkup(mode, configured),
  );
}

export async function handleTelegramSettingsMenuCallbackAction(
  callbackQueryId: string,
  data: string | undefined,
  deps: TelegramSettingsMenuCallbackDeps,
): Promise<boolean> {
  if (!data?.startsWith("settings:")) return false;
  if (data === "settings:list") {
    await updateTelegramSettingsMenuMessage(deps, deps.sectionRegistry);
    await deps.answerCallbackQuery(callbackQueryId);
    return true;
  }
  if (data === "settings:open:automatic-thread-cleanup") {
    await updateAutomaticThreadCleanupSettingsMessage(deps);
    await deps.answerCallbackQuery(callbackQueryId);
    return true;
  }
  if (data === "settings:open:proactive") {
    await updateProactivePushSettingsMessage(deps);
    await deps.answerCallbackQuery(callbackQueryId);
    return true;
  }
  if (
    data === "settings:open:draft-previews" ||
    data === "settings:open:rich-drafts"
  ) {
    await updateDraftPreviewsSettingsMessage(deps);
    await deps.answerCallbackQuery(callbackQueryId);
    return true;
  }
  if (data === "settings:open:assistant-rendering") {
    await updateAssistantRenderingSettingsMessage(deps);
    await deps.answerCallbackQuery(callbackQueryId);
    return true;
  }
  if (data === "settings:open:activity-verbosity") {
    await updateActivityVerbositySettingsMessage(deps);
    await deps.answerCallbackQuery(callbackQueryId);
    return true;
  }
  if (data === "settings:open:voice-reply") {
    await updateVoiceReplyModeSettingsMessage(deps);
    await deps.answerCallbackQuery(callbackQueryId);
    return true;
  }
  if (
    data === "settings:open:time-injection" ||
    data === "settings:open:time"
  ) {
    await updateTimeInjectionModeSettingsMessage(deps);
    await deps.answerCallbackQuery(callbackQueryId);
    return true;
  }
  if (data.startsWith("settings:set:voice-reply:")) {
    const mode = data.slice("settings:set:voice-reply:".length);
    if (
      mode === "manual" ||
      mode === "hidden" ||
      mode === "mirror" ||
      mode === "always"
    ) {
      const normalizedMode = mode === "hidden" ? "manual" : mode;
      await deps.setVoiceReplyMode(normalizedMode);
      await updateVoiceReplyModeSettingsMessage(deps);
      await deps.answerCallbackQuery(
        callbackQueryId,
        `Voice reply mode: ${normalizedMode}`,
      );
      return true;
    }
  }
  if (
    data.startsWith("settings:set:time-injection:") ||
    data.startsWith("settings:set:time:")
  ) {
    const mode = data.startsWith("settings:set:time-injection:")
      ? data.slice("settings:set:time-injection:".length)
      : data.slice("settings:set:time:".length);
    const normalizedMode = mode === "off" ? "hidden" : mode;
    if (
      normalizedMode === "hidden" ||
      normalizedMode === "always" ||
      normalizedMode === "interval"
    ) {
      await deps.setTimeInjectionMode(normalizedMode);
      await updateTimeInjectionModeSettingsMessage(deps);
      await deps.answerCallbackQuery(
        callbackQueryId,
        `Time injection: ${normalizedMode}`,
      );
      return true;
    }
  }
  if (
    data === "settings:set:draft-previews:on" ||
    data === "settings:set:draft-previews:off" ||
    data === "settings:set:rich-drafts:on" ||
    data === "settings:set:rich-drafts:off"
  ) {
    const enabled = data.endsWith(":on");
    await deps.setDraftPreviewsEnabled(enabled);
    await updateDraftPreviewsSettingsMessage(deps);
    await deps.answerCallbackQuery(
      callbackQueryId,
      `Draft previews ${enabled ? "enabled" : "disabled"}`,
    );
    return true;
  }
  if (data.startsWith("settings:set:assistant-rendering:")) {
    const mode = data.slice("settings:set:assistant-rendering:".length);
    if (mode === "rich" || mode === "html") {
      await deps.setAssistantRenderingMode(mode);
      await updateAssistantRenderingSettingsMessage(deps);
      await deps.answerCallbackQuery(callbackQueryId, `Rendering: ${mode}`);
      return true;
    }
  }
  if (data.startsWith("settings:set:activity-verbosity:")) {
    const verbosity = data.slice("settings:set:activity-verbosity:".length);
    if (
      verbosity === "quiet" ||
      verbosity === "thinking" ||
      verbosity === "tools" ||
      verbosity === "verbose"
    ) {
      await deps.setActivityVerbosity(verbosity);
      await updateActivityVerbositySettingsMessage(deps);
      await deps.answerCallbackQuery(
        callbackQueryId,
        `Activity: ${verbosity}`,
      );
      return true;
    }
  }
  if (
    data === "settings:set:automatic-thread-cleanup:on" ||
    data === "settings:set:automatic-thread-cleanup:off"
  ) {
    const enabled = data.endsWith(":on");
    await deps.setAutomaticThreadCleanupEnabled(enabled);
    await updateAutomaticThreadCleanupSettingsMessage(deps);
    await deps.answerCallbackQuery(
      callbackQueryId,
      `Thread cleanup ${enabled ? "enabled" : "disabled"}`,
    );
    return true;
  }
  if (
    data === "settings:set:proactive:on" ||
    data === "settings:set:proactive:off"
  ) {
    const enabled = data.endsWith(":on");
    await deps.setProactivePushEnabled(enabled);
    await updateProactivePushSettingsMessage(deps);
    await deps.answerCallbackQuery(
      callbackQueryId,
      `Proactive push ${enabled ? "enabled" : "disabled"}`,
    );
    return true;
  }
  await deps.answerCallbackQuery(callbackQueryId);
  return true;
}

export function createTelegramSettingsMenuRuntime<
  TContext,
  TModel extends MenuModel = MenuModel,
>(
  deps: TelegramSettingsMenuRuntimeDeps<TContext, TModel>,
  sectionRegistry?: TelegramSectionRegistry,
): TelegramSettingsMenuRuntime<TContext> {
  return {
    openSettingsMenu: async (chatId, _replyToMessageId, ctx) => {
      await deps.reloadConfig?.();
      return openTelegramSettingsMenu(
        {
          getModelMenuState: () => deps.getModelMenuState(chatId, ctx),
          isProactivePushEnabled: deps.isProactivePushEnabled,
          areDraftPreviewsEnabled: deps.areDraftPreviewsEnabled,
          getAssistantRenderingMode: deps.getAssistantRenderingMode,
          getActivityVerbosity: deps.getActivityVerbosity,
          getVoiceReplyMode: deps.getVoiceReplyMode,
          isVoiceReplyModeConfigured: deps.isVoiceReplyModeConfigured,
          getTimeInjectionMode: deps.getTimeInjectionMode,
          isAutomaticThreadCleanupEnabled: deps.isAutomaticThreadCleanupEnabled,
          sendSettingsMenu: (state, text, replyMarkup) =>
            deps.sendInteractiveMessage(
              state.chatId,
              text,
              "html",
              replyMarkup,
            ),
          storeModelMenuState: deps.storeModelMenuState,
        },
        sectionRegistry,
      );
    },
    updateSettingsMenuMessage: async (state) => {
      await deps.reloadConfig?.();
      return updateTelegramSettingsMenuMessage(
        {
          isProactivePushEnabled: deps.isProactivePushEnabled,
          areDraftPreviewsEnabled: deps.areDraftPreviewsEnabled,
          getAssistantRenderingMode: deps.getAssistantRenderingMode,
          getActivityVerbosity: deps.getActivityVerbosity,
          getVoiceReplyMode: deps.getVoiceReplyMode,
          isVoiceReplyModeConfigured: deps.isVoiceReplyModeConfigured,
          getTimeInjectionMode: deps.getTimeInjectionMode,
          isAutomaticThreadCleanupEnabled: deps.isAutomaticThreadCleanupEnabled,
          updateSettingsMessage: (text, replyMarkup) =>
            deps.editInteractiveMessage(
              state.chatId,
              state.messageId,
              text,
              "html",
              replyMarkup,
            ),
        },
        sectionRegistry,
      );
    },
    handleCallbackQuery: async (query, ctx) => {
      if (!query.data?.startsWith("settings:")) return false;
      await deps.reloadConfig?.();
      const messageId = query.message?.message_id;
      const chatId = query.message?.chat?.id;
      let state = deps.getStoredModelMenuState(messageId, chatId);
      if (!state) {
        if (typeof messageId !== "number" || typeof chatId !== "number") {
          await deps.answerCallbackQuery(
            query.id,
            "Interactive message expired.",
          );
          return true;
        }
        state = await deps.getModelMenuState(
          chatId,
          ctx,
          query.message?.message_thread_id,
        );
        state.messageId = messageId;
        state.mode = "settings";
        deps.storeModelMenuState(state);
      }
      return handleTelegramSettingsMenuCallbackAction(query.id, query.data, {
        isProactivePushEnabled: deps.isProactivePushEnabled,
        areDraftPreviewsEnabled: deps.areDraftPreviewsEnabled,
        getAssistantRenderingMode: deps.getAssistantRenderingMode,
        getActivityVerbosity: deps.getActivityVerbosity,
        getVoiceReplyMode: deps.getVoiceReplyMode,
        isVoiceReplyModeConfigured: deps.isVoiceReplyModeConfigured,
        getTimeInjectionMode: deps.getTimeInjectionMode,
        isAutomaticThreadCleanupEnabled: deps.isAutomaticThreadCleanupEnabled,
        setProactivePushEnabled: deps.setProactivePushEnabled,
        setDraftPreviewsEnabled: deps.setDraftPreviewsEnabled,
        setAssistantRenderingMode: deps.setAssistantRenderingMode,
        setActivityVerbosity: deps.setActivityVerbosity,
        setVoiceReplyMode: deps.setVoiceReplyMode,
        setTimeInjectionMode: deps.setTimeInjectionMode,
        setAutomaticThreadCleanupEnabled: deps.setAutomaticThreadCleanupEnabled,
        updateSettingsMessage: (text, replyMarkup) =>
          deps.editInteractiveMessage(
            state.chatId,
            state.messageId,
            text,
            "html",
            replyMarkup,
          ),
        answerCallbackQuery: deps.answerCallbackQuery,
        sectionRegistry,
      });
    },
  };
}