import { NextResponse } from "next/server";
import { requireAgentWorkflowAdmin } from "@/lib/middleware/admin";
import { findBestMatchingPsdFont } from "@/lib/agents/psd-font-matching";
import { readAgentPsdFonts } from "@/lib/agents/psd-font-settings";
import {
  type AgentPsdTemplateLayerSlot,
  type AgentPsdTemplateMutationResponse,
} from "@/lib/agents/psd-template-config";
import {
  type ParsedPsdTemplateLayer,
  parsePsdTemplateFile,
} from "@/lib/agents/psd-template-parser";
import { pickPrimaryPsdImageLayerId } from "@/lib/agents/psd-template-image-slot-selection";
import { schedulePsdTemplateAssetBackfill } from "@/lib/agents/psd-template-asset-backfill";
import {
  AGENT_PSD_TEMPLATE_INCOMPATIBLE_PSB_MESSAGE,
  AGENT_PSD_TEMPLATE_INVALID_FORMAT_MESSAGE,
  assertSupportedAgentPsdTemplateFile,
  type AgentPsdTemplateFileInspection,
} from "@/lib/agents/psd-template-format";
import {
  createAgentPsdTemplateParseHeartbeat,
  updateAgentPsdTemplateById,
  updateAgentPsdTemplateParseProgress,
} from "@/lib/agents/psd-template-progress";
import {
  cacheAgentPsdSourceLocally,
  hasAgentPsdLocalCache,
  readAgentPsdSourceFromLocalCache,
} from "@/lib/agents/psd-local-cache";
import { readAgentPsdTemplates } from "@/lib/agents/psd-template-settings";
import { failTimedOutAgentPsdTemplates } from "@/lib/agents/psd-template-timeout";
import { uploadFile } from "@/lib/storage/service";

export const runtime = "nodejs";
export const maxDuration = 1800;

function jsonError(status: number, error: string) {
  const payload: AgentPsdTemplateMutationResponse = {
    success: false,
    error,
  };
  return NextResponse.json(payload, { status });
}

function toArrayBuffer(buffer: Buffer) {
  return buffer.buffer.slice(
    buffer.byteOffset,
    buffer.byteOffset + buffer.byteLength
  ) as ArrayBuffer;
}

function getErrorMessage(error: unknown) {
  if (error instanceof Error && error.message.trim()) {
    return error.message.trim();
  }
  return "PSD 解析失败";
}

function getPsdTemplateParseErrorMessage(params: {
  error: unknown;
  fileInspection?: AgentPsdTemplateFileInspection;
}) {
  const message = getErrorMessage(params.error);

  if (
    params.fileInspection?.format === "psb" &&
    /invalid signature/i.test(message)
  ) {
    return AGENT_PSD_TEMPLATE_INCOMPATIBLE_PSB_MESSAGE;
  }

  return message;
}

function pickPrimaryImageLayerId(params: {
  parsedLayers: Awaited<ReturnType<typeof parsePsdTemplateFile>>["layers"];
  canvasWidth: number;
  canvasHeight: number;
}) {
  const { parsedLayers, canvasWidth, canvasHeight } = params;
  return pickPrimaryPsdImageLayerId({
    imageLayers: parsedLayers.filter((layer) => layer.slotType === "image"),
    canvasWidth,
    canvasHeight,
  });
}

function shouldAutoEditableTextLayer(
  layer: ParsedPsdTemplateLayer
) {
  const text = String(layer.defaultText || "").replace(/\s+/g, "");
  if (!text) {
    return false;
  }

  return (
    layer.width >= 80 ||
    layer.height >= 30 ||
    text.length >= 4 ||
    /[A-Za-z0-9]{3,}/.test(text)
  );
}

function buildInitialTemplateLayers(params: {
  parsedLayers: Awaited<ReturnType<typeof parsePsdTemplateFile>>["layers"];
  fonts: Awaited<ReturnType<typeof readAgentPsdFonts>>;
  canvasWidth: number;
  canvasHeight: number;
}) {
  const { parsedLayers, fonts, canvasWidth, canvasHeight } = params;
  const primaryImageLayerId = pickPrimaryImageLayerId({
    parsedLayers,
    canvasWidth,
    canvasHeight,
  });

  return parsedLayers.map((layer): AgentPsdTemplateLayerSlot => {
    if (layer.slotType === "text") {
      const matchedFont = findBestMatchingPsdFont({
        detectedFontNames: layer.detectedFontNames || [],
        fonts,
      });
      const autoBoundFont = matchedFont?.confidence === "high" ? matchedFont.font : undefined;
      const isEditable = shouldAutoEditableTextLayer(layer);

      return {
        ...layer,
        slotType: "text",
        styleSource: "auto",
        isEditable,
        isRequired: false,
        placeholder: layer.defaultText || layer.layerName,
        detectedFontName: layer.detectedFontName,
        detectedFontNames: layer.detectedFontNames,
        fontId: autoBoundFont?.id,
        fontFamily:
          autoBoundFont?.family ||
          layer.detectedFontNames?.[0] ||
          layer.detectedFontName,
        fontLabel:
          autoBoundFont?.name ||
          layer.detectedFontNames?.[0] ||
          layer.detectedFontName,
        fontFileUrl: autoBoundFont?.fileUrl,
        fontContentType: autoBoundFont?.contentType,
        fontSize: Math.max(
          10,
          Math.round(
            Number(
              layer.detectedFontSize ||
                Math.max(16, Math.min(layer.height, Math.round(layer.height * 0.78)))
            )
          )
        ),
        lineHeight:
          Number.isFinite(Number(layer.detectedLineHeight)) && Number(layer.detectedLineHeight) > 0
            ? Number(layer.detectedLineHeight)
            : 1.2,
        letterSpacing: Number.isFinite(Number(layer.detectedLetterSpacing))
          ? Number(layer.detectedLetterSpacing)
          : 0,
        fontWeight: 500,
        textColor: layer.detectedTextColor || "#111111",
        textAlign: "left",
        paddingX: 0,
        paddingY: 0,
        maxLines: 4,
      };
    }

    const isPrimaryImageLayer = layer.id === primaryImageLayerId;
    return {
      ...layer,
      slotType: "image",
      isEditable: isPrimaryImageLayer,
      isRequired: false,
      isDefaultResultSource: isPrimaryImageLayer,
      allowUserUploadOverride: isPrimaryImageLayer,
      replaceMode: "cover",
    };
  });
}

async function updateParseProgress(params: {
  templateId: string;
  updatedBy: string;
  progress: number;
  stage: string;
  error?: string;
  restart?: boolean;
}) {
  return updateAgentPsdTemplateParseProgress(params);
}

export async function POST(
  _request: Request,
  context: { params: Promise<{ id: string }> }
) {
  const session = await requireAgentWorkflowAdmin().catch(() => null);
  if (!session?.user?.id) {
    return jsonError(401, "未登录");
  }

  const { id } = await context.params;
  let fileInspection: AgentPsdTemplateFileInspection | undefined;
  let latestProgress = {
    progress: 0,
    stage: "准备解析 PSD",
    error: undefined as string | undefined,
  };

  try {
    const { templates, timedOutTemplates } = await failTimedOutAgentPsdTemplates({
      updatedBy: session.user.id,
    });
    if (timedOutTemplates.length > 0) {
      console.warn("[PSD Templates][Admin] cleared timed out parsing templates before parse:", {
        requestedTemplateId: id,
        count: timedOutTemplates.length,
        templateIds: timedOutTemplates.map((template) => template.id),
      });
    }

    const currentTemplate = templates.find((entry) => entry.id === id);

    if (!currentTemplate) {
      return jsonError(404, "未找到 PSD 模板");
    }

    if (currentTemplate.parseStatus === "processing") {
      return jsonError(409, "该模板正在解析中，请稍后刷新");
    }

    latestProgress = {
      progress: 5,
      stage: "准备解析 PSD",
      error: undefined,
    };
    const setParseProgress = async (progress: number, stage: string, error?: string) => {
      latestProgress = {
        progress,
        stage,
        error,
      };
      return updateParseProgress({
        templateId: id,
        updatedBy: session.user.id,
        progress,
        stage,
        error,
      });
    };

    await updateParseProgress({
      templateId: id,
      updatedBy: session.user.id,
      ...latestProgress,
      error: undefined,
      restart: true,
    });
    const heartbeat = createAgentPsdTemplateParseHeartbeat({
      templateId: id,
      updatedBy: session.user.id,
      getSnapshot: () => latestProgress,
    });

    try {
      let fileBuffer: ArrayBuffer;
      if (
        await hasAgentPsdLocalCache({
          templateId: id,
          fileName: currentTemplate.fileName,
        })
      ) {
        await setParseProgress(18, "正在读取服务器本地 PSD 缓存");
        const localBuffer = await readAgentPsdSourceFromLocalCache({
          templateId: id,
          fileName: currentTemplate.fileName,
        });
        fileBuffer = localBuffer.buffer.slice(
          localBuffer.byteOffset,
          localBuffer.byteOffset + localBuffer.byteLength
        ) as ArrayBuffer;
      } else {
        const response = await fetch(currentTemplate.fileUrl, {
          cache: "no-store",
          signal: AbortSignal.timeout(60_000),
        });

        if (!response.ok) {
          throw new Error(`PSD 文件下载失败 (${response.status})`);
        }

        await setParseProgress(18, "正在下载并写入服务器本地 PSD 缓存");

        fileBuffer = await response.arrayBuffer();
        await cacheAgentPsdSourceLocally({
          templateId: id,
          fileName: currentTemplate.fileName,
          buffer: fileBuffer,
        }).catch((error) => {
          console.warn("[PSD Templates][Admin] failed to cache PSD source locally:", {
            templateId: id,
            error,
          });
        });
      }

      await setParseProgress(22, "正在校验 PSD 文件格式");
      fileInspection = assertSupportedAgentPsdTemplateFile(fileBuffer);

      await setParseProgress(24, "正在解析 PSD 图层结构与预览");
      const parsedTemplate = await parsePsdTemplateFile(fileBuffer, {
        onProgress: async (event) => {
          await setParseProgress(event.progress, event.stage);
        },
      });

      if (parsedTemplate.layers.length === 0) {
        throw new Error("PSD 中未识别到可配置图层");
      }

      await setParseProgress(42, "正在上传模板预览");

      const uploadedPreview = await uploadFile(
        `agent-psd-preview-${id}-${Date.now()}.png`,
        toArrayBuffer(parsedTemplate.previewBuffer)
      );

      await setParseProgress(58, "正在匹配字体与初始化图层");

      const fonts = await readAgentPsdFonts().catch(() => []);
      const initialLayers = buildInitialTemplateLayers({
        parsedLayers: parsedTemplate.layers,
        fonts,
        canvasWidth: parsedTemplate.width,
        canvasHeight: parsedTemplate.height,
      });

      heartbeat.stop();
      const updatedTemplate = await updateAgentPsdTemplateById({
        templateId: id,
        updatedBy: session.user.id,
        updater: (template) => {
          const now = new Date().toISOString();
          return {
            ...template,
            previewUrl: uploadedPreview.url,
            previewPath: uploadedPreview.pathname,
            width: parsedTemplate.width,
            height: parsedTemplate.height,
            layerCount: parsedTemplate.layers.length,
            layers: initialLayers,
            parseStatus: "processing",
            parseProgress: 48,
            parseStage: "快速解析完成，正在后台补全图层资源和模板底图",
            parseError: undefined,
            parseHeartbeatAt: now,
            updatedAt: now,
          };
        },
      });

      if (!updatedTemplate) {
        return jsonError(404, "未找到 PSD 模板");
      }

      schedulePsdTemplateAssetBackfill({
        templateId: id,
        updatedBy: session.user.id,
      });

      return NextResponse.json({
        success: true,
        template: updatedTemplate,
      } satisfies AgentPsdTemplateMutationResponse);
    } catch (error) {
      heartbeat.stop();
      throw error;
    }
  } catch (error) {
    const message = getPsdTemplateParseErrorMessage({
      error,
      fileInspection,
    });
    const existingTemplate = (await readAgentPsdTemplates()).find((entry) => entry.id === id);

    if (existingTemplate) {
      const hasUsablePreviousParse =
        existingTemplate.layers.length > 0 &&
        existingTemplate.width > 1 &&
        existingTemplate.height > 1 &&
        Boolean(existingTemplate.previewUrl);
      const fallbackStatus = hasUsablePreviousParse ? "completed" : "failed";

      await updateAgentPsdTemplateById({
        templateId: id,
        updatedBy: session.user.id,
        updater: (template) => ({
          ...template,
          parseStatus: fallbackStatus,
          parseProgress:
            fallbackStatus === "completed"
              ? 100
              : Math.max(0, Math.round(Number(latestProgress.progress || 0))),
          parseStage:
            fallbackStatus === "completed"
              ? "沿用上次成功解析结果"
              : latestProgress.stage || "PSD 解析失败",
          parseError:
            fallbackStatus === "completed"
              ? `重新解析失败：${message}`
              : message,
          updatedAt: new Date().toISOString(),
        }),
      }).catch(() => undefined);
    }

    console.error("[PSD Templates][Admin] parse failed:", {
      templateId: id,
      fileName: existingTemplate?.fileName,
      progress: latestProgress.progress,
      stage: latestProgress.stage,
      fileFormat: fileInspection?.format,
      error,
    });
    return jsonError(
      message === AGENT_PSD_TEMPLATE_INCOMPATIBLE_PSB_MESSAGE ||
        message === AGENT_PSD_TEMPLATE_INVALID_FORMAT_MESSAGE
        ? 400
        : 502,
      message
    );
  }
}