ai-chatbot/lib/agents/psd-render-service.ts

import "server-only";

import { readAgentPsdFonts } from "@/lib/agents/psd-font-settings";
import { normalizeAgentPsdImagePlacement } from "@/lib/agents/psd-image-placement";
import {
  type AgentPsdTemplateRenderRequest,
} from "@/lib/agents/psd-render-task-contract";
import {
  type AgentPsdTemplateRenderResult,
  getAgentPsdTemplateRuntimeIssue,
  getEditableAgentPsdTemplateLayers,
  isAgentPsdImageLayerSlot,
  isAgentPsdTemplateReady,
  isAgentPsdTemplateRuntimeReady,
  isAgentPsdTextLayerSlot,
} from "@/lib/agents/psd-template-config";
import { renderAgentPsdTemplate } from "@/lib/agents/psd-template-renderer";
import { repairAgentPsdTemplateFontBindings } from "@/lib/agents/psd-template-repair";
import { readAgentPsdTemplates } from "@/lib/agents/psd-template-settings";
import { normalizeHexColor } from "@/lib/agents/psd-text-layout";

export async function executeAgentPsdTemplateRenderRequest(
  body: AgentPsdTemplateRenderRequest
): Promise<AgentPsdTemplateRenderResult> {
  const templates = await readAgentPsdTemplates();
  const template = templates.find(
    (entry) =>
      entry.id === body.templateId &&
      entry.status === "active" &&
      isAgentPsdTemplateReady(entry)
  );

  if (!template) {
    throw new Error("PSD 模板不存在或未启用");
  }

  const fonts = await readAgentPsdFonts();
  const resolvedTemplate = repairAgentPsdTemplateFontBindings(template, fonts);
  if (!isAgentPsdTemplateRuntimeReady(resolvedTemplate)) {
    throw new Error(
      getAgentPsdTemplateRuntimeIssue(resolvedTemplate) ||
        "PSD 模板资源不完整，请在后台重新解析后再导出"
    );
  }

  const editableLayers = getEditableAgentPsdTemplateLayers(resolvedTemplate);
  if (editableLayers.length === 0) {
    throw new Error("当前模板未配置可编辑图层");
  }
  const hiddenLayerIdSet = new Set(
    (body.hiddenLayerIds || []).map((layerId) => String(layerId || "").trim()).filter(Boolean)
  );

  const fontMap = new Map(fonts.map((font) => [font.id, font]));
  const missingFontLayer = editableLayers.find(
    (layer) =>
      !hiddenLayerIdSet.has(layer.id) &&
      isAgentPsdTextLayerSlot(layer) &&
      layer.fontId &&
      !fontMap.has(layer.fontId)
  );
  if (missingFontLayer) {
    throw new Error(`文字图层“${missingFontLayer.layerName}”引用的字体已不存在`);
  }

  const imageAssignments: Record<string, string> = {};
  const imagePlacements: Record<
    string,
    ReturnType<typeof normalizeAgentPsdImagePlacement>
  > = {};
  const textAssignments: Record<string, string> = {};
  const textColorAssignments: Record<string, string> = {};

  for (const layer of editableLayers) {
    if (hiddenLayerIdSet.has(layer.id)) {
      continue;
    }

    if (isAgentPsdImageLayerSlot(layer)) {
      const explicitUrl = String(body.imageAssignments[layer.id] || "").trim();
      if (explicitUrl) {
        imageAssignments[layer.id] = explicitUrl;
        imagePlacements[layer.id] = normalizeAgentPsdImagePlacement(
          body.imagePlacements[layer.id]
        );
        continue;
      }

      if (layer.isDefaultResultSource && body.sourceImageUrl?.trim()) {
        imageAssignments[layer.id] = body.sourceImageUrl.trim();
        imagePlacements[layer.id] = normalizeAgentPsdImagePlacement(
          body.imagePlacements[layer.id]
        );
      }
    }

    if (isAgentPsdTextLayerSlot(layer)) {
      if (
        Object.prototype.hasOwnProperty.call(body.textAssignments, layer.id)
      ) {
        textAssignments[layer.id] = String(
          body.textAssignments[layer.id] ?? ""
        ).trim();
      }
      textColorAssignments[layer.id] = normalizeHexColor(
        body.textColorAssignments[layer.id] || layer.textColor,
        layer.textColor
      );
    }
  }

  const missingRequiredLayer = editableLayers.find(
    (layer) =>
      !hiddenLayerIdSet.has(layer.id) &&
      layer.isRequired &&
      (isAgentPsdImageLayerSlot(layer)
        ? !imageAssignments[layer.id]
        : !Object.prototype.hasOwnProperty.call(textAssignments, layer.id) &&
          !String(layer.defaultText || "").trim())
  );
  if (missingRequiredLayer) {
    throw new Error(`缺少必传素材：${missingRequiredLayer.layerName}`);
  }

  const uploaded = await renderAgentPsdTemplate({
    template: resolvedTemplate,
    hiddenLayerIds: Array.from(hiddenLayerIdSet),
    imageAssignments,
    imagePlacements,
    textAssignments,
    textColorAssignments,
    fonts,
  });

  return {
    url: uploaded.url,
    pathname: uploaded.pathname,
    contentType: uploaded.contentType,
  };
}