import { and, eq } from "drizzle-orm";
import { NextResponse } from "next/server";
import { auth } from "@/app/(auth)/auth";
import { db } from "@/lib/db";
import { model3dAsset } from "@/lib/db/schema";
import { resolveThreeDModelAliasId } from "@/lib/model3d/model-alias-config";
import { getThreeDModelAliasConfigForRuntime } from "@/lib/model3d/model-alias-config-server";
import { createLogger } from "@/lib/observability/logger";
import { uploadFile } from "@/lib/storage/service";
import {
  isWorldLabsExternalTaskApi,
  WORLDLABS_EXTERNAL_TASK_MODEL,
  WorldLabsApiError,
  worldLabsRequest,
} from "@/lib/worldlabs/client";
import { getWorldLabsProviderConfig } from "@/lib/worldlabs/server";
import type {
  WorldLabsExternalTaskResponse,
  WorldLabsExternalTaskResultData,
  WorldLabsOperation,
  WorldLabsWorld,
  WorldLabsWorldAssets,
} from "@/lib/worldlabs/types";

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

const logger = createLogger("world-labs-task-status");
const WORLDLABS_TASK_STATUS_TIMEOUT_MS =
  Number.parseInt(String(process.env.WORLDLABS_TASK_STATUS_TIMEOUT_MS || "").trim(), 10) ||
  180_000;

function resolveWorldLabsStatusTimeoutMs() {
  if (!Number.isFinite(WORLDLABS_TASK_STATUS_TIMEOUT_MS)) return 180_000;
  if (WORLDLABS_TASK_STATUS_TIMEOUT_MS <= 0) return 180_000;
  return WORLDLABS_TASK_STATUS_TIMEOUT_MS;
}

type ArchiveCacheItem = {
  sourceUrl: string;
  archivedUrl: string;
};

type ArchiveValidationKind = "spz" | "glb";

function getArchiveCache() {
  const globalState = globalThis as any;
  if (!globalState.__worldLabsAssetArchiveCache) {
    globalState.__worldLabsAssetArchiveCache = new Map<string, ArchiveCacheItem>();
  }
  return globalState.__worldLabsAssetArchiveCache as Map<string, ArchiveCacheItem>;
}

function getArchiveInflight() {
  const globalState = globalThis as any;
  if (!globalState.__worldLabsAssetArchiveInflight) {
    globalState.__worldLabsAssetArchiveInflight = new Map<string, Promise<string | null>>();
  }
  return globalState.__worldLabsAssetArchiveInflight as Map<string, Promise<string | null>>;
}

function isLikelyArchivedStorageUrl(parsed: URL) {
  const hostname = parsed.hostname.toLowerCase();
  return (
    hostname.includes("blob.vercel-storage.com") ||
    hostname.includes("s3.1080p.hk") ||
    hostname.includes("img.yydd.ai")
  );
}

function shouldArchiveRemoteAssetUrl(sourceUrl?: string | null) {
  const raw = String(sourceUrl || "").trim();
  if (!raw) return false;
  try {
    const parsed = new URL(raw);
    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return false;
    return !isLikelyArchivedStorageUrl(parsed);
  } catch {
    return false;
  }
}

function resolveExtensionFromContentType(contentType: string | null) {
  const normalized = String(contentType || "").toLowerCase().split(";")[0]?.trim() || "";
  const map: Record<string, string> = {
    "image/jpeg": "jpg",
    "image/png": "png",
    "image/webp": "webp",
    "image/gif": "gif",
    "model/gltf-binary": "glb",
    "model/gltf+json": "gltf",
    "model/stl": "stl",
    "model/3mf": "3mf",
    "model/vnd.usdz+zip": "usdz",
    "application/zip": "zip",
    "application/json": "json",
  };
  return map[normalized] || "";
}

function resolveRemoteFileExtension(url: string, fallback: string, contentType?: string | null) {
  const contentTypeExtension = resolveExtensionFromContentType(contentType || null);
  if (contentTypeExtension) return contentTypeExtension;

  try {
    const parsed = new URL(url);
    const pathname = parsed.pathname.toLowerCase();
    const ext = pathname.split(".").pop() || "";
    const allowed = new Set([
      "glb",
      "gltf",
      "usdz",
      "fbx",
      "obj",
      "stl",
      "3mf",
      "ply",
      "spz",
      "splat",
      "ksplat",
      "zip",
      "world",
      "json",
      "jpg",
      "jpeg",
      "png",
      "webp",
      "gif",
    ]);
    return allowed.has(ext) ? ext : fallback;
  } catch {
    return fallback;
  }
}

function hasSpzMagic(bytes: Uint8Array) {
  if (bytes.length < 4) return false;
  const hasNgspHeader =
    bytes[0] === 0x4e &&
    bytes[1] === 0x47 &&
    bytes[2] === 0x53 &&
    bytes[3] === 0x50;
  const hasLegacyGzipHeader = bytes[0] === 0x1f && bytes[1] === 0x8b;
  return hasNgspHeader || hasLegacyGzipHeader;
}

function hasGlbMagic(bytes: Uint8Array) {
  return (
    bytes.length >= 12 &&
    bytes[0] === 0x67 &&
    bytes[1] === 0x6c &&
    bytes[2] === 0x54 &&
    bytes[3] === 0x46
  );
}

function looksLikeTextErrorPayload(bytes: Uint8Array) {
  const head = bytes.slice(0, Math.min(bytes.length, 64));
  const text = new TextDecoder("utf-8", { fatal: false }).decode(head).trimStart();
  return text.startsWith("<") || text.startsWith("{") || text.startsWith("[");
}

function assertArchivedAssetBuffer(params: {
  buffer: ArrayBuffer;
  contentType?: string | null;
  validateAs?: ArchiveValidationKind;
}) {
  const bytes = new Uint8Array(params.buffer);
  if (bytes.byteLength <= 0) {
    throw new Error("World Labs 资源文件为空");
  }

  if (!params.validateAs) return;

  const contentType = String(params.contentType || "").toLowerCase();
  if (
    /\btext\/html\b/.test(contentType) ||
    /\bapplication\/json\b/.test(contentType) ||
    looksLikeTextErrorPayload(bytes)
  ) {
    throw new Error(`World Labs ${params.validateAs.toUpperCase()} 资源返回了非二进制内容`);
  }

  if (params.validateAs === "spz" && !hasSpzMagic(bytes)) {
    throw new Error("World Labs SPZ 资源头无效，已拒绝写入成功资产");
  }

  if (params.validateAs === "glb" && !hasGlbMagic(bytes)) {
    throw new Error("World Labs GLB 资源头无效，已拒绝写入模型资产");
  }
}

async function verifyArchivedAssetUpload(params: {
  url: string;
  expectedBytes: number;
  validateAs?: ArchiveValidationKind;
}) {
  const headResponse = await fetch(params.url, {
    method: "HEAD",
    cache: "no-store",
  });
  if (!headResponse.ok) {
    throw new Error(`归档文件校验失败（HTTP ${headResponse.status}）`);
  }

  const archivedLength = Number(headResponse.headers.get("content-length"));
  if (
    Number.isFinite(archivedLength) &&
    archivedLength > 0 &&
    archivedLength !== params.expectedBytes
  ) {
    throw new Error(
      `归档文件大小不一致（源文件 ${params.expectedBytes}，归档文件 ${archivedLength}）`
    );
  }

  if (!params.validateAs) return;

  const rangeResponse = await fetch(params.url, {
    method: "GET",
    headers: { Range: "bytes=0-63" },
    cache: "no-store",
  });
  if (!rangeResponse.ok) {
    throw new Error(`归档文件头校验失败（HTTP ${rangeResponse.status}）`);
  }
  const headerBuffer = await rangeResponse.arrayBuffer();
  assertArchivedAssetBuffer({
    buffer: headerBuffer,
    contentType: rangeResponse.headers.get("content-type"),
    validateAs: params.validateAs,
  });
}

async function archiveRemoteAssetIfNeeded(params: {
  cacheKey: string;
  sourceUrl?: string | null;
  filenamePrefix: string;
  fallbackExtension: string;
  skipHtml?: boolean;
  validateAs?: ArchiveValidationKind;
}) {
  const sourceUrl = String(params.sourceUrl || "").trim();
  if (!shouldArchiveRemoteAssetUrl(sourceUrl)) return sourceUrl || null;

  const cache = getArchiveCache();
  const cached = cache.get(params.cacheKey);
  if (cached && cached.sourceUrl === sourceUrl) {
    return cached.archivedUrl;
  }

  const inflight = getArchiveInflight();
  const existingTask = inflight.get(params.cacheKey);
  if (existingTask) {
    return existingTask;
  }

  const archiveTask = (async () => {
    try {
      const upstream = await fetch(sourceUrl, {
        method: "GET",
        headers: {
          "User-Agent": "AI-Chatbot-WorldLabs-Archiver/1.0",
        },
        cache: "no-store",
      });
      if (!upstream.ok) {
        throw new Error(`下载 World Labs 资源失败（HTTP ${upstream.status}）`);
      }

      const contentType = upstream.headers.get("content-type");
      if (params.skipHtml && /\btext\/html\b/i.test(String(contentType || ""))) {
        logger.warn("archive skipped html viewer", {
          cacheKey: params.cacheKey,
          sourceUrl,
        });
        return null;
      }

      const assetBuffer = await upstream.arrayBuffer();
      assertArchivedAssetBuffer({
        buffer: assetBuffer,
        contentType,
        validateAs: params.validateAs,
      });

      const ext = params.validateAs || resolveRemoteFileExtension(
        sourceUrl,
        params.fallbackExtension,
        contentType
      );
      const filename = `${params.filenamePrefix}.${ext}`;
      const uploaded = await uploadFile(filename, assetBuffer);
      await verifyArchivedAssetUpload({
        url: uploaded.url,
        expectedBytes: assetBuffer.byteLength,
        validateAs: params.validateAs,
      });
      cache.set(params.cacheKey, {
        sourceUrl,
        archivedUrl: uploaded.url,
      });
      return uploaded.url;
    } catch (error) {
      logger.warn("archive failed", {
        cacheKey: params.cacheKey,
        sourceUrl,
        error,
      });
      return null;
    } finally {
      inflight.delete(params.cacheKey);
    }
  })();

  inflight.set(params.cacheKey, archiveTask);
  return archiveTask;
}

async function archiveRemoteAssetMapIfNeeded(params: {
  cacheKeyPrefix: string;
  sourceMap?: Record<string, string> | null;
  filenamePrefix: string;
  fallbackExtension: string;
  validateAs?: ArchiveValidationKind;
}) {
  const entries = Object.entries(params.sourceMap || {}).filter(
    (entry): entry is [string, string] =>
      Boolean(entry[0]) && typeof entry[1] === "string" && entry[1].trim().length > 0
  );

  if (entries.length === 0) return null;

  const archivedEntries = (
    await Promise.all(
      entries.map(async ([key, value]) => {
        const archivedUrl = await archiveRemoteAssetIfNeeded({
          cacheKey: `${params.cacheKeyPrefix}:${key}`,
          sourceUrl: value,
          filenamePrefix: `${params.filenamePrefix}-${key}`,
          fallbackExtension: params.fallbackExtension,
          validateAs: params.validateAs,
        });
        return archivedUrl ? ([key, archivedUrl] as const) : null;
      })
    )
  ).filter((entry): entry is readonly [string, string] => Boolean(entry));

  if (archivedEntries.length !== entries.length) return null;
  return Object.fromEntries(archivedEntries);
}

function getStringValue(...values: unknown[]) {
  for (const value of values) {
    if (typeof value === "string" && value.trim()) {
      return value.trim();
    }
  }
  return null;
}

function getObjectValue(value: unknown) {
  return value && typeof value === "object" ? (value as Record<string, unknown>) : null;
}

function readProviderIdFromAssetPayload(value: unknown) {
  const payload = getObjectValue(value);
  const providerId = payload?.providerId;
  return typeof providerId === "string" && providerId.trim()
    ? providerId.trim()
    : null;
}

async function getPersistedWorldAsset(taskId: string, userId: string) {
  const rows = await db
    .select({
      id: model3dAsset.id,
      assetPayload: model3dAsset.assetPayload,
    })
    .from(model3dAsset)
    .where(
      and(
        eq(model3dAsset.taskId, taskId),
        eq(model3dAsset.userId, userId),
        eq(model3dAsset.provider, "worldlabs-3d")
      )
    )
    .limit(1);
  return rows[0] || null;
}

async function updatePersistedWorldAsset(params: {
  id?: string | null;
  status: "running" | "success" | "failed";
  progress?: number | null;
  modelUrl?: string | null;
  previewImageUrl?: string | null;
  error?: string | null;
  assetPayload?: Record<string, unknown> | null;
}) {
  if (!params.id) return;
  await db
    .update(model3dAsset)
    .set({
      status: params.status,
      progress: params.progress ?? null,
      modelUrl: params.modelUrl ?? null,
      previewImageUrl: params.previewImageUrl ?? null,
      error: params.error ?? null,
      assetPayload: params.assetPayload ?? null,
      updatedAt: new Date(),
    })
    .where(eq(model3dAsset.id, params.id));
}

function extractWorldId(operation: WorldLabsOperation) {
  const response = getObjectValue(operation.response);
  const metadata = getObjectValue(operation.metadata);
  const nestedWorldId =
    getStringValue(response?.world_id, response?.worldId) ||
    findNestedString(response, ["world_id", "worldId"]);
  const metadataWorldId =
    getStringValue(metadata?.world_id, metadata?.worldId) ||
    findNestedString(metadata, ["world_id", "worldId"]);

  return getStringValue(nestedWorldId, metadataWorldId);
}

function isWorldLikePayload(value: unknown): value is WorldLabsWorld {
  const record = getObjectValue(value);
  if (!record) return false;

  const hasCoreWorldField =
    typeof record.world_id === "string" ||
    typeof record.world_marble_url === "string" ||
    typeof record.display_name === "string" ||
    typeof record.worldId === "string";
  const hasPossibleWorldContainerFields = record.assets || record.permission || record.tags || record.world_prompt;
  const hasModelAliasOnly =
    typeof record.model === "string" && /world/i.test(record.model);

  return Boolean(hasCoreWorldField || hasPossibleWorldContainerFields || hasModelAliasOnly);
}

function extractWorldCandidate(value: unknown, depth = 0): WorldLabsWorld | null {
  if (depth > 8) return null;
  const record = getObjectValue(value);
  if (!record) return null;

  if (isWorldLikePayload(record)) return record;

  const childCandidates: Array<Record<string, unknown> | null> = [
    getObjectValue(record.world),
    getObjectValue(record.result),
    getObjectValue(record.output),
    getObjectValue(record.data),
    getObjectValue(record.payload),
  ];

  for (const child of childCandidates) {
    if (!child) continue;
    if (isWorldLikePayload(child)) return child;
    const nested = extractWorldCandidate(child, depth + 1);
    if (nested) return nested;
  }

  for (const child of Object.values(record)) {
    const nested = extractWorldCandidate(child, depth + 1);
    if (nested) return nested;
  }

  return null;
}

function extractWorldFromOperation(operation: WorldLabsOperation) {
  return extractWorldCandidate(operation.response);
}

function hasUsableWorldAssets(world?: WorldLabsWorld | null) {
  const assets = world?.assets || null;
  if (!assets) return false;
  const meshRecord = getObjectValue(assets.mesh);
  const imageryRecord = getObjectValue(assets.imagery);
  const splatsRecord = getObjectValue(assets.splats);
  const spzUrls =
    splatsRecord?.spz_urls || splatsRecord?.spzUrls || splatsRecord?.splat_urls;
  return Boolean(
    getStringValue(assets.thumbnail_url) ||
      getStringValue(
        imageryRecord?.pano_url,
        imageryRecord?.panoUrl,
        imageryRecord?.panorama_url,
        imageryRecord?.panoramaUrl
      ) ||
      getStringValue(
        meshRecord?.collider_mesh_url,
        meshRecord?.colliderMeshUrl,
        meshRecord?.collider_mesh,
        meshRecord?.mesh_url,
        meshRecord?.meshUrl,
        meshRecord?.model_url,
        meshRecord?.modelUrl
      ) ||
      (spzUrls &&
        typeof spzUrls === "object" &&
        Object.values(spzUrls).some(
          (value) => typeof value === "string" && value.trim()
        ))
  );
}

function buildAssetPayload(
  world: WorldLabsWorld,
  worldModelAliases: Awaited<
    ReturnType<typeof getThreeDModelAliasConfigForRuntime>
  >["worldModels"],
  assets?: WorldLabsWorldAssets | null,
) {
  return {
    worldId: getStringValue(world.world_id),
    worldUrl: getStringValue(world.world_marble_url),
    displayName: getStringValue(world.display_name),
    model: resolveThreeDModelAliasId(getStringValue(world.model), worldModelAliases),
    caption: getStringValue(assets?.caption),
    thumbnailUrl: getStringValue(assets?.thumbnail_url),
    panoUrl: getStringValue(assets?.imagery?.pano_url),
    meshUrl: getStringValue(assets?.mesh?.collider_mesh_url),
    spzUrls:
      assets?.splats?.spz_urls && typeof assets.splats.spz_urls === "object"
        ? assets.splats.spz_urls
        : null,
    semanticsMetadata:
      assets?.splats?.semantics_metadata &&
      typeof assets.splats.semantics_metadata === "object"
        ? assets.splats.semantics_metadata
        : null,
  };
}

function unwrapExternalTaskData<T extends Record<string, unknown>>(payload: unknown) {
  const root = getObjectValue(payload);
  const data = getObjectValue(root?.data);
  return (data || root || {}) as T;
}

function normalizeExternalTaskStatus(status?: string | null, done?: boolean) {
  const normalized = String(status || "").trim().toLowerCase();
  if (done === true || ["succeeded", "success", "completed", "done"].includes(normalized)) {
    return "success" as const;
  }
  if (["failed", "failure", "error", "cancelled", "canceled"].includes(normalized)) {
    return "failed" as const;
  }
  return "running" as const;
}

function readStringRecord(value: unknown) {
  const record = getObjectValue(value);
  if (!record) return null;
  const entries = Object.entries(record).filter(
    (entry): entry is [string, string] =>
      Boolean(entry[0]) && typeof entry[1] === "string" && entry[1].trim().length > 0
  );
  return entries.length > 0 ? Object.fromEntries(entries) : null;
}

function findNestedString(
  value: unknown,
  keys: string[],
  depth = 0
): string | null {
  if (depth > 8) return null;
  const record = getObjectValue(value);
  if (!record) return null;

  for (const key of keys) {
    const directValue = getStringValue(record[key]);
    if (directValue) return directValue;
  }

  for (const child of Object.values(record)) {
    const found = findNestedString(child, keys, depth + 1);
    if (found) return found;
  }
  return null;
}

function findNestedObject(
  value: unknown,
  keys: string[],
  depth = 0
): Record<string, unknown> | null {
  if (depth > 8) return null;
  const record = getObjectValue(value);
  if (!record) return null;

  for (const key of keys) {
    const directValue = getObjectValue(record[key]);
    if (directValue) return directValue;
  }

  for (const child of Object.values(record)) {
    const found = findNestedObject(child, keys, depth + 1);
    if (found) return found;
  }
  return null;
}

function findNestedStringRecord(
  value: unknown,
  keys: string[],
  depth = 0
): Record<string, string> | null {
  if (depth > 8) return null;
  const record = getObjectValue(value);
  if (!record) return null;

  for (const key of keys) {
    const directValue = readStringRecord(record[key]);
    if (directValue) return directValue;
  }

  for (const child of Object.values(record)) {
    const found = findNestedStringRecord(child, keys, depth + 1);
    if (found) return found;
  }
  return null;
}

function extractExternalTaskErrorMessage(
  data: WorldLabsExternalTaskResultData,
  payload: WorldLabsExternalTaskResponse<WorldLabsExternalTaskResultData>
) {
  const dataError = getObjectValue(data.error);
  const payloadError = getObjectValue(payload.error);
  return (
    getStringValue(
      data.errorMessage,
      data.message,
      dataError?.message,
      payload.message,
      payloadError?.message,
      payload.error
    ) || "World Labs 外部任务失败"
  );
}

function extractExternalWorldAssetPayload(data: WorldLabsExternalTaskResultData) {
  const root = getObjectValue(data) || {};
  const resultRoot =
    getObjectValue(root.result) ||
    getObjectValue(root.output) ||
    getObjectValue(root.world) ||
    root;
  const assets = findNestedObject(resultRoot, ["assets"]);
  const worldAssets = assets as Partial<WorldLabsWorldAssets> | null;
  const splats = getObjectValue(worldAssets?.splats);

  return {
    worldId: getStringValue(
      findNestedString(resultRoot, ["worldId", "world_id"]),
      findNestedString(root, ["worldId", "world_id"])
    ),
    worldUrl: getStringValue(
      findNestedString(resultRoot, [
        "worldUrl",
        "world_marble_url",
        "sourceWorldUrl",
        "viewerUrl",
        "marbleUrl",
      ]),
      findNestedString(root, [
        "worldUrl",
        "world_marble_url",
        "sourceWorldUrl",
        "viewerUrl",
        "marbleUrl",
      ])
    ),
    displayName: getStringValue(
      findNestedString(resultRoot, ["displayName", "display_name"]),
      findNestedString(root, ["displayName", "display_name"])
    ),
    model:
      getStringValue(
        findNestedString(resultRoot, ["model", "modelId", "model_id"]),
        findNestedString(root, ["model", "modelId", "model_id"])
      ) || WORLDLABS_EXTERNAL_TASK_MODEL,
    caption: getStringValue(
      worldAssets?.caption,
      findNestedString(resultRoot, ["caption"]),
      findNestedString(root, ["caption"])
    ),
    thumbnailUrl: getStringValue(
      worldAssets?.thumbnail_url,
      findNestedString(resultRoot, [
        "thumbnailUrl",
        "thumbnail_url",
        "previewImageUrl",
        "preview_image_url",
      ]),
      findNestedString(root, [
        "thumbnailUrl",
        "thumbnail_url",
        "previewImageUrl",
        "preview_image_url",
      ])
    ),
    panoUrl: getStringValue(
      worldAssets?.imagery?.pano_url,
      findNestedString(resultRoot, ["panoUrl", "pano_url", "panoramaUrl", "panorama_url"]),
      findNestedString(root, ["panoUrl", "pano_url", "panoramaUrl", "panorama_url"])
    ),
    meshUrl: getStringValue(
      worldAssets?.mesh?.collider_mesh_url,
      findNestedString(resultRoot, [
        "meshUrl",
        "mesh_url",
        "modelUrl",
        "model_url",
        "glbUrl",
        "glb_url",
        "colliderMeshUrl",
        "collider_mesh_url",
      ]),
      findNestedString(root, [
        "meshUrl",
        "mesh_url",
        "modelUrl",
        "model_url",
        "glbUrl",
        "glb_url",
        "colliderMeshUrl",
        "collider_mesh_url",
      ])
    ),
    spzUrls:
      readStringRecord(splats?.spz_urls) ||
      findNestedStringRecord(resultRoot, ["spzUrls", "spz_urls"]) ||
      findNestedStringRecord(root, ["spzUrls", "spz_urls"]),
    semanticsMetadata:
      getObjectValue(splats?.semantics_metadata) ||
      findNestedObject(resultRoot, ["semanticsMetadata", "semantics_metadata"]) ||
      findNestedObject(root, ["semanticsMetadata", "semantics_metadata"]),
  };
}

interface RouteParams {
  params: Promise<{ taskId: string }>;
}

export async function GET(request: Request, { params }: RouteParams) {
  const startedAt = Date.now();
  let normalizedTaskIdForLog: string | null = null;
  let providerForLog: string | null = null;
  try {
    const session = await auth();
    if (!session?.user?.id) {
      return NextResponse.json({ success: false, error: "未登录" }, { status: 401 });
    }

    const { taskId } = await params;
    const normalizedTaskId = String(taskId || "").trim();
    normalizedTaskIdForLog = normalizedTaskId;
    if (!normalizedTaskId) {
      return NextResponse.json({ success: false, error: "缺少 taskId" }, { status: 400 });
    }

    const persistedWorldAsset = await getPersistedWorldAsset(
      normalizedTaskId,
      session.user.id
    );
    const explicitProviderId = new URL(request.url).searchParams.get("providerId");
    const providerId =
      explicitProviderId || readProviderIdFromAssetPayload(persistedWorldAsset?.assetPayload);
    const config = await getWorldLabsProviderConfig(providerId, {
      includeDisabledPreferred: true,
    });
    providerForLog = config.providerId || null;
    const modelAliasConfig = await getThreeDModelAliasConfigForRuntime();
    let persistedAssetPayload =
      getObjectValue(persistedWorldAsset?.assetPayload) || {};
    let shouldUseExternalTaskResultApi =
      isWorldLabsExternalTaskApi(config.baseUrl) &&
      persistedAssetPayload.externalTaskApi !== false &&
      persistedAssetPayload.marbleApi !== true;
    if (shouldUseExternalTaskResultApi) {
      try {
        const externalPayload = await worldLabsRequest<
          WorldLabsExternalTaskResponse<WorldLabsExternalTaskResultData>
        >(config, {
          method: "GET",
          path: `/api/external/task/result?taskId=${encodeURIComponent(normalizedTaskId)}`,
          timeoutMs: resolveWorldLabsStatusTimeoutMs(),
        });
        const externalData =
          unwrapExternalTaskData<WorldLabsExternalTaskResultData>(externalPayload);
        const externalStatusText = getStringValue(externalData.status) || "running";
        const externalStatus = normalizeExternalTaskStatus(
          externalStatusText,
          externalData.done === true
        );
        const externalAssetPayloadBase = {
          ...persistedAssetPayload,
          providerId: config.providerId || null,
          providerName: config.providerName || null,
          externalTaskApi: true,
          externalTaskStatus: externalStatusText,
          requestId: getStringValue(externalPayload.requestId, externalPayload.request_id),
        };

        if (externalStatus === "running") {
          return NextResponse.json({
            success: true,
            data: {
              taskId: normalizedTaskId,
              type: "world",
              status: "running",
              progress: null,
              output: externalData,
              assetPayload: externalAssetPayloadBase,
            },
          });
        }

        if (externalStatus === "failed") {
          const errorMessage = extractExternalTaskErrorMessage(
            externalData,
            externalPayload
          );
          await updatePersistedWorldAsset({
            id: persistedWorldAsset?.id,
            status: "failed",
            progress: null,
            error: errorMessage,
            assetPayload: externalAssetPayloadBase,
          });
          logger.warn("external task failed status", {
            elapsedMs: Date.now() - startedAt,
            taskIdLength: normalizedTaskId.length,
            providerId: config.providerId || null,
            error: errorMessage,
          });
          return NextResponse.json({
            success: true,
            data: {
              taskId: normalizedTaskId,
              type: "world",
              status: "failed",
              progress: null,
              errorMessage,
              output: externalData,
              assetPayload: externalAssetPayloadBase,
            },
          });
        }
        const extractedAssetPayload = extractExternalWorldAssetPayload(externalData);
        const rawMeshUrl = extractedAssetPayload.meshUrl;
        const rawThumbnailUrl = extractedAssetPayload.thumbnailUrl;
        const rawPanoUrl = extractedAssetPayload.panoUrl;
        const stableWorldUrl: string | null = null;
        const stableModelUrl = await archiveRemoteAssetIfNeeded({
          cacheKey: `worldlabs:${normalizedTaskId}:mesh`,
          sourceUrl: rawMeshUrl,
          filenamePrefix: `worldlabs-mesh-${normalizedTaskId}`,
          fallbackExtension: "glb",
          validateAs: "glb",
        });
        const stableThumbnailUrl = await archiveRemoteAssetIfNeeded({
          cacheKey: `worldlabs:${normalizedTaskId}:thumb`,
          sourceUrl: rawThumbnailUrl,
          filenamePrefix: `worldlabs-thumb-${normalizedTaskId}`,
          fallbackExtension: "jpg",
        });
        const stablePanoUrl = await archiveRemoteAssetIfNeeded({
          cacheKey: `worldlabs:${normalizedTaskId}:pano`,
          sourceUrl: rawPanoUrl,
          filenamePrefix: `worldlabs-pano-${normalizedTaskId}`,
          fallbackExtension: "jpg",
        });
        const stableSpzUrls = await archiveRemoteAssetMapIfNeeded({
          cacheKeyPrefix: `worldlabs:${normalizedTaskId}:spz`,
          sourceMap: extractedAssetPayload.spzUrls,
          filenamePrefix: `worldlabs-splat-${normalizedTaskId}`,
          fallbackExtension: "spz",
          validateAs: "spz",
        });
        const sourceSpzEntryCount = Object.keys(
          extractedAssetPayload.spzUrls || {}
        ).length;
        const stableSpzEntryCount = Object.keys(stableSpzUrls || {}).length;
        const assetsArchivingPending = Boolean(
          (rawMeshUrl && !stableModelUrl) ||
            (rawThumbnailUrl && !stableThumbnailUrl) ||
            (rawPanoUrl && !stablePanoUrl) ||
            (sourceSpzEntryCount > 0 && stableSpzEntryCount !== sourceSpzEntryCount)
        );
        const storageArchivedAt = assetsArchivingPending
          ? null
          : new Date().toISOString();
        const assetPayload = {
          ...externalAssetPayloadBase,
          worldId: extractedAssetPayload.worldId,
          worldUrl: stableWorldUrl,
          displayName: extractedAssetPayload.displayName,
          model: resolveThreeDModelAliasId(
            extractedAssetPayload.model,
            modelAliasConfig.worldModels
          ),
          caption: extractedAssetPayload.caption,
          thumbnailUrl: stableThumbnailUrl || extractedAssetPayload.thumbnailUrl,
          panoUrl: stablePanoUrl || extractedAssetPayload.panoUrl,
          meshUrl: stableModelUrl,
          spzUrls: stableSpzUrls,
          semanticsMetadata: extractedAssetPayload.semanticsMetadata,
          spzArchiveValidatedAt: stableSpzUrls ? storageArchivedAt : null,
          storageArchivedAt,
          assetsArchivingPending,
          sourceWorldUrl: extractedAssetPayload.worldUrl || null,
          sourceMeshUrl:
            rawMeshUrl && stableModelUrl && rawMeshUrl !== stableModelUrl
              ? rawMeshUrl
              : null,
          sourceThumbnailUrl:
            rawThumbnailUrl && stableThumbnailUrl && rawThumbnailUrl !== stableThumbnailUrl
              ? rawThumbnailUrl
              : null,
          sourcePanoUrl:
            rawPanoUrl && stablePanoUrl && rawPanoUrl !== stablePanoUrl
              ? rawPanoUrl
              : null,
          sourceSpzUrls:
            extractedAssetPayload.spzUrls &&
            stableSpzUrls !== extractedAssetPayload.spzUrls
              ? extractedAssetPayload.spzUrls
              : null,
        };

        await updatePersistedWorldAsset({
          id: persistedWorldAsset?.id,
          status: "success",
          progress: 100,
          modelUrl: stableModelUrl,
          previewImageUrl: stableThumbnailUrl || stablePanoUrl || null,
          error: null,
          assetPayload,
        });

        logger.info("external task success status", {
          elapsedMs: Date.now() - startedAt,
          taskIdLength: normalizedTaskId.length,
          providerId: config.providerId || null,
          hasMesh: Boolean(stableModelUrl),
          hasPano: Boolean(stablePanoUrl),
          hasThumbnail: Boolean(stableThumbnailUrl),
          hasSplat: Boolean(stableSpzUrls && Object.keys(stableSpzUrls).length > 0),
          assetsArchivingPending,
        });

        return NextResponse.json({
          success: true,
          data: {
            taskId: normalizedTaskId,
            type: "world",
            status: "success",
            progress: 100,
            output: externalData,
            modelUrl: stableModelUrl,
            previewImageUrl: stableThumbnailUrl || stablePanoUrl || null,
            worldId: assetPayload.worldId,
            worldUrl: stableWorldUrl,
            panoUrl: stablePanoUrl,
            caption: assetPayload.caption,
            assetPayload,
          },
        });
      } catch (error) {
        const fallbackAssetPayload = {
          ...persistedAssetPayload,
          providerId: config.providerId || null,
          providerName: config.providerName || null,
          marbleApi: true,
          externalTaskApi: false,
        };
        shouldUseExternalTaskResultApi = false;
        persistedAssetPayload = fallbackAssetPayload;
        await updatePersistedWorldAsset({
          id: persistedWorldAsset?.id,
          status: "running",
          assetPayload: fallbackAssetPayload,
        }).catch(() => {});
        logger.warn("external task result failed, fallback to marble status", {
          elapsedMs: Date.now() - startedAt,
          taskIdLength: normalizedTaskId.length,
          providerId: config.providerId || null,
          error: error instanceof Error ? error.message : String(error),
        });
      }
    }

    const operation = await worldLabsRequest<WorldLabsOperation>(config, {
      method: "GET",
      path: `/marble/v1/operations/${encodeURIComponent(normalizedTaskId)}`,
      timeoutMs: resolveWorldLabsStatusTimeoutMs(),
    });

    if (!operation.done) {
      return NextResponse.json({
        success: true,
        data: {
          taskId: normalizedTaskId,
          type: "world",
          status: "running",
          progress: null,
          output: operation.response ?? null,
          assetPayload: {
            providerId: config.providerId || null,
            providerName: config.providerName || null,
            operationMetadata: operation.metadata ?? null,
          },
        },
      });
    }

    if (operation.error?.message) {
      const failedAssetPayload = {
        ...(getObjectValue(persistedWorldAsset?.assetPayload) || {}),
        providerId: config.providerId || null,
        providerName: config.providerName || null,
        operationMetadata: operation.metadata ?? null,
      };
      await updatePersistedWorldAsset({
        id: persistedWorldAsset?.id,
        status: "failed",
        progress: null,
        error: operation.error.message,
        assetPayload: failedAssetPayload,
      });
      logger.warn("task failed status", {
        elapsedMs: Date.now() - startedAt,
        taskIdLength: normalizedTaskId.length,
        providerId: config.providerId || null,
        error: operation.error.message,
      });
      return NextResponse.json({
        success: true,
        data: {
          taskId: normalizedTaskId,
          type: "world",
          status: "failed",
          progress: null,
          errorMessage: operation.error.message,
          output: operation.response ?? null,
        },
      });
    }

    let world = extractWorldFromOperation(operation);
    const worldId = extractWorldId(operation);
    if ((!world || !hasUsableWorldAssets(world)) && worldId) {
      try {
        const detailedWorld = await worldLabsRequest<WorldLabsWorld>(config, {
          method: "GET",
          path: `/marble/v1/worlds/${encodeURIComponent(worldId)}`,
          timeoutMs: resolveWorldLabsStatusTimeoutMs(),
        });
        world = world
          ? {
              ...world,
              ...detailedWorld,
              assets: detailedWorld.assets || world.assets || null,
            }
          : detailedWorld;
      } catch (error) {
        logger.warn("world detail fetch failed, retry with running status", {
          elapsedMs: Date.now() - startedAt,
          taskIdLength: normalizedTaskId.length,
          providerId: config.providerId || null,
          worldId,
          error: error instanceof Error ? error.message : "unknown",
        });
      }
    }

    if (!world) {
      const pendingPayload = {
        ...(getObjectValue(persistedWorldAsset?.assetPayload) || {}),
        providerId: config.providerId || null,
        providerName: config.providerName || null,
        worldId: worldId || null,
        worldUrl: null,
        displayName: null,
        model: null,
        assetsPending: true,
        operationMetadata: operation.metadata ?? null,
      };
      await updatePersistedWorldAsset({
        id: persistedWorldAsset?.id,
        status: "running",
        progress: 95,
        assetPayload: pendingPayload,
      });
      logger.warn("task completed but world payload is missing", {
        elapsedMs: Date.now() - startedAt,
        taskIdLength: normalizedTaskId.length,
        providerId: config.providerId || null,
        worldId: worldId || null,
      });
      return NextResponse.json({
        success: true,
        data: {
          taskId: normalizedTaskId,
          type: "world",
          status: "running",
          progress: 95,
          output: operation.response ?? null,
          worldId: worldId || null,
          worldUrl: null,
          previewImageUrl: null,
          assetPayload: pendingPayload,
        },
      });
    }

    if (!hasUsableWorldAssets(world)) {
      await updatePersistedWorldAsset({
        id: persistedWorldAsset?.id,
        status: "running",
        progress: 95,
        assetPayload: {
          ...(getObjectValue(persistedWorldAsset?.assetPayload) || {}),
          providerId: config.providerId || null,
          providerName: config.providerName || null,
          worldId: getStringValue(world.world_id) || worldId || null,
          worldUrl: getStringValue(world.world_marble_url),
          displayName: getStringValue(world.display_name),
          model: resolveThreeDModelAliasId(
            getStringValue(world.model),
            modelAliasConfig.worldModels
          ),
          assetsPending: true,
          operationMetadata: operation.metadata ?? null,
        },
      });
      logger.info("task assets pending", {
        elapsedMs: Date.now() - startedAt,
        taskIdLength: normalizedTaskId.length,
        providerId: config.providerId || null,
        worldIdLength: String(getStringValue(world.world_id) || worldId || "").length,
      });
      return NextResponse.json({
        success: true,
        data: {
          taskId: normalizedTaskId,
          type: "world",
          status: "running",
          progress: 95,
          output: operation.response ?? null,
          worldId: getStringValue(world.world_id) || worldId || null,
          worldUrl: getStringValue(world.world_marble_url),
          previewImageUrl: null,
          assetPayload: {
            providerId: config.providerId || null,
            providerName: config.providerName || null,
            worldId: getStringValue(world.world_id) || worldId || null,
            worldUrl: getStringValue(world.world_marble_url),
            displayName: getStringValue(world.display_name),
            model: resolveThreeDModelAliasId(
              getStringValue(world.model),
              modelAliasConfig.worldModels
            ),
            assetsPending: true,
            operationMetadata: operation.metadata ?? null,
          },
        },
      });
    }

    const assets = world.assets || null;
    const rawWorldUrl = getStringValue(world.world_marble_url);
    const rawMeshUrl = getStringValue(assets?.mesh?.collider_mesh_url);
    const rawThumbnailUrl = getStringValue(assets?.thumbnail_url);
    const rawPanoUrl = getStringValue(assets?.imagery?.pano_url);

    // world_marble_url is an interactive HTML viewer. It is intentionally not embedded in
    // canvas because the third-party iframe is unstable and can expire independently.
    const stableWorldUrl: string | null = null;
    const stableModelUrl = await archiveRemoteAssetIfNeeded({
      cacheKey: `worldlabs:${normalizedTaskId}:mesh`,
      sourceUrl: rawMeshUrl,
      filenamePrefix: `worldlabs-mesh-${normalizedTaskId}`,
      fallbackExtension: "glb",
      validateAs: "glb",
    });
    const stableThumbnailUrl = await archiveRemoteAssetIfNeeded({
      cacheKey: `worldlabs:${normalizedTaskId}:thumb`,
      sourceUrl: rawThumbnailUrl,
      filenamePrefix: `worldlabs-thumb-${normalizedTaskId}`,
      fallbackExtension: "jpg",
    });
    const stablePanoUrl = await archiveRemoteAssetIfNeeded({
      cacheKey: `worldlabs:${normalizedTaskId}:pano`,
      sourceUrl: rawPanoUrl,
      filenamePrefix: `worldlabs-pano-${normalizedTaskId}`,
      fallbackExtension: "jpg",
    });

    const stableSpzUrls = await archiveRemoteAssetMapIfNeeded({
      cacheKeyPrefix: `worldlabs:${normalizedTaskId}:spz`,
      sourceMap:
        assets?.splats?.spz_urls && typeof assets.splats.spz_urls === "object"
          ? assets.splats.spz_urls
          : null,
      filenamePrefix: `worldlabs-splat-${normalizedTaskId}`,
      fallbackExtension: "spz",
      validateAs: "spz",
    });

    const assetPayload = {
      providerId: config.providerId || null,
      providerName: config.providerName || null,
      ...buildAssetPayload(world, modelAliasConfig.worldModels, assets),
    };
    const rawSpzUrls =
      assetPayload.spzUrls && typeof assetPayload.spzUrls === "object"
        ? Object.entries(assetPayload.spzUrls).filter(
            (entry): entry is [string, string] =>
              Boolean(entry[0]) &&
              typeof entry[1] === "string" &&
              entry[1].trim().length > 0
          )
        : [];
    const stableSpzEntryCount = stableSpzUrls
      ? Object.keys(stableSpzUrls).length
      : 0;
    const hasMissingSpzArchive =
      rawSpzUrls.length > 0 && stableSpzEntryCount < rawSpzUrls.length;
    const assetsArchivingPending = Boolean(
      (rawMeshUrl && !stableModelUrl) ||
        (rawThumbnailUrl && !stableThumbnailUrl) ||
        (rawPanoUrl && !stablePanoUrl) ||
        hasMissingSpzArchive
    );
    const storageArchivedAt = assetsArchivingPending
      ? null
      : new Date().toISOString();

    logger.info("task success status", {
      elapsedMs: Date.now() - startedAt,
      taskIdLength: normalizedTaskId.length,
      providerId: config.providerId || null,
      worldIdLength: String(assetPayload.worldId || "").length,
      hasMesh: Boolean(stableModelUrl),
      hasPano: Boolean(stablePanoUrl),
      hasThumbnail: Boolean(stableThumbnailUrl),
      hasSplat: Boolean(stableSpzUrls && Object.keys(stableSpzUrls).length > 0),
      storageArchivedAt,
      assetsArchivingPending,
    });

    const responseAssetPayload = {
      ...assetPayload,
      worldUrl: stableWorldUrl,
      thumbnailUrl: stableThumbnailUrl || assetPayload.thumbnailUrl,
      panoUrl: stablePanoUrl || assetPayload.panoUrl,
      meshUrl: stableModelUrl,
      spzUrls: stableSpzUrls,
      spzArchiveValidatedAt: stableSpzUrls ? storageArchivedAt : null,
      storageArchivedAt,
      assetsArchivingPending,
      sourceWorldUrl: rawWorldUrl || null,
      sourceMeshUrl:
        rawMeshUrl && stableModelUrl && rawMeshUrl !== stableModelUrl
          ? rawMeshUrl
          : null,
      sourceThumbnailUrl:
        rawThumbnailUrl && stableThumbnailUrl && rawThumbnailUrl !== stableThumbnailUrl
          ? rawThumbnailUrl
          : null,
      sourcePanoUrl:
        rawPanoUrl && stablePanoUrl && rawPanoUrl !== stablePanoUrl
          ? rawPanoUrl
          : null,
      sourceSpzUrls:
        assetPayload.spzUrls && stableSpzUrls !== assetPayload.spzUrls
          ? assetPayload.spzUrls
          : null,
    };
    await updatePersistedWorldAsset({
      id: persistedWorldAsset?.id,
      status: "success",
      progress: 100,
      modelUrl: stableModelUrl,
      previewImageUrl: stableThumbnailUrl || stablePanoUrl || null,
      error: null,
      assetPayload: responseAssetPayload,
    });

    return NextResponse.json({
      success: true,
      data: {
        taskId: normalizedTaskId,
        type: "world",
        status: "success",
        progress: 100,
        output: operation.response ?? null,
        modelUrl: stableModelUrl,
        previewImageUrl: stableThumbnailUrl || stablePanoUrl || null,
        worldId: assetPayload.worldId,
        worldUrl: stableWorldUrl,
        panoUrl: stablePanoUrl,
        caption: assetPayload.caption,
        assetPayload: responseAssetPayload,
      },
    });
  } catch (error) {
    logger.error("task status failed", error, {
      elapsedMs: Date.now() - startedAt,
      taskIdLength: String(normalizedTaskIdForLog || "").length,
      providerId: providerForLog,
    });
    if (error instanceof WorldLabsApiError) {
      return NextResponse.json(
        {
          success: false,
          error: error.message,
          payload: error.payload,
        },
        { status: error.httpStatus || 502 }
      );
    }

    return NextResponse.json(
      {
        success: false,
        error: error instanceof Error ? error.message : "查询 World Labs 任务失败",
      },
      { status: 500 }
    );
  }
}