import { readBody } from "h3";
import { getAuthContext } from "../../../utils/auth";
import { prisma } from "../../../utils/prisma";

type BackendGraphqlResponse<T> = {
  data?: T;
  errors?: Array<{ message?: string }>;
};

function asString(value: unknown) {
  if (typeof value !== "string") return null;
  const v = value.trim();
  return v || null;
}

async function requestTelegramOutbound(input: {
  omniMessageId: string;
  chatId: string;
  text: string;
  businessConnectionId?: string | null;
}) {
  type Out = {
    requestTelegramOutbound: {
      ok: boolean;
      message: string;
      runId?: string | null;
    };
  };

  const url = asString(process.env.BACKEND_GRAPHQL_URL);
  if (!url) throw new Error("BACKEND_GRAPHQL_URL is required");

  const headers: Record<string, string> = {
    "content-type": "application/json",
  };
  const secret = asString(process.env.BACKEND_GRAPHQL_SHARED_SECRET);
  if (secret) {
    headers["x-graphql-secret"] = secret;
  }

  const query = `mutation RequestTelegramOutbound($input: TelegramOutboundTaskInput!) {
    requestTelegramOutbound(input: $input) {
      ok
      message
      runId
    }
  }`;

  const response = await fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify({
      operationName: "RequestTelegramOutbound",
      query,
      variables: { input },
    }),
  });

  const payload = (await response.json()) as BackendGraphqlResponse<Out>;
  if (!response.ok || payload.errors?.length) {
    const message =
      payload.errors?.map((error) => error.message).filter(Boolean).join("; ") || `HTTP ${response.status}`;
    throw new Error(message);
  }

  const result = payload.data?.requestTelegramOutbound;
  if (!result?.ok) {
    throw new Error(result?.message || "requestTelegramOutbound failed");
  }

  return result;
}

export default defineEventHandler(async (event) => {
  const auth = await getAuthContext(event);
  const body = await readBody<{ omniMessageId?: string }>(event);

  const omniMessageId = String(body?.omniMessageId ?? "").trim();
  if (!omniMessageId) {
    throw createError({ statusCode: 400, statusMessage: "omniMessageId is required" });
  }

  const msg = await prisma.omniMessage.findFirst({
    where: { id: omniMessageId, teamId: auth.teamId, channel: "TELEGRAM", direction: "OUT" },
    select: {
      id: true,
      text: true,
      thread: { select: { externalChatId: true, businessConnectionId: true } },
    },
  });
  if (!msg) {
    throw createError({ statusCode: 404, statusMessage: "telegram outbound message not found" });
  }

  const result = await requestTelegramOutbound({
    omniMessageId: msg.id,
    chatId: msg.thread.externalChatId,
    text: msg.text,
    businessConnectionId: msg.thread.businessConnectionId ?? null,
  });

  return {
    ok: true,
    runId: result.runId ?? null,
    omniMessageId,
  };
});