import path from 'path'
import { Prisma } from '@prisma/client'
import { prisma } from '@/lib/prisma'
import { generateDownloadUrl } from '@/lib/download-token'
import { getPublicAppOrigin } from '@/lib/public-app-url'
import { parseStandardModelWhiteBgAssetType } from '@/lib/standard-model-white-background'

// These are resource categories, not filename guesses. Models, PSD templates,
// video and task-other attachments are deliberately outside this API's scope.
export const EXTERNAL_IMAGE_RESOURCE_TYPES = {
  image: ['实拍图片', '买家秀图片', '任务-实拍原图', '任务-视频截图', '任务-详情', '标准模型'],
  'ai-original': ['任务-AI原图'],
  'render-original': ['任务-3D原图'],
} as const
type ResourceType = keyof typeof EXTERNAL_IMAGE_RESOURCE_TYPES

export class ExternalImageAssetsError extends Error {
  constructor(readonly status: number, readonly code: string, message: string) { super(message) }
}

export interface ExternalImageQuery {
  type: 'sku' | 'barcode'
  value: string
  resourceType: ResourceType | 'all'
  page: number
  pageSize: number
}

export function parseExternalImageQuery(params: URLSearchParams): ExternalImageQuery {
  const allowed = new Set(['sku', 'barcode', 'resourceType', 'page', 'pageSize'])
  for (const key of Array.from(params.keys())) {
    if (!allowed.has(key) || params.getAll(key).length !== 1) {
      throw new ExternalImageAssetsError(400, 'INVALID_QUERY', '查询参数无效或重复')
    }
  }
  const sku = (params.get('sku') || '').trim(), barcode = (params.get('barcode') || '').trim()
  if (Boolean(sku) === Boolean(barcode)) throw new ExternalImageAssetsError(400, 'INVALID_QUERY', 'sku 与 barcode 必须且只能提供一个')
  const value = (sku || barcode).normalize('NFC')
  if (value.length > 200 || /[\x00-\x1f\x7f]/.test(value)) throw new ExternalImageAssetsError(400, 'INVALID_QUERY', '产品编号无效')
  const resourceType = params.get('resourceType') || 'all'
  if (resourceType !== 'all' && !Object.hasOwn(EXTERNAL_IMAGE_RESOURCE_TYPES, resourceType)) {
    throw new ExternalImageAssetsError(400, 'INVALID_RESOURCE_TYPE', 'resourceType 仅支持 image、ai-original、render-original 或 all')
  }
  const integer = (key: string, fallback: number, max: number) => {
    const raw = params.get(key)
    if (raw === null) return fallback
    if (!/^[1-9]\d{0,5}$/.test(raw) || Number(raw) > max) throw new ExternalImageAssetsError(400, 'INVALID_PAGINATION', '分页参数无效')
    return Number(raw)
  }
  return { type: sku ? 'sku' : 'barcode', value: sku ? value.toUpperCase() : value,
    resourceType: resourceType as ExternalImageQuery['resourceType'], page: integer('page', 1, 10000), pageSize: integer('pageSize', 20, 50) }
}

const VISIBLE: Prisma.MaterialWhereInput = { deletedAt: null, isIncompleteShell: false, taskDetailPrivate: false }
const equal = (value: string) => ({ equals: value, mode: 'insensitive' as const })

async function resolveProduct(query: ExternalImageQuery) {
  // Reuse the database's SKU and barcode bindings; never derive an SPU by
  // truncating a SKU or use a broad title/name search for a product identity.
  const [skus, assets] = await Promise.all([
    prisma.materialSku.findMany({
      where: { deletedAt: null, material: { is: VISIBLE }, ...(query.type === 'sku'
        ? { skuName: equal(query.value) }
        : { barcodes: { some: { barcode: query.value, deletedAt: null } } }) },
      select: { skuName: true, material: { select: { productModel: true } } }, take: 101,
    }),
    prisma.materialAsset.findMany({
      where: { material: { is: VISIBLE }, ...(query.type === 'sku'
        ? { skuCode: equal(query.value) }
        : { barcodes: { some: { barcode: query.value } } }) },
      select: { skuCode: true, material: { select: { productModel: true } } }, take: 101,
    }),
  ])
  if (skus.length > 100 || assets.length > 100) throw new ExternalImageAssetsError(409, 'PRODUCT_BINDING_LIMIT', '产品绑定过多，请先核对 SKU／条码关联')
  const targets = [...skus.map(s => ({ sku: s.skuName, spu: s.material.productModel })),
    ...assets.map(a => ({ sku: a.skuCode, spu: a.material.productModel }))]
  if (!targets.length) throw new ExternalImageAssetsError(404, query.type === 'sku' ? 'SKU_NOT_FOUND' : 'BARCODE_NOT_FOUND', '未找到有效的产品编号绑定')
  const spus = Array.from(new Set(targets.map(t => t.spu.trim().toUpperCase()).filter(Boolean)))
  const skuNames = Array.from(new Set(targets.map(t => t.sku?.trim().toUpperCase()).filter((s): s is string => Boolean(s))))
  if (spus.length !== 1 || skuNames.length > 1) throw new ExternalImageAssetsError(409, 'PRODUCT_BINDING_AMBIGUOUS', '该编号关联多个产品或规格，请先核对绑定')
  return { sku: skuNames[0] || null, spu: spus[0], resourceScope: 'spu' as const }
}

const select = {
  id: true, productModel: true, materialType: true, taskNo: true, categoryName: true, createdAt: true,
  zipFilePath: true, zipFileName: true, zipFileSize: true,
  assets: { select: { id: true, assetType: true, fileUrl: true, fileName: true, fileSize: true, sortOrder: true }, orderBy: [{ sortOrder: 'asc' as const }, { id: 'asc' as const }] },
  skus: { where: { deletedAt: null }, select: { id: true, skuName: true } },
} satisfies Prisma.MaterialSelect
type ImageMaterial = Prisma.MaterialGetPayload<{ select: typeof select }>
export interface ExternalImageResource {
  materialId: string
  assetId: string | null
  materialType: string
  resourceType: ResourceType
  taskNo: string | null
  productModel: string
  skuCode: string | null
  matchScope: 'sku' | 'spu'
  group: string | null
  fileName: string
  fileSize: number
  kind: 'image' | 'archive' | 'source'
  downloadUrl: string
  uploadedAt: string
}

/** Only the new image-source token reaches this resolver; old callers do not. */
export async function resolveExternalImageDownloadSource(material: {
  id: string; materialType: string; deletedAt?: Date | null; taskDetailPrivate?: boolean; isIncompleteShell?: boolean;
  zipFilePath?: string; zipFileName?: string; assets?: Array<{ id: string; assetType: string; fileUrl: string; fileName?: string | null }>;
}, assetId?: string) {
  const allowed = Object.values(EXTERNAL_IMAGE_RESOURCE_TYPES).flat() as readonly string[]
  if (material.deletedAt || material.taskDetailPrivate || material.isIncompleteShell || !allowed.includes(material.materialType)) return null
  if (assetId) {
    const asset = material.assets?.find(a => a.id === assetId)
    if (!asset?.fileUrl.trim()) return null
    if (material.materialType === '标准模型') {
      const parsed = parseStandardModelWhiteBgAssetType(asset.assetType)
      if (!parsed || parsed.kind === 'zip') return null
      const sku = await prisma.materialSku.findFirst({ where: { id: parsed.skuId, materialId: material.id, deletedAt: null }, select: { id: true } })
      return sku ? asset : null
    }
    const sourceTypes = material.materialType === '任务-详情' ? ['main', 'sku', 'detail', 'all'] : ['zip']
    return sourceTypes.includes(asset.assetType) ? asset : null
  }
  if (['标准模型', '任务-详情'].includes(material.materialType) || !material.zipFilePath?.trim()) return null
  return { fileUrl: material.zipFilePath, fileName: material.zipFileName || leaf(material.zipFilePath) }
}

function leaf(value: string): string {
  try { return decodeURIComponent(path.posix.basename(new URL(value).pathname)) } catch { return path.posix.basename(value.replace(/\\/g, '/')) }
}
function kind(fileName: string, storedPath: string): ExternalImageResource['kind'] {
  const extension = (path.extname(fileName) || path.extname(leaf(storedPath))).toLowerCase()
  if (['.zip', '.rar'].includes(extension)) return 'archive'
  if (/^\.(png|jpe?g|webp|gif|bmp|tiff?|avif|heic|heif)$/.test(extension)) return 'image'
  return 'source'
}

export async function findExternalImageAssets(query: ExternalImageQuery) {
  const resolution = await resolveProduct(query)
  const types = query.resourceType === 'all' ? Object.values(EXTERNAL_IMAGE_RESOURCE_TYPES).flat() : [...EXTERNAL_IMAGE_RESOURCE_TYPES[query.resourceType]]
  const where: Prisma.MaterialWhereInput = { ...VISIBLE, productModel: equal(resolution.spu), materialType: { in: types } }
  const [totalMaterials, materials] = await Promise.all([
    prisma.material.count({ where }),
    prisma.material.findMany({ where, select, orderBy: [{ createdAt: 'desc' }, { id: 'asc' }], skip: (query.page - 1) * query.pageSize, take: query.pageSize }),
  ])
  const baseUrl = getPublicAppOrigin(), items: ExternalImageResource[] = []
  const issues: Array<{ materialId: string; code: string; message: string }> = []
  const append = (m: ImageMaterial, source: { id?: string; fileUrl: string; fileName: string | null; fileSize: bigint },
    group: string | null = null, skuCode: string | null = null) => {
    if (!source.fileUrl.trim()) return
    const resourceType = (Object.entries(EXTERNAL_IMAGE_RESOURCE_TYPES).find(([, values]) => (values as readonly string[]).includes(m.materialType))?.[0] || 'image') as ResourceType
    const size = Number(source.fileSize)
    items.push({ materialId: m.id, assetId: source.id || null, materialType: m.materialType, resourceType, taskNo: m.taskNo,
      productModel: m.productModel, skuCode, matchScope: skuCode ? 'sku' : 'spu', group,
      fileName: leaf(source.fileName || source.fileUrl), fileSize: Number.isSafeInteger(size) && size >= 0 ? size : 0,
      kind: kind(source.fileName || '', source.fileUrl),
      downloadUrl: generateDownloadUrl(baseUrl, { materialId: m.id, downloadType: 'image-source', ...(source.id ? { assetId: source.id } : {}) }),
      uploadedAt: m.createdAt.toISOString() })
  }
  for (const m of materials) {
    const countBefore = items.length
    if (m.materialType === '标准模型') {
      // Standard-model source ZIPs contain 3D models, not image originals.
      // Only return white-background image assets belonging to the exact SKU.
      const ids = new Set(m.skus.filter(s => s.skuName.trim().toUpperCase() === resolution.sku).map(s => s.id))
      for (const a of m.assets) {
        const parsed = parseStandardModelWhiteBgAssetType(a.assetType)
        if (parsed && parsed.kind !== 'zip' && ids.has(parsed.skuId)) append(m, a, 'white-background', resolution.sku)
      }
    } else if (m.materialType === '任务-详情') {
      const groups = m.assets.filter(a => ['main', 'sku', 'detail'].includes(a.assetType))
      for (const a of groups) append(m, a, a.assetType)
      if (!groups.length) for (const a of m.assets.filter(a => a.assetType === 'all')) append(m, a, 'all')
    } else {
      const archives = m.assets.filter(a => a.assetType === 'zip' && a.fileUrl.trim())
      if (archives.length) for (const a of archives) append(m, a)
      else if (m.zipFilePath.trim()) append(m, { fileUrl: m.zipFilePath, fileName: m.zipFileName, fileSize: m.zipFileSize })
    }
    if (items.length === countBefore) issues.push({ materialId: m.id, code: 'SOURCE_NOT_AVAILABLE', message: '暂无对应的原始资源，不返回预览图代替' })
  }
  return { query: { type: query.type, value: query.value, resourceType: query.resourceType }, resolution, count: items.length, items, issues,
    pagination: { page: query.page, pageSize: query.pageSize, totalMaterials, hasMore: query.page * query.pageSize < totalMaterials } }
}