import { createRequestError } from './request-client.js'
import {
  normalizeNormalDisableResponseStatus,
  normalizeOptionalNonnegativeInteger,
  normalizeOptionalNumericId,
  normalizeResponseText
} from './response-normalizers.js'
import {
  assertPlainPayload,
  normalizeOptionalNormalDisableStatus,
  normalizeOptionalSafeInteger,
  normalizeOptionalText,
  normalizeOssIdString
} from './request-normalizers.js'
import {
  normalizeBusinessFileAccess,
  normalizeResourceCapabilities
} from './business-file-contract.js'

export const normalizeAppVideo = (value, expectedGenealogyId, expectedVideoId = '') => {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    throw createRequestError('家族视频响应无效', 'VIDEO_RESPONSE_INVALID')
  }
  const id = normalizeOptionalNumericId(value.videoId, '视频标识', 'VIDEO_RESPONSE_INVALID')
  const genealogyId = normalizeOptionalNumericId(value.genealogyId, '视频家谱标识', 'VIDEO_RESPONSE_INVALID')
  const title = normalizeResponseText(value.videoTitle, 'videoTitle')
  if (!id || genealogyId !== expectedGenealogyId || !title || (expectedVideoId && id !== expectedVideoId)) {
    throw createRequestError('家族视频响应缺少稳定字段', 'VIDEO_RESPONSE_INVALID')
  }
  if (typeof value.canEdit !== 'boolean' || typeof value.canDelete !== 'boolean') {
    throw createRequestError('家族视频响应缺少权限字段', 'VIDEO_RESPONSE_INVALID')
  }
  return {
    id,
    genealogyId,
    title,
    description: normalizeResponseText(value.videoDesc, 'videoDesc'),
    coverFile: normalizeBusinessFileAccess(value.coverFile, '视频封面', 'VIDEO_RESPONSE_INVALID'),
    videoFile: normalizeBusinessFileAccess(value.videoFile, '视频文件', 'VIDEO_RESPONSE_INVALID', { required: true }),
    durationSeconds: normalizeOptionalNonnegativeInteger(value.durationSeconds, '视频时长', 'VIDEO_RESPONSE_INVALID'),
    publishTime: normalizeResponseText(value.publishTime, 'publishTime'),
    viewCount: normalizeOptionalNonnegativeInteger(value.viewCount, '视频播放量', 'VIDEO_RESPONSE_INVALID'),
    sortOrder: normalizeOptionalNonnegativeInteger(value.sortOrder, '视频排序值', 'VIDEO_RESPONSE_INVALID'),
    status: normalizeNormalDisableResponseStatus(value.status, '视频状态', 'VIDEO_RESPONSE_INVALID'),
    canEdit: value.canEdit,
    canDelete: value.canDelete
  }
}

export const normalizeAppVideos = (value, expectedGenealogyId) => {
  if (!Array.isArray(value)) throw createRequestError('家族视频响应不是列表', 'VIDEO_RESPONSE_INVALID')
  const videos = value.map((item) => normalizeAppVideo(item, expectedGenealogyId))
  if (new Set(videos.map((item) => item.id)).size !== videos.length) {
    throw createRequestError('家族视频响应包含重复标识', 'VIDEO_RESPONSE_INVALID')
  }
  return videos
}

export const normalizeAppAlbum = (value, expectedGenealogyId) => {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    throw createRequestError('相册响应无效', 'ALBUM_RESPONSE_INVALID')
  }
  const id = normalizeOptionalNumericId(value.albumId, '相册标识', 'ALBUM_RESPONSE_INVALID')
  const genealogyId = normalizeOptionalNumericId(value.genealogyId, '相册家谱标识', 'ALBUM_RESPONSE_INVALID')
  if (!id || genealogyId !== expectedGenealogyId) {
    throw createRequestError('相册响应缺少稳定归属字段', 'ALBUM_RESPONSE_INVALID')
  }
  return {
    id,
    genealogyId,
    name: normalizeResponseText(value.albumName, 'albumName') || '未命名相册',
    description: normalizeResponseText(value.albumDesc, 'albumDesc'),
    coverFile: normalizeBusinessFileAccess(value.coverFile, '相册封面', 'ALBUM_RESPONSE_INVALID'),
    photoCount: normalizeOptionalNonnegativeInteger(value.photoCount, '相册照片数量', 'ALBUM_RESPONSE_INVALID'),
    sortOrder: normalizeOptionalNonnegativeInteger(value.sortOrder, '相册排序值', 'ALBUM_RESPONSE_INVALID'),
    status: normalizeNormalDisableResponseStatus(value.status, '相册状态', 'ALBUM_RESPONSE_INVALID'),
    ...normalizeResourceCapabilities(value, '相册', 'ALBUM_RESPONSE_INVALID')
  }
}

export const normalizeAppAlbums = (value, expectedGenealogyId) => {
  if (!Array.isArray(value)) throw createRequestError('相册响应不是列表', 'ALBUM_RESPONSE_INVALID')
  const albums = value.map((item) => normalizeAppAlbum(item, expectedGenealogyId))
  if (new Set(albums.map((item) => item.id)).size !== albums.length) {
    throw createRequestError('相册响应包含重复标识', 'ALBUM_RESPONSE_INVALID')
  }
  return albums
}

export const projectPreviewAlbums = (value, expectedGenealogyId) =>
  value.map((item) => ({
    id: String(item.id),
    genealogyId: expectedGenealogyId,
    name: String(item.name || '未命名相册'),
    description: String(item.description || ''),
    coverFile: item.cover ? { accessUrl: String(item.cover) } : null,
    photoCount: Number.isSafeInteger(item.photoCount) ? item.photoCount : 0,
    canEdit: false,
    canDelete: false
  }))

const normalizeAppAlbumPhoto = (value, expectedGenealogyId, expectedAlbumId) => {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    throw createRequestError('相册照片响应无效', 'ALBUM_PHOTO_RESPONSE_INVALID')
  }
  const id = normalizeOptionalNumericId(value.photoId, '照片标识', 'ALBUM_PHOTO_RESPONSE_INVALID')
  const genealogyId = normalizeOptionalNumericId(value.genealogyId, '照片家谱标识', 'ALBUM_PHOTO_RESPONSE_INVALID')
  const albumId = normalizeOptionalNumericId(value.albumId, '照片相册标识', 'ALBUM_PHOTO_RESPONSE_INVALID')
  if (!id || genealogyId !== expectedGenealogyId || albumId !== expectedAlbumId) {
    throw createRequestError('相册照片响应缺少稳定归属字段', 'ALBUM_PHOTO_RESPONSE_INVALID')
  }
  return {
    id,
    genealogyId,
    albumId,
    title: normalizeResponseText(value.photoTitle, 'photoTitle') || '未命名照片',
    description: normalizeResponseText(value.photoDesc, 'photoDesc'),
    photographer: normalizeResponseText(value.photographer, 'photographer'),
    shootTime: normalizeResponseText(value.shootTime, 'shootTime'),
    photoFile: normalizeBusinessFileAccess(value.photoFile, '相册照片', 'ALBUM_PHOTO_RESPONSE_INVALID', { required: true }),
    ...normalizeResourceCapabilities(value, '相册照片', 'ALBUM_PHOTO_RESPONSE_INVALID')
  }
}

export const normalizeAppAlbumPhotos = (value, expectedGenealogyId, expectedAlbumId) => {
  if (!Array.isArray(value)) throw createRequestError('相册照片响应不是列表', 'ALBUM_PHOTO_RESPONSE_INVALID')
  const photos = value.map((item) => normalizeAppAlbumPhoto(item, expectedGenealogyId, expectedAlbumId))
  if (new Set(photos.map((item) => item.id)).size !== photos.length) {
    throw createRequestError('相册照片响应包含重复标识', 'ALBUM_PHOTO_RESPONSE_INVALID')
  }
  return photos
}

export const normalizeAlbumCreatePayload = (payload) => {
  const allowedFields = new Set(['albumName', 'albumDesc', 'coverOssId', 'sortOrder', 'status'])
  assertPlainPayload(payload, allowedFields, '相册请求')
  if (typeof payload.albumName !== 'string' || !payload.albumName.trim()) {
    throw new TypeError('相册名称不能为空')
  }
  const normalizedPayload = { albumName: payload.albumName.trim() }
  const albumDesc = normalizeOptionalText(payload.albumDesc, 'albumDesc')
  if (albumDesc) normalizedPayload.albumDesc = albumDesc
  const status = normalizeOptionalNormalDisableStatus(payload.status, '相册状态')
  if (status) normalizedPayload.status = status
  if (payload.coverOssId !== undefined && payload.coverOssId !== null && payload.coverOssId !== '') {
    normalizedPayload.coverOssId = normalizeOssIdString(payload.coverOssId, 'coverOssId')
  }
  if (payload.sortOrder !== undefined && payload.sortOrder !== null && payload.sortOrder !== '') {
    const sortOrder = typeof payload.sortOrder === 'number' ? payload.sortOrder : Number(payload.sortOrder)
    if (!Number.isSafeInteger(sortOrder)) throw new TypeError('sortOrder 必须是安全整数')
    normalizedPayload.sortOrder = sortOrder
  }
  return normalizedPayload
}

export const normalizeAlbumPhotoCreatePayload = (payload) => {
  const allowedFields = new Set(['ossId', 'photoTitle', 'photoDesc', 'photographer', 'shootTime', 'sortOrder', 'status'])
  assertPlainPayload(payload, allowedFields, '相册照片请求')
  const ossId = normalizeOssIdString(payload.ossId, '相册照片 ossId')
  const normalizedPayload = { ossId }
  for (const field of ['photoTitle', 'photoDesc', 'photographer', 'shootTime']) {
    const normalizedText = normalizeOptionalText(payload[field], field)
    if (normalizedText) normalizedPayload[field] = normalizedText
  }
  const status = normalizeOptionalNormalDisableStatus(payload.status, '照片状态')
  if (status) normalizedPayload.status = status
  const sortOrder = normalizeOptionalSafeInteger(payload.sortOrder, 'sortOrder')
  if (sortOrder !== undefined) normalizedPayload.sortOrder = sortOrder
  return normalizedPayload
}

export const normalizeVideoPayload = (payload) => {
  const allowedFields = new Set(['videoTitle', 'videoDesc', 'coverOssId', 'videoOssId', 'durationSeconds', 'sortOrder', 'status'])
  assertPlainPayload(payload, allowedFields, '视频请求')
  const videoTitle = normalizeOptionalText(payload.videoTitle, '视频标题')
  if (!videoTitle) throw new TypeError('视频标题不能为空')
  const videoOssId = normalizeOssIdString(payload.videoOssId, '视频文件 OSS ID')
  const normalizedPayload = { videoTitle, videoOssId }
  const videoDesc = normalizeOptionalText(payload.videoDesc, '视频说明')
  if (videoDesc) normalizedPayload.videoDesc = videoDesc
  if (payload.coverOssId !== undefined && payload.coverOssId !== null && payload.coverOssId !== '') {
    normalizedPayload.coverOssId = normalizeOssIdString(payload.coverOssId, '视频封面 OSS ID')
  }
  for (const field of ['durationSeconds', 'sortOrder']) {
    const normalizedInteger = normalizeOptionalSafeInteger(payload[field], field)
    if (normalizedInteger !== undefined) normalizedPayload[field] = normalizedInteger
  }
  const status = normalizeOptionalNormalDisableStatus(payload.status, '视频状态')
  if (status) normalizedPayload.status = status
  return normalizedPayload
}