import { NextRequest } from "next/server";
import { jsonNoStore } from "@/lib/api-response";
import {
  appendProjectMessages,
  getAuthSession,
  type AuthRole,
  type AuthSession,
  type BossState,
  type ExternalReplyTarget,
  type TelegramGroupProjectRoute,
  type TelegramIntegrationState,
  readState,
  writeState,
} from "@/lib/boss-data";
import { replyToMasterAgentUserMessage, tryBuildLocalMasterAgentFastReply } from "@/lib/boss-master-agent";

const TELEGRAM_API_BASE = "https://api.telegram.org";
const TELEGRAM_TEXT_LIMIT = 4000;
const TELEGRAM_BRIDGE_ACCOUNT = "telegram-bridge";
const TELEGRAM_BRIDGE_LABEL = "Telegram";

type TelegramChatType = "private" | "group" | "supergroup" | "channel";

interface TelegramUser {
  id: number;
  is_bot?: boolean;
  first_name?: string;
  last_name?: string;
  username?: string;
}

interface TelegramChat {
  id: number;
  type: TelegramChatType;
  title?: string;
}

interface TelegramMessage {
  message_id: number;
  message_thread_id?: number;
  date: number;
  chat: TelegramChat;
  from?: TelegramUser;
  text?: string;
  reply_to_message?: {
    from?: TelegramUser;
  };
}

interface TelegramUpdate {
  update_id: number;
  message?: TelegramMessage;
}

interface NormalizedTelegramMessage {
  updateId: number;
  messageId: number;
  chatId: string;
  chatType: TelegramChatType;
  chatTitle?: string;
  threadId?: number;
  senderId?: string;
  senderName: string;
  text: string;
  repliedToBot: boolean;
  repliedToBotUsername?: string;
}

interface TelegramGatewayView {
  enabled: boolean;
  mode: "webhook" | "polling";
  botTokenConfigured: boolean;
  botUsername?: string;
  dmPolicy: "allowlist" | "open" | "disabled";
  allowFrom: string[];
  groupPolicy: "allowlist" | "open" | "disabled";
  groups: string[];
  requireMentionInGroups: boolean;
  defaultProjectId: string;
  groupProjectRoutes: TelegramGroupProjectRoute[];
  webhookSecretConfigured: boolean;
  webhookUrl?: string;
  lastConfiguredAt?: string;
  lastConfiguredBy?: string;
  lastError?: string;
  processedUpdateCount: number;
}

function trimToDefined(value?: string | null) {
  const trimmed = value?.trim();
  return trimmed ? trimmed : undefined;
}

function toSenderName(message: TelegramMessage) {
  const firstName = trimToDefined(message.from?.first_name);
  const lastName = trimToDefined(message.from?.last_name);
  const username = trimToDefined(message.from?.username);
  return [firstName, lastName].filter(Boolean).join(" ") || username || `用户${message.from?.id ?? "未知"}`;
}

function normalizeTelegramUpdate(update: TelegramUpdate): NormalizedTelegramMessage | null {
  const message = update.message;
  const text = trimToDefined(message?.text);
  if (!message || !text) {
    return null;
  }
  return {
    updateId: update.update_id,
    messageId: message.message_id,
    chatId: String(message.chat.id),
    chatType: message.chat.type,
    chatTitle: trimToDefined(message.chat.title),
    threadId: typeof message.message_thread_id === "number" ? message.message_thread_id : undefined,
    senderId: message.from?.id != null ? String(message.from.id) : undefined,
    senderName: toSenderName(message),
    text,
    repliedToBot: message.reply_to_message?.from?.is_bot === true,
    repliedToBotUsername: trimToDefined(message.reply_to_message?.from?.username),
  };
}

function buildTelegramSessionKey(message: NormalizedTelegramMessage) {
  if (message.chatType === "private") {
    return `telegram:dm:${message.chatId}`;
  }
  if (message.threadId != null) {
    return `telegram:group:${message.chatId}:topic:${message.threadId}`;
  }
  return `telegram:group:${message.chatId}`;
}

function chunkTelegramText(text: string) {
  if (text.length <= TELEGRAM_TEXT_LIMIT) {
    return [text];
  }
  const chunks: string[] = [];
  let remaining = text.trim();
  while (remaining.length > TELEGRAM_TEXT_LIMIT) {
    let index = remaining.lastIndexOf("\n", TELEGRAM_TEXT_LIMIT);
    if (index < Math.floor(TELEGRAM_TEXT_LIMIT * 0.6)) {
      index = TELEGRAM_TEXT_LIMIT;
    }
    chunks.push(remaining.slice(0, index).trim());
    remaining = remaining.slice(index).trim();
  }
  if (remaining) {
    chunks.push(remaining);
  }
  return chunks;
}

function escapeRegExp(value: string) {
  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}

function resolveTelegramMentionRegex(botUsername?: string) {
  const username = trimToDefined(botUsername);
  if (!username) {
    return null;
  }
  return new RegExp(`(^|\\s)@${escapeRegExp(username)}\\b`, "ig");
}

function hasTelegramBotMention(text: string, botUsername?: string) {
  const mentionRegex = resolveTelegramMentionRegex(botUsername);
  if (!mentionRegex) {
    return /@\S+/.test(text);
  }
  return mentionRegex.test(text);
}

function isReplyToConfiguredTelegramBot(message: NormalizedTelegramMessage, botUsername?: string) {
  if (!message.repliedToBot) {
    return false;
  }
  const expectedUsername = trimToDefined(botUsername)?.toLowerCase();
  if (!expectedUsername) {
    return true;
  }
  return message.repliedToBotUsername?.toLowerCase() === expectedUsername;
}

function stripTelegramBotMention(text: string, botUsername?: string) {
  const mentionRegex = resolveTelegramMentionRegex(botUsername);
  if (!mentionRegex) {
    return text.trim();
  }
  return text.replace(mentionRegex, " ").replace(/\s+/g, " ").trim();
}

function ensureTelegramIntegration(state: BossState): TelegramIntegrationState {
  const integration = state.telegramIntegration;
  if (integration) {
    integration.groupProjectRoutes ??= [];
    return integration;
  }
  const next: TelegramIntegrationState = {
    enabled: false,
    mode: "webhook",
    dmPolicy: "allowlist",
    allowFrom: [],
    groupPolicy: "allowlist",
    groups: [],
    requireMentionInGroups: true,
    defaultProjectId: "master-agent",
    groupProjectRoutes: [],
    processedUpdateIds: [],
  };
  state.telegramIntegration = next;
  return next;
}

function getTelegramConfigView(integration: TelegramIntegrationState | undefined): TelegramGatewayView {
  const config = integration ?? {
    enabled: false,
    mode: "webhook",
    dmPolicy: "allowlist",
    allowFrom: [],
    groupPolicy: "allowlist",
    groups: [],
    requireMentionInGroups: true,
    defaultProjectId: "master-agent",
    groupProjectRoutes: [],
    processedUpdateIds: [],
  };
  return {
    enabled: config.enabled,
    mode: config.mode,
    botTokenConfigured: Boolean(trimToDefined(config.botToken)),
    botUsername: trimToDefined(config.botUsername),
    dmPolicy: config.dmPolicy,
    allowFrom: config.allowFrom,
    groupPolicy: config.groupPolicy,
    groups: config.groups,
    requireMentionInGroups: config.requireMentionInGroups,
    defaultProjectId: config.defaultProjectId,
    groupProjectRoutes: config.groupProjectRoutes ?? [],
    webhookSecretConfigured: Boolean(trimToDefined(config.webhookSecret)),
    webhookUrl: trimToDefined(config.webhookUrl),
    lastConfiguredAt: trimToDefined(config.lastConfiguredAt),
    lastConfiguredBy: trimToDefined(config.lastConfiguredBy),
    lastError: trimToDefined(config.lastError),
    processedUpdateCount: config.processedUpdateIds.length,
  };
}

function checkTelegramAccess(
  config: TelegramIntegrationState,
  message: NormalizedTelegramMessage,
): { ok: true } | { ok: false; message: string; status: number } {
  if (!config.enabled) {
    return { ok: false, message: "TELEGRAM_DISABLED", status: 403 };
  }
  if (message.chatType === "private") {
    if (config.dmPolicy === "disabled") {
      return { ok: false, message: "TELEGRAM_DM_DISABLED", status: 403 };
    }
    if (config.dmPolicy === "allowlist") {
      if (!message.senderId || !config.allowFrom.includes(message.senderId)) {
        return { ok: false, message: "TELEGRAM_SENDER_FORBIDDEN", status: 403 };
      }
    }
    return { ok: true };
  }

  if (config.groupPolicy === "disabled") {
    return { ok: false, message: "TELEGRAM_GROUP_DISABLED", status: 403 };
  }
  if (config.groupPolicy === "allowlist" && !config.groups.includes(message.chatId)) {
    return { ok: false, message: "TELEGRAM_GROUP_FORBIDDEN", status: 403 };
  }
  if (
    config.requireMentionInGroups &&
    !hasTelegramBotMention(message.text, config.botUsername) &&
    !isReplyToConfiguredTelegramBot(message, config.botUsername)
  ) {
    return { ok: false, message: "TELEGRAM_GROUP_MENTION_REQUIRED", status: 400 };
  }
  return { ok: true };
}

function buildTelegramSenderLabel(message: NormalizedTelegramMessage) {
  if (message.chatType === "private") {
    return `Telegram · ${message.senderName}`;
  }
  const groupLabel = message.chatTitle || message.chatId;
  return `Telegram · ${groupLabel} · ${message.senderName}`;
}

function resolveTelegramTargetProjectId(
  state: BossState,
  config: TelegramIntegrationState,
  message: NormalizedTelegramMessage,
) {
  const routes = config.groupProjectRoutes ?? [];
  const exactRoute = routes.find(
    (route) => route.chatId === message.chatId && route.threadId != null && route.threadId === message.threadId,
  );
  const chatRoute =
    exactRoute ??
    routes.find((route) => route.chatId === message.chatId && route.threadId == null);
  const requestedProjectId = chatRoute?.projectId || config.defaultProjectId || "master-agent";
  const projectExists = state.projects.some((project) => project.id === requestedProjectId);
  if (projectExists) {
    return requestedProjectId;
  }
  if (state.projects.some((project) => project.id === config.defaultProjectId)) {
    return config.defaultProjectId;
  }
  return "master-agent";
}

function markTelegramUpdateProcessed(state: BossState, updateId: number) {
  const integration = ensureTelegramIntegration(state);
  integration.processedUpdateIds = Array.from(new Set([...integration.processedUpdateIds, updateId]))
    .sort((left, right) => left - right)
    .slice(-256);
}

async function persistTelegramUpdateProcessed(updateId: number) {
  const state = await readState();
  markTelegramUpdateProcessed(state, updateId);
  await writeState(state);
}

function hasProcessedTelegramUpdate(state: BossState, updateId: number) {
  return ensureTelegramIntegration(state).processedUpdateIds.includes(updateId);
}

async function sendTelegramMessage(config: TelegramIntegrationState, target: ExternalReplyTarget, text: string) {
  const botToken = trimToDefined(config.botToken);
  if (!botToken) {
    throw new Error("TELEGRAM_BOT_TOKEN_REQUIRED");
  }
  const chunks = chunkTelegramText(text);
  for (const chunk of chunks) {
    const body: Record<string, unknown> = {
      chat_id: Number(target.chatId),
      text: chunk,
    };
    if (typeof target.messageId === "number") {
      body.reply_to_message_id = target.messageId;
    }
    if (typeof target.threadId === "number") {
      body.message_thread_id = target.threadId;
    }
    const response = await fetch(`${TELEGRAM_API_BASE}/bot${botToken}/sendMessage`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
      },
      body: JSON.stringify(body),
    });
    if (!response.ok) {
      throw new Error(`TELEGRAM_SEND_FAILED_${response.status}`);
    }
  }
}

function buildTelegramBridgeSession(): AuthSession {
  const now = new Date().toISOString();
  return {
    sessionId: "telegram-bridge-session",
    sessionToken: "telegram-bridge-session",
    restoreToken: "telegram-bridge-session",
    account: TELEGRAM_BRIDGE_ACCOUNT,
    role: "highest_admin" satisfies AuthRole,
    displayName: TELEGRAM_BRIDGE_LABEL,
    loginMethod: "password",
    createdAt: now,
    expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
    lastSeenAt: now,
  };
}

export async function handleTelegramWebhookRequest(params: { request: NextRequest }) {
  const state = await readState();
  const integration = ensureTelegramIntegration(state);
  const secret = trimToDefined(integration.webhookSecret);
  if (secret) {
    const received = trimToDefined(params.request.headers.get("x-telegram-bot-api-secret-token"));
    if (received !== secret) {
      return jsonNoStore({ ok: false, message: "TELEGRAM_WEBHOOK_SECRET_INVALID" }, { status: 401 });
    }
  }

  const update = (await params.request.json().catch(() => null)) as TelegramUpdate | null;
  const normalized = update ? normalizeTelegramUpdate(update) : null;
  if (!update || !normalized) {
    return jsonNoStore({ ok: true, delivery: "ignored" });
  }
  if (hasProcessedTelegramUpdate(state, normalized.updateId)) {
    return jsonNoStore({ ok: true, delivery: "duplicate" });
  }

  const access = checkTelegramAccess(integration, normalized);
  if (!access.ok) {
    return jsonNoStore({ ok: false, message: access.message }, { status: access.status });
  }

  const replyTarget: ExternalReplyTarget = {
    provider: "telegram",
    chatId: normalized.chatId,
    messageId: normalized.messageId,
    threadId: normalized.threadId,
    sessionKey: buildTelegramSessionKey(normalized),
  };
  const bridgeSession = buildTelegramBridgeSession();
  const bridgeAccount = state.user.account || bridgeSession.account;
  const projectId = resolveTelegramTargetProjectId(state, integration, normalized);
  const requestText =
    normalized.chatType === "private"
      ? normalized.text
      : stripTelegramBotMention(normalized.text, integration.botUsername);
  const localFastReply = await tryBuildLocalMasterAgentFastReply({
    requestText,
    requestedByAccount: bridgeSession.account,
    projectId,
    state,
  });

  if (localFastReply) {
    await appendProjectMessages({
      projectId,
      messages: [
        {
          senderLabel: buildTelegramSenderLabel(normalized),
          body: requestText,
          kind: "text",
        },
        {
          sender: "master",
          senderLabel: localFastReply.senderLabel,
          body: localFastReply.replyBody,
          kind: "text",
        },
      ],
    });
    await persistTelegramUpdateProcessed(normalized.updateId);
    await sendTelegramMessage(integration, replyTarget, localFastReply.replyBody);
    return jsonNoStore({ ok: true, delivery: "sent" });
  }

  const [message] = await appendProjectMessages({
    projectId,
    messages: [
      {
        senderLabel: buildTelegramSenderLabel(normalized),
        body: requestText,
        kind: "text",
      },
    ],
  });
  const reply = await replyToMasterAgentUserMessage({
    requestMessageId: message.id,
    requestText,
    requestedBy: buildTelegramSenderLabel(normalized),
    requestedByAccount: bridgeAccount,
    currentSessionExpiresAt: bridgeSession.expiresAt,
    projectId,
    mode: "smart",
    externalReplyTarget: replyTarget,
  });
  await persistTelegramUpdateProcessed(normalized.updateId);

  const replyState = "masterReplyState" in reply ? reply.masterReplyState : undefined;
  if (reply.ok && replyState === "completed" && "replyMessage" in reply && reply.replyMessage?.body) {
    await sendTelegramMessage(integration, replyTarget, reply.replyMessage.body);
    return jsonNoStore({ ok: true, delivery: "sent", taskId: "taskId" in reply ? reply.taskId : undefined });
  }

  await sendTelegramMessage(integration, replyTarget, "已收到，我先继续协调，整理好结果后会自动回到这里。");
  return jsonNoStore({ ok: true, delivery: "queued", taskId: "taskId" in reply ? reply.taskId : undefined });
}

export async function deliverTelegramReplyForCompletedTask(taskId: string) {
  const state = await readState();
  const integration = ensureTelegramIntegration(state);
  const task = state.masterAgentTasks.find((item) => item.taskId === taskId);
  if (!task?.externalReplyTarget || task.externalReplyTarget.provider !== "telegram") {
    return { delivered: false, reason: "NO_EXTERNAL_TARGET" as const };
  }
  if (!task.replyBody?.trim()) {
    return { delivered: false, reason: "NO_REPLY_BODY" as const };
  }
  if (task.externalReplyTarget.deliveredAt) {
    return { delivered: false, reason: "ALREADY_DELIVERED" as const };
  }

  try {
    await sendTelegramMessage(integration, task.externalReplyTarget, task.replyBody);
  } catch (error) {
    task.externalReplyTarget.deliveryError = error instanceof Error ? error.message : "TELEGRAM_DELIVERY_FAILED";
    await writeState(state);
    return { delivered: false, reason: "SEND_FAILED" as const };
  }

  task.externalReplyTarget.deliveredAt = new Date().toISOString();
  task.externalReplyTarget.deliveryError = undefined;
  await writeState(state);
  return { delivered: true as const };
}

export async function getTelegramIntegrationView() {
  const state = await readState();
  return getTelegramConfigView(state.telegramIntegration);
}

export async function saveTelegramIntegrationConfig(input: {
  enabled: boolean;
  mode?: "webhook" | "polling";
  botToken?: string;
  botUsername?: string;
  dmPolicy?: "allowlist" | "open" | "disabled";
  allowFrom?: string[];
  groupPolicy?: "allowlist" | "open" | "disabled";
  groups?: string[];
  requireMentionInGroups?: boolean;
  defaultProjectId?: string;
  groupProjectRoutes?: TelegramGroupProjectRoute[];
  webhookSecret?: string;
  webhookUrl?: string;
  configuredBy: string;
}) {
  const state = await readState();
  const integration = ensureTelegramIntegration(state);
  integration.enabled = input.enabled;
  integration.mode = input.mode ?? integration.mode;
  integration.botToken = trimToDefined(input.botToken) ?? integration.botToken;
  integration.botUsername = trimToDefined(input.botUsername);
  integration.dmPolicy = input.dmPolicy ?? integration.dmPolicy;
  integration.allowFrom = (input.allowFrom ?? integration.allowFrom).map((item) => item.trim()).filter(Boolean);
  integration.groupPolicy = input.groupPolicy ?? integration.groupPolicy;
  integration.groups = (input.groups ?? integration.groups).map((item) => item.trim()).filter(Boolean);
  integration.requireMentionInGroups =
    input.requireMentionInGroups ?? integration.requireMentionInGroups;
  integration.defaultProjectId = trimToDefined(input.defaultProjectId) ?? integration.defaultProjectId;
  integration.groupProjectRoutes = (input.groupProjectRoutes ?? integration.groupProjectRoutes)
    .map((route) => ({
      chatId: String(route.chatId ?? "").trim(),
      threadId: typeof route.threadId === "number" ? route.threadId : undefined,
      projectId: String(route.projectId ?? "").trim(),
      label: trimToDefined(route.label),
    }))
    .filter((route) => route.chatId && route.projectId);
  integration.webhookSecret = trimToDefined(input.webhookSecret) ?? integration.webhookSecret;
  integration.webhookUrl = trimToDefined(input.webhookUrl);
  integration.lastConfiguredAt = new Date().toISOString();
  integration.lastConfiguredBy = input.configuredBy;
  integration.lastError = undefined;
  await writeState(state);
  return getTelegramConfigView(integration);
}

export async function probeTelegramBot(config?: TelegramIntegrationState | null) {
  const integration = config ?? (await readState()).telegramIntegration;
  const botToken = trimToDefined(integration?.botToken);
  if (!botToken) {
    throw new Error("TELEGRAM_BOT_TOKEN_REQUIRED");
  }
  const response = await fetch(`${TELEGRAM_API_BASE}/bot${botToken}/getMe`);
  if (!response.ok) {
    throw new Error(`TELEGRAM_GET_ME_FAILED_${response.status}`);
  }
  const payload = (await response.json()) as { ok?: boolean; result?: { username?: string } };
  return {
    ok: payload.ok === true,
    username: trimToDefined(payload.result?.username),
  };
}

export async function syncTelegramWebhookRegistration(config?: TelegramIntegrationState | null) {
  const integration = config ?? (await readState()).telegramIntegration;
  const botToken = trimToDefined(integration?.botToken);
  if (!integration?.enabled || integration.mode === "polling") {
    if (!botToken) {
      return { ok: true as const, action: "skipped" as const, reason: "BOT_TOKEN_NOT_CONFIGURED" };
    }
    const response = await fetch(`${TELEGRAM_API_BASE}/bot${botToken}/deleteWebhook`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
      },
      body: JSON.stringify({ drop_pending_updates: false }),
    });
    if (!response.ok) {
      throw new Error(`TELEGRAM_DELETE_WEBHOOK_FAILED_${response.status}`);
    }
    return { ok: true as const, action: "delete_webhook" as const };
  }

  if (!botToken) {
    return { ok: true as const, action: "skipped" as const, reason: "BOT_TOKEN_NOT_CONFIGURED" };
  }
  const webhookUrl = trimToDefined(integration.webhookUrl);
  if (!webhookUrl) {
    return { ok: true as const, action: "skipped" as const, reason: "WEBHOOK_URL_NOT_CONFIGURED" };
  }

  const body: Record<string, unknown> = {
    url: webhookUrl,
    drop_pending_updates: false,
  };
  const secret = trimToDefined(integration.webhookSecret);
  if (secret) {
    body.secret_token = secret;
  }
  const response = await fetch(`${TELEGRAM_API_BASE}/bot${botToken}/setWebhook`, {
    method: "POST",
    headers: {
      "content-type": "application/json",
    },
    body: JSON.stringify(body),
  });
  if (!response.ok) {
    throw new Error(`TELEGRAM_SET_WEBHOOK_FAILED_${response.status}`);
  }
  return { ok: true as const, action: "set_webhook" as const };
}

export async function getAuthorizedTelegramConfigSession(request: NextRequest) {
  const session = await getAuthSession(request.cookies.get("boss_session")?.value);
  if (!session || session.role !== "highest_admin") {
    return null;
  }
  return session;
}