import { createError, defineEventHandler, readBody } from 'h3'
import { db } from '~/drizzle/db'
import {
  cardCodeRedeemLogs,
  cardCodes,
  emailTemplates,
  gradeClass,
  notificationSettings,
  notifications,
  playTimes,
  schedules,
  semesters,
  songBlacklists,
  songs,
  systemSettings,
  userIdentities,
  users,
  userStatusLogs,
  votes
} from '~/drizzle/schema'
import { and, eq } from 'drizzle-orm'
import { restoreScheduleSongPoolRecord } from '~~/server/utils/restoreScheduleSongPool'
import { omitMaskedSystemSettingsSecrets } from '~~/server/api/admin/system-settings/secretMask'
import { createApiError } from '~~/server/utils/apiError'
import { validateThemeConfig } from '~~/server/utils/theme-config'
import { SERVER_ERROR_CODES } from '~~/server/config/constants'
import { normalizeScheduleVisibilitySettings } from '~~/server/utils/system-settings-defaults'
import { syncAllSequences } from '~~/server/utils/sequence-sync'

export default defineEventHandler(async (event) => {
  // 验证管理员权限
  const user = event.context.user
  if (!user || user.role !== 'SUPER_ADMIN') {
    throw createError({
      statusCode: 403,
      message: '只有超级管理员可以恢复备份'
    })
  }

  const body = await readBody(event)
  const {
    tableName,
    records,
    mappings,
    mode = 'merge',
    overwriteSuperAdmin = false,
    hasSuperAdminInBackup = false
  } = body

  if (overwriteSuperAdmin && user.role !== 'SUPER_ADMIN') {
    throw createError({
      statusCode: 403,
      message: '仅超级管理员可以覆盖超级管理员账号数据'
    })
  }

  if (!tableName || !records || !Array.isArray(records)) {
    throw createError({
      statusCode: 400,
      message: '无效的请求参数'
    })
  }

  // 转换映射对象为Map
  const userIdMapping = new Map(
    Object.entries(mappings?.users || {}).map(([k, v]) => [Number(k), Number(v)])
  )
  const songIdMapping = new Map(
    Object.entries(mappings?.songs || {}).map(([k, v]) => [Number(k), Number(v)])
  )
  const cardCodeIdMapping = new Map(
    Object.entries(mappings?.cardCodes || {}).map(([k, v]) => [Number(k), Number(v)])
  )
  const preservedSuperAdminIds = new Set(
    (mappings?.meta?.preservedSuperAdminIds || []).map((id) => Number(id))
  )
  const temporaryPreservedUserId = mappings?.meta?.temporaryPreservedUserId
    ? Number(mappings.meta.temporaryPreservedUserId)
    : null
  const shouldOverwriteSuperAdmin = overwriteSuperAdmin && hasSuperAdminInBackup

  const newMappings = {
    users: {},
    songs: {},
    cardCodes: {}
  }

  const stats = {
    processed: 0,
    created: 0,
    updated: 0,
    errors: 0,
    warnings: []
  }

  console.log(`处理批次: ${tableName}, ${records.length} 条记录`)

  for (const record of records) {
    try {
      await db.transaction(async (tx) => {
        switch (tableName) {
          case 'users': {
            const buildUserData = (includePassword = false) => {
              const userData: any = {}
              const userFields = [
                'username',
                'name',
                'grade',
                'class',
                'role',
                'email',
                'emailVerified',
                'lastLoginIp',
                'meowNickname',
                'forcePasswordChange',
                'status',
                'statusChangedBy',
                'remark',
                'avatarProvider',
                'avatarProviderUserId'
              ]
              const dateFields = [
                'createdAt',
                'updatedAt',
                'lastLogin',
                'passwordChangedAt',
                'meowBoundAt',
                'statusChangedAt'
              ]

              userFields.forEach((field) => {
                if (record.hasOwnProperty(field)) {
                  if (field === 'role') {
                    if (!['USER', 'SONG_ADMIN', 'ADMIN', 'SUPER_ADMIN'].includes(record[field])) {
                      userData[field] = 'USER'
                    } else {
                      userData[field] = record[field]
                    }
                  } else {
                    userData[field] = record[field]
                  }
                }
              })

              dateFields.forEach((field) => {
                if (record.hasOwnProperty(field) && record[field]) {
                  userData[field] = new Date(record[field])
                } else if (record.hasOwnProperty(field)) {
                  userData[field] = null
                }
              })

              if (includePassword && record.hasOwnProperty('password')) {
                userData.password = record.password
              }

              return userData
            }

            let createdUser
            if (mode === 'merge') {
              const existingUser = await tx.query.users.findFirst({
                where: eq(users.username, record.username)
              })

              if (existingUser) {
                createdUser = (
                  await tx
                    .update(users)
                    .set(buildUserData(false))
                    .where(eq(users.username, record.username))
                    .returning()
                )[0]
                stats.updated++
              } else {
                try {
                  const existingUserWithId = await tx.query.users.findFirst({
                    where: eq(users.id, record.id)
                  })

                  if (existingUserWithId) {
                    createdUser = (
                      await tx.insert(users).values(buildUserData(true)).returning()
                    )[0]
                  } else {
                    createdUser = (
                      await tx
                        .insert(users)
                        .values({
                          ...buildUserData(true),
                          id: record.id
                        })
                        .returning()
                    )[0]
                  }
                } catch (error) {
                  console.warn(`用户 ${record.username} 使用原始ID创建失败，使用自动生成ID`)
                  createdUser = (await tx.insert(users).values(buildUserData(true)).returning())[0]
                }
                stats.created++
              }
            } else {
              if (
                shouldOverwriteSuperAdmin &&
                temporaryPreservedUserId &&
                Number(record.id) === temporaryPreservedUserId
              ) {
                createdUser = (await tx.insert(users).values(buildUserData(true)).returning())[0]
                stats.created++
                if (record.id && createdUser?.id) {
                  newMappings.users[record.id] = createdUser.id
                }
                break
              }

              const isBackupSuperAdminRecord =
                record.role === 'SUPER_ADMIN' || preservedSuperAdminIds.has(Number(record.id))
              if (!shouldOverwriteSuperAdmin && isBackupSuperAdminRecord) {
                if (record.id) {
                  const existingUserWithId = await tx.query.users.findFirst({
                    where: eq(users.id, record.id)
                  })
                  if (existingUserWithId) {
                    newMappings.users[record.id] = existingUserWithId.id
                  }
                }
                stats.updated++
                break
              }

              const existingUserWithId = await tx.query.users.findFirst({
                where: eq(users.id, record.id)
              })

              if (existingUserWithId) {
                createdUser = (
                  await tx
                    .update(users)
                    .set(buildUserData(true))
                    .where(eq(users.id, record.id))
                    .returning()
                )[0]
                stats.updated++
              } else {
                createdUser = (
                  await tx
                    .insert(users)
                    .values({
                      ...buildUserData(true),
                      id: record.id
                    })
                    .returning()
                )[0]
                stats.created++
              }
            }

            if (record.id && createdUser.id) {
              newMappings.users[record.id] = createdUser.id
            }
            break
          }

          case 'userIdentities': {
            let validIdentityUserId = record.userId
            if (record.userId) {
              const mappedUserId = userIdMapping.get(record.userId)
              if (mappedUserId) {
                validIdentityUserId = mappedUserId
              } else {
                const userExists = await tx.query.users.findFirst({
                  where: eq(users.id, record.userId)
                })
                if (!userExists) {
                  console.warn(`身份关联记录的用户ID ${record.userId} 不存在，跳过`)
                  return
                }
              }
            } else {
              return
            }

            const identityData = {
              userId: validIdentityUserId,
              provider: record.provider,
              providerUserId: record.providerUserId,
              providerUsername: record.providerUsername,
              avatar: record.avatar || null,
              createdAt: record.createdAt ? new Date(record.createdAt) : new Date()
            }

            if (
              !shouldOverwriteSuperAdmin &&
              preservedSuperAdminIds.has(Number(validIdentityUserId))
            ) {
              stats.updated++
              break
            }

            if (mode === 'merge') {
              await tx
                .insert(userIdentities)
                .values(identityData)
                .onConflictDoUpdate({
                  target: [userIdentities.provider, userIdentities.providerUserId],
                  set: identityData
                })
              stats.updated++
            } else if (record.id) {
              const existingIdentityWithId = await tx.query.userIdentities.findFirst({
                where: eq(userIdentities.id, record.id)
              })

              if (existingIdentityWithId) {
                await tx
                  .update(userIdentities)
                  .set(identityData)
                  .where(eq(userIdentities.id, record.id))
                stats.updated++
              } else {
                await tx.insert(userIdentities).values({
                  ...identityData,
                  id: record.id
                })
                stats.created++
              }
            } else {
              await tx.insert(userIdentities).values(identityData)
              stats.created++
            }
            break
          }

          case 'userStatusLogs': {
            let validUserId = record.userId
            if (record.userId) {
              const mappedUserId = userIdMapping.get(record.userId)
              if (mappedUserId) {
                validUserId = mappedUserId
              } else {
                const userExists = await tx.query.users.findFirst({
                  where: eq(users.id, record.userId)
                })
                if (!userExists) {
                  console.warn(`用户状态日志的用户ID ${record.userId} 不存在，跳过`)
                  return
                }
              }
            } else {
              return
            }

            const userStatusLogData = {
              userId: validUserId,
              username: record.username ?? null,
              name: record.name ?? null,
              oldStatus: record.oldStatus || record.previousStatus || null,
              newStatus: record.newStatus,
              reason: record.reason || null,
              operatorId: record.operatorId || record.changedBy || null,
              createdAt: record.createdAt ? new Date(record.createdAt) : new Date()
            }

            if (mode === 'merge') {
              await tx.insert(userStatusLogs).values(userStatusLogData)
              stats.created++
            } else {
              if (record.id) {
                const existingLog = await tx.query.userStatusLogs.findFirst({
                  where: eq(userStatusLogs.id, record.id)
                })

                if (existingLog) {
                  await tx
                    .update(userStatusLogs)
                    .set(userStatusLogData)
                    .where(eq(userStatusLogs.id, record.id))
                  stats.updated++
                } else {
                  await tx.insert(userStatusLogs).values({
                    ...userStatusLogData,
                    id: record.id
                  })
                  stats.created++
                }
              } else {
                await tx.insert(userStatusLogs).values(userStatusLogData)
                stats.created++
              }
            }
            break
          }

          case 'cardCodes': {
            const cardCodeData: any = {}
            const cardCodeFields = ['code', 'status', 'note']
            cardCodeFields.forEach((field) => {
              if (record.hasOwnProperty(field)) {
                cardCodeData[field] = record[field]
              }
            })

            if (!cardCodeData.code) return

            const mapUserId = async (field: 'lockedBy' | 'redeemedBy') => {
              if (!record[field]) return null
              const mappedUserId = userIdMapping.get(record[field])
              if (mappedUserId) return mappedUserId
              if (mode === 'merge') return null
              const userExists = await tx.query.users.findFirst({
                where: eq(users.id, record[field])
              })
              return userExists ? record[field] : null
            }

            cardCodeData.lockedBy = await mapUserId('lockedBy')
            cardCodeData.redeemedBy = await mapUserId('redeemedBy')
            cardCodeData.lockedAt = record.lockedAt ? new Date(record.lockedAt) : null
            cardCodeData.redeemedAt = record.redeemedAt ? new Date(record.redeemedAt) : null
            cardCodeData.createdAt = record.createdAt ? new Date(record.createdAt) : new Date()
            cardCodeData.updatedAt = record.updatedAt ? new Date(record.updatedAt) : new Date()

            let restoredCardCode
            if (mode === 'merge') {
              const existing = await tx.query.cardCodes.findFirst({
                where: eq(cardCodes.code, cardCodeData.code)
              })
              if (existing) {
                restoredCardCode = (
                  await tx
                    .update(cardCodes)
                    .set(cardCodeData)
                    .where(eq(cardCodes.id, existing.id))
                    .returning()
                )[0]
                stats.updated++
              } else {
                restoredCardCode = (await tx.insert(cardCodes).values(cardCodeData).returning())[0]
                stats.created++
              }
            } else {
              const existing = await tx.query.cardCodes.findFirst({
                where: eq(cardCodes.id, record.id)
              })
              if (existing) {
                restoredCardCode = (
                  await tx
                    .update(cardCodes)
                    .set(cardCodeData)
                    .where(eq(cardCodes.id, record.id))
                    .returning()
                )[0]
                stats.updated++
              } else {
                restoredCardCode = (
                  await tx
                    .insert(cardCodes)
                    .values({ ...cardCodeData, id: record.id })
                    .returning()
                )[0]
                stats.created++
              }
            }

            if (record.id && restoredCardCode?.id) {
              newMappings.cardCodes[record.id] = restoredCardCode.id
            }
            break
          }

          case 'songs': {
            let validRequesterId = record.requesterId
            let validPreferredPlayTimeId = record.preferredPlayTimeId

            if (record.requesterId) {
              const mappedUserId = userIdMapping.get(record.requesterId)
              if (mappedUserId) {
                validRequesterId = mappedUserId
              } else {
                const userExists = await tx.query.users.findFirst({
                  where: eq(users.id, record.requesterId)
                })
                if (!userExists) {
                  console.warn(`歌曲请求者ID ${record.requesterId} 不存在，跳过`)
                  return
                }
              }
            } else {
              return
            }

            if (record.preferredPlayTimeId) {
              const playTimeExists = await tx.query.playTimes.findFirst({
                where: eq(playTimes.id, record.preferredPlayTimeId)
              })
              if (!playTimeExists) {
                validPreferredPlayTimeId = null
              }
            }

            let validCardCodeId = record.cardCodeId || null
            if (record.cardCodeId) {
              const mappedCardCodeId = cardCodeIdMapping.get(record.cardCodeId)
              if (mappedCardCodeId) {
                validCardCodeId = mappedCardCodeId
              } else {
                const cardCodeExists = await tx.query.cardCodes.findFirst({
                  where: eq(cardCodes.id, record.cardCodeId)
                })
                if (!cardCodeExists) {
                  validCardCodeId = null
                }
              }
            }

            const songData: any = {
              requesterId: validRequesterId,
              preferredPlayTimeId: validPreferredPlayTimeId,
              cardCodeId: validCardCodeId,
              played: record.hasOwnProperty('played') ? record.played : false
            }

            const songFields = [
              'title',
              'artist',
              'semester',
              'cover',
              'musicPlatform',
              'musicId',
              'durationSeconds',
              'submissionNote',
              'submissionNotePublic',
              'submissionNotePublicStatus'
            ]
            songFields.forEach((field) => {
              if (record.hasOwnProperty(field)) {
                songData[field] = record[field]
              }
            })

            if (record.playedAt) songData.playedAt = new Date(record.playedAt)
            else songData.playedAt = null

            if (record.createdAt) songData.createdAt = new Date(record.createdAt)
            else songData.createdAt = new Date()

            if (record.updatedAt) songData.updatedAt = new Date(record.updatedAt)
            else songData.updatedAt = new Date()

            let createdSong
            if (mode === 'merge') {
              const existingSong = await tx.query.songs.findFirst({
                where: and(eq(songs.title, record.title), eq(songs.artist, record.artist))
              })

              if (existingSong) {
                createdSong = (
                  await tx
                    .update(songs)
                    .set(songData)
                    .where(eq(songs.id, existingSong.id))
                    .returning()
                )[0]
                stats.updated++
              } else {
                try {
                  const existingSongWithId = await tx.query.songs.findFirst({
                    where: eq(songs.id, record.id)
                  })

                  if (existingSongWithId) {
                    createdSong = (await tx.insert(songs).values(songData).returning())[0]
                  } else {
                    createdSong = (
                      await tx
                        .insert(songs)
                        .values({
                          ...songData,
                          id: record.id
                        })
                        .returning()
                    )[0]
                  }
                } catch (error) {
                  createdSong = (await tx.insert(songs).values(songData).returning())[0]
                }
                stats.created++
              }
            } else {
              const existingSongWithId = await tx.query.songs.findFirst({
                where: eq(songs.id, record.id)
              })

              if (existingSongWithId) {
                createdSong = (
                  await tx.update(songs).set(songData).where(eq(songs.id, record.id)).returning()
                )[0]
                stats.updated++
              } else {
                createdSong = (
                  await tx
                    .insert(songs)
                    .values({
                      ...songData,
                      id: record.id
                    })
                    .returning()
                )[0]
                stats.created++
              }
            }

            if (record.id && createdSong.id) {
              newMappings.songs[record.id] = createdSong.id
            }
            break
          }

          case 'playTimes': {
            const playTimeData: any = {}
            const playTimeFields = ['name', 'startTime', 'endTime', 'description']
            playTimeFields.forEach((field) => {
              if (record.hasOwnProperty(field)) {
                playTimeData[field] = record[field]
              }
            })
            playTimeData.enabled = record.hasOwnProperty('enabled') ? record.enabled : true

            if (mode === 'merge') {
              const existingPlayTime = await tx.query.playTimes.findFirst({
                where: eq(playTimes.name, record.name)
              })

              if (existingPlayTime) {
                await tx
                  .update(playTimes)
                  .set(playTimeData)
                  .where(eq(playTimes.id, existingPlayTime.id))
                stats.updated++
              } else {
                await tx.insert(playTimes).values(playTimeData)
                stats.created++
              }
            } else {
              const existingPlayTimeWithId = await tx.query.playTimes.findFirst({
                where: eq(playTimes.id, record.id)
              })

              if (existingPlayTimeWithId) {
                await tx.update(playTimes).set(playTimeData).where(eq(playTimes.id, record.id))
                stats.updated++
              } else {
                await tx.insert(playTimes).values({
                  ...playTimeData,
                  id: record.id
                })
                stats.created++
              }
            }
            break
          }

          case 'semesters': {
            const semesterData: any = {}
            const semesterFields = ['name']
            semesterFields.forEach((field) => {
              if (record.hasOwnProperty(field)) {
                semesterData[field] = record[field]
              }
            })
            semesterData.isActive = record.hasOwnProperty('isActive') ? record.isActive : false
            if (record.createdAt) semesterData.createdAt = new Date(record.createdAt)

            if (mode === 'merge') {
              const existingSemester = await tx.query.semesters.findFirst({
                where: eq(semesters.name, semesterData.name)
              })
              if (existingSemester) {
                await tx
                  .update(semesters)
                  .set(semesterData)
                  .where(eq(semesters.id, existingSemester.id))
                stats.updated++
              } else {
                await tx.insert(semesters).values(semesterData)
                stats.created++
              }
            } else {
              const existing = await tx.query.semesters.findFirst({
                where: eq(semesters.id, record.id)
              })
              if (existing) {
                await tx.update(semesters).set(semesterData).where(eq(semesters.id, record.id))
                stats.updated++
              } else {
                await tx.insert(semesters).values({ ...semesterData, id: record.id })
                stats.created++
              }
            }
            break
          }

          case 'gradeClass': {
            const gradeClassData: any = {}
            const gradeClassFields = ['grade', 'class']
            gradeClassFields.forEach((field) => {
              if (record.hasOwnProperty(field)) {
                gradeClassData[field] =
                  typeof record[field] === 'string' ? record[field].trim() : record[field]
              }
            })
            // 空行直接跳过，避免空值配置行锁死配置优先校验
            if (!gradeClassData.grade || !gradeClassData.class) {
              stats.warnings.push(`gradeClass 记录 ${record.id ?? ''} 年级或班级为空，已跳过`)
              break
            }

            if (mode === 'merge') {
              const existingGradeClass = await tx.query.gradeClass.findFirst({
                where: and(
                  eq(gradeClass.grade, gradeClassData.grade),
                  eq(gradeClass.class, gradeClassData.class)
                )
              })
              if (!existingGradeClass) {
                await tx.insert(gradeClass).values(gradeClassData)
                stats.created++
              }
            } else {
              const existing = await tx.query.gradeClass.findFirst({
                where: eq(gradeClass.id, record.id)
              })
              if (!existing) {
                await tx.insert(gradeClass).values({ ...gradeClassData, id: record.id })
                stats.created++
              }
            }
            break
          }

          case 'systemSettings': {
            let systemSettingsData: any = {}
            const fields = [
              'enablePlayTimeSelection',
              'instanceId',
              'defaultTheme',
              'enabledThemes',
              'telemetryEnabled',
              'siteTitle',
              'siteLogoUrl',
              'schoolLogoHomeUrl',
              'schoolLogoPrintUrl',
              'siteDescription',
              'submissionGuidelines',
              'icpNumber',
              'gonganNumber',
              'enableSubmissionLimit',
              'dailySubmissionLimit',
              'weeklySubmissionLimit',
              'monthlySubmissionLimit',
              'scheduleDaysBeforeEnabled',
              'scheduleDaysBefore',
              'scheduleDaysAfterEnabled',
              'scheduleDaysAfter',
              'showBlacklistKeywords',
              'hideStudentInfo',
              'enableReplayRequests',
              'enableCollaborativeSubmission',
              'enableSubmissionRemarks',
              'enableCardCodeRequests',
              'requireCardCodeForRequests',
              'enableCardCodeLimitBypass',
              'enableSubmissionRestriction',
              'submissionRestrictionScope',
              'sameSongRestrictionHours',
              'sameArtistRestrictionHours',
              'enableRequestTimeLimitation',
              'forceBlockAllRequests',
              'forcePasswordChangeOnFirstLogin',
              'smtpEnabled',
              'smtpHost',
              'smtpPort',
              'smtpSecure',
              'smtpUsername',
              'smtpPassword',
              'smtpFromEmail',
              'smtpFromName',
              'allowOAuthRegistration',
              'allowRegister',
              'registerRequiresApproval',
                'registerEmailRequired',
              'registerRequiresGradeClass',
              'oauthRegisterRequiresApproval',
              'submissionNoteRequiresApproval',
              'oauthRedirectUri',
              'oauthStateSecret',
              'oauthProviders',
              'githubOAuthEnabled',
              'githubClientId',
              'githubClientSecret',
              'casdoorOAuthEnabled',
              'casdoorServerUrl',
              'casdoorClientId',
              'casdoorClientSecret',
              'casdoorOrganizationName',
              'googleOAuthEnabled',
              'googleClientId',
              'googleClientSecret',
              'aggregateOAuthEnabled',
              'aggregateOAuthAppId',
              'aggregateOAuthAppKey',
              'aggregateOAuthLoginType',
              'aggregateOAuthEndpoint',
              'customOAuthEnabled',
              'customOAuthDisplayName',
              'customOAuthAuthorizeUrl',
              'customOAuthTokenUrl',
              'customOAuthUserInfoUrl',
              'customOAuthScope',
              'customOAuthClientId',
              'customOAuthClientSecret',
              'customOAuthUserIdField',
              'customOAuthUsernameField',
              'customOAuthNameField',
              'customOAuthEmailField',
              'customOAuthAvatarField',
              'captchaEnabled',
              'captchaMaxFailures',
              'captchaProvider',
              'turnstileSiteKey',
              'turnstileSecretKey',
              'autoBackupEnabled',
              'autoBackupConfig',
              'statisticsCodeEnabled',
              'statisticsCode',
              'enabledPlatforms',
              'platformOrder'
            ]
            fields.forEach((field) => {
              if (record.hasOwnProperty(field)) systemSettingsData[field] = record[field]
            })
            if (Object.prototype.hasOwnProperty.call(systemSettingsData, 'defaultTheme') || Object.prototype.hasOwnProperty.call(systemSettingsData, 'enabledThemes')) {
              if (!Object.prototype.hasOwnProperty.call(systemSettingsData, 'defaultTheme') || !Object.prototype.hasOwnProperty.call(systemSettingsData, 'enabledThemes')) {
                throw createApiError(400, SERVER_ERROR_CODES.THEME_INVALID_LIST, '主题配置必须同时包含默认主题和启用主题列表')
              }
              systemSettingsData.enabledThemes = JSON.stringify(validateThemeConfig(systemSettingsData.defaultTheme, systemSettingsData.enabledThemes))
            }
            for (const field of ['scheduleDaysBeforeEnabled', 'scheduleDaysAfterEnabled']) {
              if (Object.prototype.hasOwnProperty.call(systemSettingsData, field) && systemSettingsData[field] !== null && typeof systemSettingsData[field] !== 'boolean') {
                throw createApiError(400, SERVER_ERROR_CODES.COMMON_INVALID_PARAMS, `${field} 必须是布尔值`)
              }
            }
            for (const field of ['scheduleDaysBefore', 'scheduleDaysAfter']) {
              if (Object.prototype.hasOwnProperty.call(systemSettingsData, field) && (systemSettingsData[field] !== null && (!Number.isInteger(systemSettingsData[field]) || systemSettingsData[field] < 1 || systemSettingsData[field] > 730))) {
                throw createApiError(400, SERVER_ERROR_CODES.COMMON_INVALID_PARAMS, `${field} 必须是 1-730 的正整数`)
              }
            }
            systemSettingsData = normalizeScheduleVisibilitySettings(systemSettingsData)
            systemSettingsData = omitMaskedSystemSettingsSecrets(systemSettingsData)

            if (mode === 'merge') {
              const existing = await tx.query.systemSettings.findFirst()
              if (existing) {
                await tx
                  .update(systemSettings)
                  .set(systemSettingsData)
                  .where(eq(systemSettings.id, existing.id))
                stats.updated++
              } else {
                await tx.insert(systemSettings).values(systemSettingsData)
                stats.created++
              }
            } else {
              const existing = await tx.query.systemSettings.findFirst({
                where: eq(systemSettings.id, record.id)
              })
              if (existing) {
                await tx
                  .update(systemSettings)
                  .set(systemSettingsData)
                  .where(eq(systemSettings.id, record.id))
                stats.updated++
              } else {
                await tx.insert(systemSettings).values({ ...systemSettingsData, id: record.id })
                stats.created++
              }
            }
            break
          }

          case 'emailTemplates': {
            // 邮件模板（按 key 去重：merge 模式同名 key 覆盖）
            if (!record.key || !record.name || !record.subject) return
            const templateData: any = {
              key: record.key,
              name: record.name,
              subject: record.subject,
              html: record.html || ''
            }
            if (record.contentType) templateData.contentType = record.contentType
            if (record.headerSubtitle) templateData.headerSubtitle = record.headerSubtitle
            if (record.actionText) templateData.actionText = record.actionText
            if (record.actionUrl) templateData.actionUrl = record.actionUrl
            if (record.updatedByUserId) templateData.updatedByUserId = record.updatedByUserId
            if (record.createdAt) templateData.createdAt = new Date(record.createdAt)
            if (record.updatedAt) templateData.updatedAt = new Date(record.updatedAt)

            if (mode === 'merge') {
              const existing = await tx.query.emailTemplates.findFirst({
                where: eq(emailTemplates.key, record.key)
              })
              if (existing) {
                await tx.update(emailTemplates).set(templateData).where(eq(emailTemplates.id, existing.id))
                stats.updated++
              } else {
                await tx.insert(emailTemplates).values(templateData)
                stats.created++
              }
            } else {
              const existing = await tx.query.emailTemplates.findFirst({
                where: eq(emailTemplates.id, record.id)
              })
              if (existing) {
                await tx.update(emailTemplates).set(templateData).where(eq(emailTemplates.id, record.id))
                stats.updated++
              } else {
                await tx.insert(emailTemplates).values({ ...templateData, id: record.id })
                stats.created++
              }
            }
            break
          }

          case 'schedules': {
            if (!record.songId || !record.playDate) return

            let validSongId = record.songId
            const mappedSongId = songIdMapping.get(record.songId)
            if (mappedSongId) {
              validSongId = mappedSongId
            } else {
              const songExists = await tx.query.songs.findFirst({
                where: eq(songs.id, record.songId)
              })
              if (!songExists) return
            }

            let validPlayTimeId = record.playTimeId
            if (record.playTimeId) {
              const ptExists = await tx.query.playTimes.findFirst({
                where: eq(playTimes.id, record.playTimeId)
              })
              if (!ptExists) validPlayTimeId = null
            }

            const scheduleData: any = {
              songId: validSongId,
              playDate: new Date(record.playDate),
              playTimeId: validPlayTimeId,
              played: record.hasOwnProperty('played') ? record.played : false,
              sequence: record.hasOwnProperty('sequence') ? record.sequence : 1
            }
            if (record.publishedAt) scheduleData.publishedAt = new Date(record.publishedAt)
            if (record.isDraft !== undefined) scheduleData.isDraft = record.isDraft

            if (mode === 'merge') {
              const existing = await tx.query.schedules.findFirst({
                where: and(
                  eq(schedules.songId, validSongId),
                  eq(schedules.playDate, scheduleData.playDate)
                )
              })
              if (existing) {
                await tx.update(schedules).set(scheduleData).where(eq(schedules.id, existing.id))
                stats.updated++
              } else {
                await tx.insert(schedules).values(scheduleData)
                stats.created++
              }
            } else {
              const existing = await tx.query.schedules.findFirst({
                where: eq(schedules.id, record.id)
              })
              if (existing) {
                await tx.update(schedules).set(scheduleData).where(eq(schedules.id, record.id))
                stats.updated++
              } else {
                await tx.insert(schedules).values({ ...scheduleData, id: record.id })
                stats.created++
              }
            }
            break
          }

          case 'notificationSettings': {
            let validUserId = record.userId
            if (record.userId) {
              const mappedUserId = userIdMapping.get(record.userId)
              if (mappedUserId) validUserId = mappedUserId
              else {
                const userExists = await tx.query.users.findFirst({
                  where: eq(users.id, record.userId)
                })
                if (!userExists) return
              }
            }

            const notificationSettingsData: any = { userId: validUserId }
            const fields = ['refreshInterval', 'songVotedThreshold', 'meowUserId']
            fields.forEach((field) => {
              if (record.hasOwnProperty(field)) notificationSettingsData[field] = record[field]
            })
            notificationSettingsData.enabled = record.hasOwnProperty('enabled')
              ? record.enabled
              : true
            notificationSettingsData.songRequestEnabled = record.hasOwnProperty(
              'songRequestEnabled'
            )
              ? record.songRequestEnabled
              : true
            notificationSettingsData.songVotedEnabled = record.hasOwnProperty('songVotedEnabled')
              ? record.songVotedEnabled
              : true
            notificationSettingsData.songPlayedEnabled = record.hasOwnProperty('songPlayedEnabled')
              ? record.songPlayedEnabled
              : true

            if (!notificationSettingsData.refreshInterval)
              notificationSettingsData.refreshInterval = 60
            if (!notificationSettingsData.songVotedThreshold)
              notificationSettingsData.songVotedThreshold = 1

            notificationSettingsData.createdAt = record.createdAt
              ? new Date(record.createdAt)
              : new Date()
            notificationSettingsData.updatedAt = record.updatedAt
              ? new Date(record.updatedAt)
              : new Date()

            if (mode === 'merge') {
              const existing = await tx.query.notificationSettings.findFirst({
                where: eq(notificationSettings.userId, validUserId)
              })
              if (existing) {
                await tx
                  .update(notificationSettings)
                  .set(notificationSettingsData)
                  .where(eq(notificationSettings.id, existing.id))
                stats.updated++
              } else {
                await tx.insert(notificationSettings).values(notificationSettingsData)
                stats.created++
              }
            } else {
              const existing = await tx.query.notificationSettings.findFirst({
                where: eq(notificationSettings.id, record.id)
              })
              if (existing) {
                await tx
                  .update(notificationSettings)
                  .set(notificationSettingsData)
                  .where(eq(notificationSettings.id, record.id))
                stats.updated++
              } else {
                await tx
                  .insert(notificationSettings)
                  .values({ ...notificationSettingsData, id: record.id })
                stats.created++
              }
            }
            break
          }

          case 'notifications': {
            let validUserId = record.userId
            if (record.userId) {
              const mappedUserId = userIdMapping.get(record.userId)
              if (mappedUserId) validUserId = mappedUserId
              else {
                const userExists = await tx.query.users.findFirst({
                  where: eq(users.id, record.userId)
                })
                if (!userExists) return
              }
            }

            const notificationData: any = { userId: validUserId }
            const fields = [
              'batchId',
              'source',
              'senderName',
              'senderUsername',
              'title',
              'message',
              'type',
              'userDeleted'
            ]
            fields.forEach((field) => {
              if (record.hasOwnProperty(field)) notificationData[field] = record[field]
            })
            // senderId 需要重新映射到目标库的用户 ID；映射未命中时回查同 ID 用户并比对用户名快照，
            // 不一致则置空，避免跨库恢复时将发送人归属到错误用户，展示仍靠快照字段
            if (Object.prototype.hasOwnProperty.call(record, 'senderId')) {
              if (record.senderId) {
                const mappedSenderId = userIdMapping.get(record.senderId)
                if (mappedSenderId) {
                  notificationData.senderId = mappedSenderId
                } else {
                  const senderExists = await tx.query.users.findFirst({
                    where: eq(users.id, record.senderId)
                  })
                  notificationData.senderId =
                    senderExists && senderExists.username === record.senderUsername
                      ? record.senderId
                      : null
                }
              } else {
                notificationData.senderId = null
              }
            }
            notificationData.read = record.hasOwnProperty('read') ? record.read : false
            notificationData.important = Object.prototype.hasOwnProperty.call(record, 'important')
              ? record.important
              : false
            notificationData.createdAt = record.createdAt ? new Date(record.createdAt) : new Date()
            notificationData.updatedAt = record.updatedAt ? new Date(record.updatedAt) : new Date()

            if (mode === 'merge') {
              const existing = await tx.query.notifications.findFirst({
                where: and(
                  eq(notifications.userId, validUserId),
                  eq(notifications.type, record.type),
                  eq(notifications.message, record.message)
                )
              })
              if (existing) {
                await tx
                  .update(notifications)
                  .set(notificationData)
                  .where(eq(notifications.id, existing.id))
                stats.updated++
              } else {
                await tx.insert(notifications).values(notificationData)
                stats.created++
              }
            } else {
              const existing = await tx.query.notifications.findFirst({
                where: eq(notifications.id, record.id)
              })
              if (existing) {
                await tx
                  .update(notifications)
                  .set(notificationData)
                  .where(eq(notifications.id, record.id))
                stats.updated++
              } else {
                await tx.insert(notifications).values({ ...notificationData, id: record.id })
                stats.created++
              }
            }
            break
          }

          case 'songBlacklist': {
            let validCreatedBy = record.createdBy
            if (record.createdBy) {
              const mappedUserId = userIdMapping.get(record.createdBy)
              if (mappedUserId) validCreatedBy = mappedUserId
              else {
                const userExists = await tx.query.users.findFirst({
                  where: eq(users.id, record.createdBy)
                })
                if (!userExists) validCreatedBy = null
              }
            }

            const blacklistData: any = {
              type: record.type || 'KEYWORD',
              value: record.value || '',
              reason: record.reason || null,
              isActive: record.hasOwnProperty('isActive') ? record.isActive : true,
              createdBy: validCreatedBy,
              createdAt: record.createdAt ? new Date(record.createdAt) : new Date(),
              updatedAt: record.updatedAt ? new Date(record.updatedAt) : new Date()
            }

            if (mode === 'merge') {
              const existing = await tx.query.songBlacklists.findFirst({
                where: and(
                  eq(songBlacklists.type, blacklistData.type),
                  eq(songBlacklists.value, blacklistData.value)
                )
              })
              if (existing) {
                await tx
                  .update(songBlacklists)
                  .set(blacklistData)
                  .where(eq(songBlacklists.id, existing.id))
                stats.updated++
              } else {
                await tx.insert(songBlacklists).values(blacklistData)
                stats.created++
              }
            } else {
              const existing = await tx.query.songBlacklists.findFirst({
                where: eq(songBlacklists.id, record.id)
              })
              if (existing) {
                await tx
                  .update(songBlacklists)
                  .set(blacklistData)
                  .where(eq(songBlacklists.id, record.id))
                stats.updated++
              } else {
                await tx.insert(songBlacklists).values({ ...blacklistData, id: record.id })
                stats.created++
              }
            }
            break
          }

          case 'cardCodeRedeemLogs': {
            let validCardCodeId = record.cardCodeId || null
            if (record.cardCodeId) {
              const mappedCardCodeId = cardCodeIdMapping.get(record.cardCodeId)
              if (mappedCardCodeId) {
                validCardCodeId = mappedCardCodeId
              } else {
                const cardCodeExists = await tx.query.cardCodes.findFirst({
                  where: eq(cardCodes.id, record.cardCodeId)
                })
                if (!cardCodeExists) validCardCodeId = null
              }
            }

            let validRedeemedBy = record.redeemedBy
            if (record.redeemedBy) {
              const mappedUserId = userIdMapping.get(record.redeemedBy)
              if (mappedUserId) {
                validRedeemedBy = mappedUserId
              } else {
                const userExists = await tx.query.users.findFirst({
                  where: eq(users.id, record.redeemedBy)
                })
                if (!userExists) return
              }
            } else return

            let validSongId = record.songId || null
            if (record.songId) {
              const mappedSongId = songIdMapping.get(record.songId)
              if (mappedSongId) {
                validSongId = mappedSongId
              } else {
                const songExists = await tx.query.songs.findFirst({
                  where: eq(songs.id, record.songId)
                })
                if (!songExists) validSongId = null
              }
            }

            const logData: any = {
              cardCodeId: validCardCodeId,
              codeSnapshot: record.codeSnapshot,
              redeemedBy: validRedeemedBy,
              redeemedAt: record.redeemedAt ? new Date(record.redeemedAt) : new Date(),
              source: record.source || 'UNKNOWN',
              songId: validSongId,
              createdAt: record.createdAt ? new Date(record.createdAt) : new Date()
            }

            if (!logData.codeSnapshot) return

            if (mode === 'merge') {
              await tx.insert(cardCodeRedeemLogs).values(logData)
              stats.created++
            } else {
              const existing = await tx.query.cardCodeRedeemLogs.findFirst({
                where: eq(cardCodeRedeemLogs.id, record.id)
              })
              if (existing) {
                await tx
                  .update(cardCodeRedeemLogs)
                  .set(logData)
                  .where(eq(cardCodeRedeemLogs.id, record.id))
                stats.updated++
              } else {
                await tx.insert(cardCodeRedeemLogs).values({ ...logData, id: record.id })
                stats.created++
              }
            }
            break
          }

          case 'votes': {
            let validUserId = record.userId
            if (record.userId) {
              const mappedUserId = userIdMapping.get(record.userId)
              if (mappedUserId) validUserId = mappedUserId
              else {
                const userExists = await tx.query.users.findFirst({
                  where: eq(users.id, record.userId)
                })
                if (!userExists) return
              }
            } else return

            let validSongId = record.songId
            if (record.songId) {
              const mappedSongId = songIdMapping.get(record.songId)
              if (mappedSongId) validSongId = mappedSongId
              else {
                const songExists = await tx.query.songs.findFirst({
                  where: eq(songs.id, record.songId)
                })
                if (!songExists) return
              }
            } else return

            const voteData: any = {
              userId: validUserId,
              songId: validSongId,
              createdAt: record.createdAt ? new Date(record.createdAt) : new Date()
            }

            // 对于投票，merge和replace模式下都需要检查重复，因为联合主键或唯一约束
            const existing = await tx.query.votes.findFirst({
              where: and(eq(votes.userId, validUserId), eq(votes.songId, validSongId))
            })

            if (existing) {
              await tx.update(votes).set(voteData).where(eq(votes.id, existing.id))
              stats.updated++
            } else {
              await tx.insert(votes).values(voteData)
              stats.created++
            }
            break
          }

          case 'scheduleSongPool': {
            await restoreScheduleSongPoolRecord(tx, record, songIdMapping, userIdMapping, stats, () => { stats.created++ })
            break
          }
        }
      })
      stats.processed++
    } catch (error) {
      console.error(`处理记录失败 (${tableName}):`, error)
      stats.errors++
      stats.warnings.push(`记录处理失败: ${error.message}`)
    }
  }

  // 防锁死：恢复系统设置块后校验 SMTP 已配置，否则剥离 registerEmailRequired
  // （避免恢复后注册必填邮箱却无法发码）
  if (tableName === 'systemSettings') {
    try {
      const restoredSettings = await db.select().from(systemSettings).limit(1)
      if (
        restoredSettings[0]?.registerEmailRequired &&
        (!restoredSettings[0]?.smtpEnabled || !restoredSettings[0]?.smtpHost)
      ) {
        await db
          .update(systemSettings)
          .set({ registerEmailRequired: false })
          .where(eq(systemSettings.id, restoredSettings[0].id))
        stats.warnings.push('SMTP 未配置，已剥离 registerEmailRequired，避免注册邮箱流程不可用')
      }
    } catch (settingsError) {
      console.error('恢复后设置一致性校验失败:', settingsError)
    }
  }

  // 恢复可能携带显式 id，完成后同步所有自增序列，避免后续插入主键冲突
  try {
    await syncAllSequences()
  } catch (seqError) {
    const seqErrorMsg = seqError instanceof Error ? seqError.message : '未知错误'
    stats.warnings.push(`自增序列同步失败: ${seqErrorMsg}`)
    console.error('自增序列同步失败:', seqError)
  }

  return {
    success: true,
    newMappings,
    stats
  }
})