import { ChannelDeliveryError } from "@vellumai/gateway-client/http-delivery";

import { getLogger } from "../../../util/logger.js";
import type { ChannelTransport } from "../channel-transport.js";
import {
  sendSlackAssistantThreadStatus,
  sendSlackAttachments,
  sendSlackReaction,
  sendSlackReply,
  sendSlackStreamOp,
  updateSlackMessage,
} from "./send.js";

const log = getLogger("slack-transport");

export const slackTransport: ChannelTransport = {
  channel: "slack",

  async deliver(ctx, payload) {
    const { chatId, text, attachments } = payload;
    const threadTs = ctx.params.threadTs;

    let sentTs: string | undefined;
    if (text) {
      const result = await sendSlackReply(chatId, text, {
        threadTs,
        approval: payload.approval,
        useBlocks: payload.useBlocks,
        audience: payload.audience,
      });
      sentTs = result.ts;
    } else if (payload.approval) {
      const result = await sendSlackReply(
        chatId,
        payload.approval.plainTextFallback || "Approval required",
        { threadTs, approval: payload.approval },
      );
      sentTs = result.ts;
    }

    if (attachments && attachments.length > 0) {
      const result = await sendSlackAttachments(chatId, attachments, threadTs);
      if (result.allFailed && !text) {
        throw new ChannelDeliveryError(
          502,
          `All ${result.failureCount} attachments failed to deliver`,
        );
      }
    }

    log.info({ chatId, hasText: !!text }, "Slack reply delivered (direct)");
    return { ok: true, ts: sentTs };
  },

  async edit(_ctx, target) {
    const result = await updateSlackMessage(
      target.chatId,
      target.messageId,
      target.text,
      { blocks: target.blocks, useBlocks: target.useBlocks },
    );
    return { ok: true, ts: result.ts };
  },

  async react(_ctx, target) {
    await sendSlackReaction(
      target.chatId,
      target.emoji,
      target.messageId,
      target.action,
    );
    return { ok: true };
  },

  async setThreadStatus(_ctx, status) {
    await sendSlackAssistantThreadStatus(
      status.chatId,
      status.threadTs,
      status.status,
      status.loadingMessages,
    );
    return { ok: true };
  },

  async streamReply(_ctx, chatId, op) {
    return sendSlackStreamOp(chatId, op);
  },
};