import type { Request, Response } from 'express'
import { Prisma } from '@prisma/client'
import prisma from '../utils/prisma'
import { successResponse, errorResponse } from '../utils/response'
import { logOperation } from './operationLogController'
import { calculateEquipmentValues } from '../utils/assetValue'
import { loadAndLockAssetTree, lockEquipmentRows } from '../services/assetMovementService'
import {
  assertDisposalItemsConfirmed, DisposalConflictError, disposalTreeSelect, getDisposalBlockedReason,
  getDisposalOccupancy, loadDisposalTrees, MAX_DISPOSAL_BATCH_ROOTS, type DisposalTreeItem
} from '../utils/disposalSubmission'
import {
  createBusinessNotification,
  escapeNotificationMarkdownInline,
  findActiveDingTalkUsersByIds,
  findActiveDingTalkUsersByRoles,
  findActiveStationUsersByIds,
  findActiveStationUsersByRoles,
  formatBeijingDateTime,
  getCurrentDingTalkRecipientRollout,
  mergeRecipients
} from '../services/businessNotificationService'

const disposalInclude = {
  equipment: true,
  applier: { select: { id: true, name: true, username: true } },
  approver: { select: { id: true, name: true, username: true } },
  completer: { select: { id: true, name: true, username: true } },
  items: {
    orderBy: { id: 'asc' as const },
    include: {
      equipment: {
        select: {
          id: true,
          equipment_code: true,
          equipment_name: true,
          equipment_model: true,
          equipment_type: true,
          status: true,
          parent_id: true,
          storage_location_id: true,
          department_id: true
        }
      }
    }
  },
  actions: {
    orderBy: [{ created_at: 'asc' as const }, { id: 'asc' as const }],
    include: { operator: { select: { id: true, name: true, username: true } } }
  }
}

const updateEquipmentLifecycle = async (
  tx: Prisma.TransactionClient,
  equipment: {
    id: number
    unit_price: Prisma.Decimal
    total_quantity: number
    remaining_quantity: number
    status: string
    parent_id: number | null
    department_id: number | null
    mount_status: string
    updated_at: Date
  },
  targetStatus: string,
  expectedStatus: string,
  expectedParentId: number | null = equipment.parent_id
) => {
  const remainingQuantity = targetStatus === '已借出' ? 0 : equipment.remaining_quantity
  const values = calculateEquipmentValues({
    unitPrice: Number(equipment.unit_price),
    totalQuantity: equipment.total_quantity,
    remainingQuantity,
    status: targetStatus
  })
  const updated = await tx.equipment.updateMany({
    where: {
      id: equipment.id,
      status: expectedStatus,
      parent_id: expectedParentId,
      department_id: equipment.department_id,
      mount_status: equipment.mount_status,
      remaining_quantity: equipment.remaining_quantity,
      updated_at: equipment.updated_at
    },
    data: {
      status: targetStatus,
      total_value: values.total_value,
      borrowed_value: values.borrowed_value,
      available_value: values.available_value
    }
  })
  if (updated.count !== 1) {
    throw new DisposalConflictError('资产状态或挂载关系已变化，请刷新后重试')
  }
}

const excludeApplicant = <T extends { id: number }>(recipients: T[], applicantId: number) =>
  recipients.filter((recipient) => recipient.id !== applicantId)

const getSubmissionRecipients = async (tx: Prisma.TransactionClient, applicantId: number) => {
  const rollout = getCurrentDingTalkRecipientRollout()
  const [stationAdministrative, dingTalkAdministrative] = await Promise.all([
    findActiveStationUsersByRoles(tx, ['administrative']),
    findActiveDingTalkUsersByRoles(tx, ['administrative'], rollout)
  ])
  const eligibleStationAdministrative = excludeApplicant(stationAdministrative, applicantId)
  const eligibleDingTalkAdministrative = excludeApplicant(dingTalkAdministrative, applicantId)
  const stationRecipients = eligibleStationAdministrative.length > 0
    ? eligibleStationAdministrative
    : await findActiveStationUsersByRoles(tx, ['admin'])
  const dingTalkRecipients = eligibleDingTalkAdministrative.length > 0
    ? eligibleDingTalkAdministrative
    : await findActiveDingTalkUsersByRoles(tx, ['admin'], rollout)
  return { stationRecipients, dingTalkRecipients }
}

const getResultRecipients = async (tx: Prisma.TransactionClient, applierId: number) => {
  const rollout = getCurrentDingTalkRecipientRollout()
  const [stationApplier, stationAdministrative, dingTalkApplier, dingTalkAdministrative] = await Promise.all([
    findActiveStationUsersByIds(tx, [applierId]),
    findActiveStationUsersByRoles(tx, ['administrative']),
    findActiveDingTalkUsersByIds(tx, [applierId], rollout),
    findActiveDingTalkUsersByRoles(tx, ['administrative'], rollout)
  ])
  let stationRecipients = mergeRecipients(stationApplier, stationAdministrative)
  if (stationApplier.length === 0 || stationAdministrative.length === 0) {
    stationRecipients = mergeRecipients(
      stationRecipients,
      await findActiveStationUsersByRoles(tx, ['admin'])
    )
  }
  let dingTalkRecipients = mergeRecipients(dingTalkApplier, dingTalkAdministrative)
  if (dingTalkApplier.length === 0 || dingTalkAdministrative.length === 0) {
    dingTalkRecipients = mergeRecipients(
      dingTalkRecipients,
      await findActiveDingTalkUsersByRoles(tx, ['admin'], rollout)
    )
  }
  return { stationRecipients, dingTalkRecipients }
}

const assetNotificationName = (name: unknown, code: unknown) =>
  `${escapeNotificationMarkdownInline(name, '资产')}（${escapeNotificationMarkdownInline(code, '无编码')}）`

export const buildDisposalAppliedDingTalkContent = (input: {
  appliedAt: Date
  equipmentName: unknown
  equipmentCode: unknown
  applicantName: unknown
  reason: unknown
}) => [
  `**申请时间：** ${formatBeijingDateTime(input.appliedAt)}`,
  `**资产：** ${assetNotificationName(input.equipmentName, input.equipmentCode)}`,
  `**申请人：** ${escapeNotificationMarkdownInline(input.applicantName)}`,
  `**报废原因：** ${escapeNotificationMarkdownInline(input.reason)}`,
  '> 请核对资产及配件明细后处理。'
].join('\n\n')

export const buildDisposalApprovedDingTalkContent = (input: {
  approvedAt: Date
  equipmentName: unknown
  equipmentCode: unknown
  approverName: unknown
}) => [
  `**审批时间：** ${formatBeijingDateTime(input.approvedAt)}`,
  `**资产：** ${assetNotificationName(input.equipmentName, input.equipmentCode)}`,
  `**审批人：** ${escapeNotificationMarkdownInline(input.approverName)}`,
  '**审批结果：** 已通过',
  '> 报废单现已进入待处置阶段。'
].join('\n\n')

export const buildDisposalRejectedDingTalkContent = (input: {
  rejectedAt: Date
  equipmentName: unknown
  equipmentCode: unknown
  rejectorName: unknown
  reason: unknown
}) => [
  `**驳回时间：** ${formatBeijingDateTime(input.rejectedAt)}`,
  `**资产：** ${assetNotificationName(input.equipmentName, input.equipmentCode)}`,
  `**驳回人：** ${escapeNotificationMarkdownInline(input.rejectorName)}`,
  `**驳回原因：** ${escapeNotificationMarkdownInline(input.reason)}`,
  '> 资产状态已恢复为申请前状态。'
].join('\n\n')

export const buildDisposalCompletedDingTalkContent = (input: {
  completedAt: Date
  equipmentName: unknown
  equipmentCode: unknown
  completerName: unknown
  notes: unknown
}) => [
  `**完成时间：** ${formatBeijingDateTime(input.completedAt)}`,
  `**资产：** ${assetNotificationName(input.equipmentName, input.equipmentCode)}`,
  `**完成人：** ${escapeNotificationMarkdownInline(input.completerName)}`,
  '**处置结果：** 已完成报废',
  `**完成说明：** ${escapeNotificationMarkdownInline(input.notes, '无')}`,
  '> 相关资产现已统一标记为已报废。'
].join('\n\n')

const getCurrentUser = (res: Response) => ({
  id: Number(res.locals.user?.id),
  role: String(res.locals.user?.role || '')
})

const getDisposalVisibility = (res: Response): Prisma.DisposalRecordWhereInput => {
  const user = getCurrentUser(res)
  if (!Number.isSafeInteger(user.id) || user.id <= 0) {
    throw Object.assign(new Error('用户未登录'), { status: 401 })
  }
  if (user.role === 'admin' || user.role === 'administrative') return {}
  if (user.role === 'it') return { applied_by: user.id }
  throw Object.assign(new Error('无权查看报废流程'), { status: 403 })
}

const DISPOSAL_STATUSES = ['pending', 'approved', 'rejected', 'completed'] as const

const parseListPositiveInteger = (
  value: unknown,
  fieldName: string,
  fallback: number,
  max?: number
) => {
  if (value === undefined || value === null || value === '') {
    if (fallback > 0) return fallback
    throw Object.assign(new Error(`${fieldName}无效`), { status: 422 })
  }
  if ((typeof value !== 'string' && typeof value !== 'number') || !/^\d+$/.test(String(value))) {
    throw Object.assign(new Error(`${fieldName}无效`), { status: 422 })
  }
  const parsed = Number(value)
  if (!Number.isSafeInteger(parsed) || parsed <= 0 || (max !== undefined && parsed > max)) {
    throw Object.assign(new Error(`${fieldName}无效`), { status: 422 })
  }
  return parsed
}

const withHistoricalDisposalNotes = <T extends {
  status: string
  notes?: string | null
  completion_notes?: string | null
}>(record: T) => ({
  ...record,
  historical_notes:
    record.status === 'completed' && record.notes && !record.completion_notes
      ? record.notes
      : null
})

const readDisposalSubmission = (body: Record<string, unknown>) => {
  const reason = typeof body.disposal_reason === 'string' ? body.disposal_reason.trim() : ''
  const method = typeof body.disposal_method === 'string' ? body.disposal_method.trim() : ''
  if (!reason || !method) throw new Error('报废原因和处置方式不能为空')
  if (method.length > 50) throw new Error('处置方式不能超过50个字符')
  if (body.notes != null && typeof body.notes !== 'string') throw new Error('备注格式无效')
  return { reason, method, notes: typeof body.notes === 'string' ? body.notes.trim() || null : null }
}

const writeDisposalSubmission = async (
  tx: Prisma.TransactionClient, tree: DisposalTreeItem[], userId: number,
  input: ReturnType<typeof readDisposalSubmission>, estimatedValue = 0
) => {
  const root = tree[0]
  const codeById = new Map(tree.map(item => [item.id, item.equipment_code]))
  const disposal = await tx.disposalRecord.create({ data: {
    equipment_id: root.id,
    equipment_code: root.equipment_code,
    disposal_reason: input.reason,
    disposal_method: input.method,
    estimated_value: estimatedValue,
    applied_by: userId,
    pre_status: root.status,
    notes: input.notes,
    items: { create: tree.map(item => ({
      equipment_id: item.id, equipment_code: item.equipment_code, equipment_name: item.equipment_name,
      parent_equipment_id: item.parent_id,
      parent_equipment_code: item.parent_id === null ? null : codeById.get(item.parent_id) || null,
      pre_status: item.status,
      snapshot_json: JSON.stringify({
        equipment_code: item.equipment_code, equipment_name: item.equipment_name, parent_id: item.parent_id,
        department_id: item.department_id, storage_location_id: item.storage_location_id, status: item.status
      })
    })) },
    actions: { create: {
      action_type: 'applied', operator_id: userId, from_status: null, to_status: 'pending', detail: input.reason
    } }
  }, select: { id: true, applied_at: true } })
  for (const item of tree) await updateEquipmentLifecycle(tx, item, '待报废', item.status)
  return disposal
}

export const createDisposal = async (req: Request, res: Response) => {
  try {
    const {
      equipment_id,
      item_ids,
      estimated_value
    } = req.body as Record<string, any>
    const userId = Number(res.locals.user?.id)
    const rootId = Number(equipment_id)
    if (!userId) return errorResponse(res, '用户未登录', 401)
    if (!Number.isInteger(rootId) || rootId <= 0) {
      return errorResponse(res, '请选择要报废的主资产', 422)
    }
    const input = readDisposalSubmission(req.body)
    const estimatedValue = Number(estimated_value ?? 0)
    if (!Number.isFinite(estimatedValue) || estimatedValue < 0) {
      return errorResponse(res, '残值估价必须是大于或等于0的有效数字', 422)
    }

    const createdId = await prisma.$transaction(async (tx) => {
      const tree = await loadAndLockAssetTree(tx, rootId)
      const root = tree[0]
      if (root.parent_id) {
        throw new Error('挂载中的子资产不能单独申请报废，请先卸载')
      }

      const requestedIds = Array.isArray(item_ids)
        ? [...new Set(item_ids.map(Number).filter((id) => Number.isInteger(id) && id > 0))]
        : [rootId]
      assertDisposalItemsConfirmed(tree, requestedIds)
      const blocked = getDisposalBlockedReason(tree)
      if (blocked) throw new Error(blocked)
      const occupancy = await getDisposalOccupancy(tx, tree.map(item => item.id))
      const occupied = getDisposalBlockedReason(tree, occupancy)
      if (occupied) throw new Error(occupied)
      const disposal = await writeDisposalSubmission(tx, tree, userId, input, estimatedValue)

      const recipients = await getSubmissionRecipients(tx, userId)
      await createBusinessNotification(tx, {
        eventType: 'disposal_applied',
        businessType: 'disposal',
        businessId: disposal.id,
        title: `待审批报废：${root.equipment_name}`,
        content: `${res.locals.user?.name || res.locals.user?.username} 提交了 ${root.equipment_code} 的报废申请`,
        level: 'warning',
        actionUrl: `/workflows/disposals/${disposal.id}`,
        stationRecipients: recipients.stationRecipients,
        dingTalkRecipients: recipients.dingTalkRecipients,
        metadata: { equipment_code: root.equipment_code },
        dingTalk: {
          title: '资产报废待审批',
          content: buildDisposalAppliedDingTalkContent({
            appliedAt: disposal.applied_at,
            equipmentName: root.equipment_name,
            equipmentCode: root.equipment_code,
            applicantName: res.locals.user?.name || res.locals.user?.username,
            reason: input.reason
          }),
          actionTitle: '立即审批',
          messageVersion: 'v1'
        }
      })

      return disposal.id
    }, { isolationLevel: Prisma.TransactionIsolationLevel.ReadCommitted })

    const disposal = await prisma.disposalRecord.findUnique({
      where: { id: createdId },
      include: disposalInclude
    })
    await logOperation(
      userId,
      res.locals.user?.username || res.locals.user?.name || 'unknown',
      '报废申请',
      `申请报废资产 ${disposal?.equipment_code}，原因：${input.reason}`,
      rootId,
      disposal?.equipment_code,
      req.ip
    )
    successResponse(res, disposal, '报废申请创建成功')
  } catch (error: any) {
    console.error('[创建报废申请失败]', error?.message || error)
    errorResponse(res, error.message || '创建报废申请失败', error.status || 422)
  }
}

const isEquipmentId = (value: unknown): value is number => typeof value === 'number' && Number.isSafeInteger(value) && value > 0

export const previewBatchDisposal = async (req: Request, res: Response) => {
  try {
    if (!isEquipmentId(getCurrentUser(res).id)) return errorResponse(res, '用户未登录', 401)
    const { equipment_ids = [], equipment_codes = [] } = req.body || {}
    if (!Array.isArray(equipment_ids) || !equipment_ids.every(isEquipmentId) ||
        !Array.isArray(equipment_codes) || !equipment_codes.every(code => typeof code === 'string' && code.trim())) {
      return errorResponse(res, '请提供有效的资产ID或编码', 422)
    }
    const limitMessage = `每批须包含 1 至 ${MAX_DISPOSAL_BATCH_ROOTS} 个资产`
    const codes: string[] = equipment_codes.map(code => code.trim())
    const uniqueIds = [...new Set(equipment_ids)]
    const uniqueCodes = new Map<string, string>()
    for (const code of codes) {
      const key = code.toLowerCase()
      if (!uniqueCodes.has(key)) uniqueCodes.set(key, code)
    }
    if (uniqueIds.length + uniqueCodes.size === 0 ||
        uniqueIds.length > MAX_DISPOSAL_BATCH_ROOTS || uniqueCodes.size > MAX_DISPOSAL_BATCH_ROOTS) {
      return errorResponse(res, limitMessage, 422)
    }
    const roots = await prisma.equipment.findMany({
      where: { OR: [{ id: { in: uniqueIds } }, { equipment_code: { in: [...uniqueCodes.values()] } }] }, select: disposalTreeSelect
    })
    const byId = new Map(roots.map(root => [root.id, root]))
    const byCode = new Map(roots.map(root => [root.equipment_code.toLowerCase(), root]))
    const inputs = [
      ...equipment_ids.map(id => ({ key: `id:${id}`, label: String(id), root: byId.get(id), isCode: false })),
      ...codes.map(code => ({ key: `code:${code.toLowerCase()}`, label: code, root: byCode.get(code.toLowerCase()), isCode: true }))
    ]
    const seen = new Set<string>()
    const duplicateCodes = new Map<string, string>()
    const distinctInputs = inputs.filter(({ key, label, root, isCode }) => {
      const identity = root ? `id:${root.id}` : key
      if (seen.has(identity)) {
        const code = root?.equipment_code || label
        if ((root || isCode) && !duplicateCodes.has(code.toLowerCase())) duplicateCodes.set(code.toLowerCase(), code)
        return false
      }
      seen.add(identity)
      return true
    })
    if (distinctInputs.length > MAX_DISPOSAL_BATCH_ROOTS) return errorResponse(res, limitMessage, 422)
    const trees = await loadDisposalTrees(prisma, roots)
    const treeIds = [...new Set([...trees.values()].flatMap(tree => tree.map(item => item.id)))]
    const occupancy = treeIds.length ? await getDisposalOccupancy(prisma, treeIds) : undefined
    const candidates = distinctInputs.map(({ label, root }) => {
      const tree = root ? trees.get(root.id)! : []
      return {
        equipment_id: root?.id ?? null, equipment_code: root?.equipment_code ?? label,
        equipment_name: root?.equipment_name ?? '', status: root?.status ?? '未找到',
        items: tree.map(({ id, equipment_code, equipment_name }) => ({ id, equipment_code, equipment_name })),
        blocked_reason: root ? getDisposalBlockedReason(tree, occupancy) : '未找到资产'
      }
    })
    successResponse(res, { candidates, duplicate_codes: [...duplicateCodes.values()] }, '批量预检完成')
  } catch (error: any) {
    errorResponse(res, error.message || '批量报废预检失败', error.status || 422)
  }
}

export const createBatchDisposal = async (req: Request, res: Response) => {
  try {
    const userId = getCurrentUser(res).id
    if (!isEquipmentId(userId)) return errorResponse(res, '用户未登录', 401)
    const { assets } = req.body || {}
    if (!Array.isArray(assets) || assets.length < 1 || assets.length > MAX_DISPOSAL_BATCH_ROOTS) {
      return errorResponse(res, `每批须包含 1 至 ${MAX_DISPOSAL_BATCH_ROOTS} 个主资产`, 422)
    }
    const input = readDisposalSubmission(req.body)
    const rootIds: number[] = []
    const confirmed = new Map<number, number[]>()
    const lockedIds = new Set<number>()
    for (const asset of assets) {
      if (!isEquipmentId(asset?.equipment_id) || !Array.isArray(asset.item_ids) ||
          !asset.item_ids.every(isEquipmentId) || !asset.item_ids.includes(asset.equipment_id)) {
        return errorResponse(res, '请逐项确认报废明细，明细必须包含主资产', 422)
      }
      if (confirmed.has(asset.equipment_id)) return errorResponse(res, '批量报废包含重复主资产', 422)
      for (const id of asset.item_ids as number[]) {
        if (lockedIds.has(id)) return errorResponse(res, '批量报废明细包含重复资产', 422)
        lockedIds.add(id)
      }
      rootIds.push(asset.equipment_id)
      confirmed.set(asset.equipment_id, asset.item_ids)
    }

    const disposalIds = await prisma.$transaction(async tx => {
      // All confirmed assets are locked in ID order. Re-read the current trees
      // after locking; any unconfirmed descendant aborts before the first write.
      await lockEquipmentRows(tx, [...lockedIds])
      const roots = await tx.equipment.findMany({ where: { id: { in: rootIds } }, select: disposalTreeSelect })
      if (roots.length !== rootIds.length) throw new DisposalConflictError('有主资产已不存在，请重新预检')
      const trees = await loadDisposalTrees(tx, roots)
      for (const id of rootIds) {
        const tree = trees.get(id)!
        const blocked = getDisposalBlockedReason(tree)
        if (blocked) throw new DisposalConflictError(`${tree[0].equipment_code}：${blocked}`)
        assertDisposalItemsConfirmed(tree, confirmed.get(id)!)
      }
      const occupancy = await getDisposalOccupancy(tx, [...lockedIds])
      for (const id of rootIds) {
        const tree = trees.get(id)!
        const blocked = getDisposalBlockedReason(tree, occupancy)
        if (blocked) throw new DisposalConflictError(`${tree[0].equipment_code}：${blocked}`)
      }

      const created = []
      for (const id of rootIds) created.push(await writeDisposalSubmission(tx, trees.get(id)!, userId, input))
      const codes = rootIds.map(id => trees.get(id)![0].equipment_code)
      const ids = created.map(row => row.id)
      const userName = res.locals.user?.username || res.locals.user?.name || 'unknown'
      await tx.operationLog.createMany({ data: codes.map((code, index) => ({
        user_id: userId, username: userName, operation_type: '报废申请',
        operation_details: `申请报废资产 ${code}，原因：${input.reason}`,
        equipment_id: rootIds[index], equipment_code: code, ip_address: req.ip || null
      })) })
      const recipients = await getSubmissionRecipients(tx, userId)
      const preview = codes.slice(0, 10).join('、') + (codes.length > 10 ? ` 等 ${codes.length} 个` : '')
      await createBusinessNotification(tx, {
        ...recipients, eventType: 'disposal_applied', businessType: 'disposal', businessId: ids[0],
        title: `待审批报废：${ids.length} 笔`,
        content: `${res.locals.user?.name || userName} 提交了 ${ids.length} 笔报废申请：${preview}`,
        level: 'warning', actionUrl: '/workflows/disposals',
        metadata: { disposal_ids: ids, equipment_codes: codes, count: ids.length },
        dingTalk: {
          title: '批量报废待审批', actionTitle: '查看待审批', messageVersion: 'v1',
          content: [
            `**申请时间：** ${formatBeijingDateTime(created[0].applied_at)}`,
            `**待审批：** ${ids.length} 笔（${escapeNotificationMarkdownInline(preview)}）`,
            `**申请人：** ${escapeNotificationMarkdownInline(res.locals.user?.name || userName)}`,
            `**报废原因：** ${escapeNotificationMarkdownInline(input.reason.slice(0, 300))}`,
            '> 请在报废流程列表中逐笔核对并审批。'
          ].join('\n\n')
        }
      })
      return ids
    }, { isolationLevel: Prisma.TransactionIsolationLevel.ReadCommitted, timeout: 30000 })
    successResponse(res, { count: disposalIds.length, disposal_ids: disposalIds }, '批量报废申请创建成功')
  } catch (error: any) {
    console.error('[批量创建报废申请失败]', error?.message || error)
    errorResponse(res, error.message || '批量创建报废申请失败', error.status || 422)
  }
}

export const getDisposalList = async (req: Request, res: Response) => {
  try {
    const { page = 1, pageSize = 10, status, keyword, equipment_id, scope } = req.query
    const currentPage = parseListPositiveInteger(page, '页码', 1)
    const currentPageSize = parseListPositiveInteger(pageSize, '每页数量', 10, 100)
    const currentUser = getCurrentUser(res)
    if (!Number.isInteger(currentUser.id) || currentUser.id <= 0) {
      return errorResponse(res, '用户未登录', 401)
    }
    const resolvedScope = String(scope || (currentUser.role === 'admin'
      ? 'all'
      : currentUser.role === 'administrative'
        ? 'pending'
        : 'mine'))
    const validScopes = ['all', 'mine', 'pending', 'processed']
    if (!validScopes.includes(resolvedScope)) {
      return errorResponse(res, '报废列表范围无效', 422)
    }

    const summaryConditions: Prisma.DisposalRecordWhereInput[] = [getDisposalVisibility(res)]
    if (currentUser.role === 'administrative' && resolvedScope === 'all') {
      return errorResponse(res, '行政仅可查看本人发起、全部待审批和全部已处理报废流程', 403)
    }
    if (currentUser.role !== 'it') {
      if (resolvedScope === 'mine') {
        summaryConditions.push({ applied_by: currentUser.id })
      } else if (resolvedScope === 'pending') {
        summaryConditions.push({ status: 'pending' })
      } else if (resolvedScope === 'processed') {
        summaryConditions.push({ status: { in: ['approved', 'rejected', 'completed'] } })
      }
    }

    const normalizedStatus = String(status || '').trim()
    if (normalizedStatus && !DISPOSAL_STATUSES.includes(normalizedStatus as any)) {
      return errorResponse(res, '报废状态无效', 422)
    }
    if (equipment_id !== undefined && equipment_id !== '') {
      summaryConditions.push({
        equipment_id: parseListPositiveInteger(equipment_id, '资产ID', 0)
      })
    }
    const normalizedKeyword = String(keyword || '').trim()
    if (normalizedKeyword) {
      const keywordWhere = [
        { equipment_code: { contains: normalizedKeyword } },
        { disposal_reason: { contains: normalizedKeyword } },
        { items: { some: { equipment_code: { contains: normalizedKeyword } } } }
      ]
      summaryConditions.push({ OR: keywordWhere })
    }
    const summaryWhere: Prisma.DisposalRecordWhereInput = summaryConditions.length > 0
      ? { AND: summaryConditions }
      : {}
    const where: Prisma.DisposalRecordWhereInput = normalizedStatus
      ? { AND: [summaryWhere, { status: normalizedStatus }] }
      : summaryWhere

    const skip = (currentPage - 1) * currentPageSize
    const [list, total, statusGroups] = await Promise.all([
      prisma.disposalRecord.findMany({
        where,
        skip,
        take: currentPageSize,
        orderBy: { created_at: 'desc' },
        include: {
          equipment: { select: { equipment_name: true, equipment_type: true, unit_price: true } },
          applier: { select: { id: true, name: true, username: true } },
          approver: { select: { id: true, name: true, username: true } },
          completer: { select: { id: true, name: true, username: true } },
          _count: { select: { items: true } }
        }
      }),
      prisma.disposalRecord.count({ where }),
      prisma.disposalRecord.groupBy({
        by: ['status'],
        where: summaryWhere,
        _count: { _all: true }
      })
    ])
    const summary = {
      total: 0,
      pending: 0,
      approved: 0,
      rejected: 0,
      completed: 0
    }
    for (const group of statusGroups) {
      const count = group._count._all
      summary.total += count
      if (DISPOSAL_STATUSES.includes(group.status as any)) {
        summary[group.status as (typeof DISPOSAL_STATUSES)[number]] = count
      }
    }
    successResponse(
      res,
      {
        list: list.map(withHistoricalDisposalNotes),
        total,
        page: currentPage,
        pageSize: currentPageSize,
        summary
      },
      '获取成功'
    )
  } catch (error: any) {
    errorResponse(res, error.message || '获取报废记录列表失败', error.status || 500)
  }
}

export const getDisposalDetail = async (req: Request, res: Response) => {
  try {
    const visibility = getDisposalVisibility(res)
    const disposalId = parseListPositiveInteger(req.params.id, '报废记录ID', 0)
    const disposal = await prisma.disposalRecord.findUnique({
      where: { id: disposalId },
      include: disposalInclude
    })
    if (!disposal) return errorResponse(res, '报废记录不存在', 404)
    if (visibility.applied_by && disposal.applied_by !== visibility.applied_by) {
      return errorResponse(res, '无权查看该报废申请', 403)
    }
    successResponse(res, withHistoricalDisposalNotes(disposal), '获取成功')
  } catch (error: any) {
    errorResponse(res, error.message || '获取报废记录详情失败', error.status || 500)
  }
}

export const approveDisposal = async (req: Request, res: Response) => {
  try {
    const disposalId = Number(req.params.id)
    const { approved, reject_reason } = req.body as { approved?: boolean; reject_reason?: string }
    const userId = Number(res.locals.user?.id)
    if (typeof approved !== 'boolean') {
      return errorResponse(res, '审批结果必须明确为通过或驳回', 422)
    }
    if (!approved && !reject_reason?.trim()) {
      return errorResponse(res, '驳回原因不能为空', 422)
    }

    const result = await prisma.$transaction(async (tx) => {
      const disposal = await tx.disposalRecord.findUnique({
        where: { id: disposalId },
        include: { items: { include: { equipment: true } } }
      })
      if (!disposal) throw Object.assign(new Error('报废记录不存在'), { status: 404 })
      const changedItem = disposal.items.find((item) =>
        item.equipment.status !== '待报废' ||
        item.equipment.parent_id !== item.parent_equipment_id
      )
      if (changedItem) {
        throw new DisposalConflictError(
          `资产 ${changedItem.equipment_code} 的状态或挂载关系已变化，请先核查`
        )
      }

      const nextStatus = approved ? 'approved' : 'rejected'
      const approvedAt = new Date()
      const updated = await tx.disposalRecord.updateMany({
        where: { id: disposalId, status: 'pending' },
        data: {
          status: nextStatus,
          approved_by: userId,
          approved_at: approvedAt,
          reject_reason: approved ? null : reject_reason?.trim()
        }
      })
      if (updated.count !== 1) {
        throw new DisposalConflictError('该申请已被其他人处理，请刷新后查看')
      }

      if (!approved) {
        for (const item of disposal.items) {
          await updateEquipmentLifecycle(
            tx,
            item.equipment,
            item.pre_status,
            '待报废',
            item.parent_equipment_id
          )
        }
      }

      await tx.disposalAction.create({
        data: {
          disposal_id: disposalId,
          action_type: approved ? 'approved' : 'rejected',
          operator_id: userId,
          from_status: 'pending',
          to_status: nextStatus,
          detail: approved ? null : reject_reason?.trim()
        }
      })

      const recipients = await getResultRecipients(tx, disposal.applied_by)
      const rootItem = disposal.items.find((item) => item.equipment_id === disposal.equipment_id)
      await createBusinessNotification(tx, {
        eventType: approved ? 'disposal_approved' : 'disposal_rejected',
        businessType: 'disposal',
        businessId: disposal.id,
        title: approved ? `报废已审批：${disposal.equipment_code}` : `报废已驳回：${disposal.equipment_code}`,
        content: approved ? '报废申请已审批通过，等待完成处置' : `驳回原因：${reject_reason?.trim()}`,
        level: approved ? 'success' : 'warning',
        actionUrl: `/workflows/disposals/${disposal.id}`,
        stationRecipients: recipients.stationRecipients,
        dingTalkRecipients: recipients.dingTalkRecipients,
        dingTalk: approved
          ? {
              title: '资产报废审批已通过',
              content: buildDisposalApprovedDingTalkContent({
                approvedAt,
                equipmentName: rootItem?.equipment.equipment_name,
                equipmentCode: disposal.equipment_code,
                approverName: res.locals.user?.name || res.locals.user?.username
              }),
              actionTitle: '查看审批结果',
              messageVersion: 'v1'
            }
          : {
              title: '资产报废申请已驳回',
              content: buildDisposalRejectedDingTalkContent({
                rejectedAt: approvedAt,
                equipmentName: rootItem?.equipment.equipment_name,
                equipmentCode: disposal.equipment_code,
                rejectorName: res.locals.user?.name || res.locals.user?.username,
                reason: reject_reason
              }),
              actionTitle: '查看申请',
              messageVersion: 'v1'
            }
      })
      return disposal
    })

    await logOperation(
      userId,
      res.locals.user?.username || res.locals.user?.name || 'unknown',
      approved ? '报废审批通过' : '报废审批驳回',
      `${approved ? '批准' : '驳回'}资产 ${result.equipment_code} 的报废申请`,
      result.equipment_id,
      result.equipment_code,
      req.ip
    )
    successResponse(res, null, approved ? '审批通过' : '已驳回')
  } catch (error: any) {
    errorResponse(res, error.message || '审批失败', error.status || 500)
  }
}

export const completeDisposal = async (req: Request, res: Response) => {
  try {
    const disposalId = Number(req.params.id)
    const { actual_value, completion_notes, notes } = req.body as Record<string, any>
    const userId = Number(res.locals.user?.id)
    const actualValue = actual_value === undefined ? undefined : Number(actual_value)
    if (actualValue !== undefined && (!Number.isFinite(actualValue) || actualValue < 0)) {
      return errorResponse(res, '实际处置价值必须是大于或等于0的有效数字', 422)
    }

    const result = await prisma.$transaction(async (tx) => {
      const disposal = await tx.disposalRecord.findUnique({
        where: { id: disposalId },
        include: { items: { include: { equipment: true } } }
      })
      if (!disposal) throw Object.assign(new Error('报废记录不存在'), { status: 404 })

      const completedAt = new Date()
      const updated = await tx.disposalRecord.updateMany({
        where: { id: disposalId, status: 'approved' },
        data: {
          status: 'completed',
          actual_value: actualValue !== undefined ? actualValue : disposal.estimated_value,
          completed_at: completedAt,
          completed_by: userId,
          completion_notes: completion_notes?.trim() || notes?.trim() || null
        }
      })
      if (updated.count !== 1) {
        throw new DisposalConflictError('该申请状态已变化，请刷新后查看')
      }

      for (const item of disposal.items) {
        await updateEquipmentLifecycle(
          tx,
          item.equipment,
          '已报废',
          '待报废',
          item.parent_equipment_id
        )
      }
      await tx.disposalAction.create({
        data: {
          disposal_id: disposalId,
          action_type: 'completed',
          operator_id: userId,
          from_status: 'approved',
          to_status: 'completed',
          detail: completion_notes?.trim() || notes?.trim() || null
        }
      })

      const recipients = await getResultRecipients(tx, disposal.applied_by)
      const rootItem = disposal.items.find((item) => item.equipment_id === disposal.equipment_id)
      await createBusinessNotification(tx, {
        eventType: 'disposal_completed',
        businessType: 'disposal',
        businessId: disposal.id,
        title: `报废处置已完成：${disposal.equipment_code}`,
        content: completion_notes?.trim() || notes?.trim() || '资产已完成报废处置',
        level: 'success',
        actionUrl: `/workflows/disposals/${disposal.id}`,
        stationRecipients: recipients.stationRecipients,
        dingTalkRecipients: recipients.dingTalkRecipients,
        dingTalk: {
          title: '资产报废处置已完成',
          content: buildDisposalCompletedDingTalkContent({
            completedAt,
            equipmentName: rootItem?.equipment.equipment_name,
            equipmentCode: disposal.equipment_code,
            completerName: res.locals.user?.name || res.locals.user?.username,
            notes: completion_notes?.trim() || notes?.trim()
          }),
          actionTitle: '查看结果',
          messageVersion: 'v1'
        }
      })
      return disposal
    })

    await logOperation(
      userId,
      res.locals.user?.username || res.locals.user?.name || 'unknown',
      '报废完成',
      `完成资产 ${result.equipment_code} 的报废处置`,
      result.equipment_id,
      result.equipment_code,
      req.ip
    )
    successResponse(res, null, '报废处置完成')
  } catch (error: any) {
    errorResponse(res, error.message || '完成报废处置失败', error.status || 500)
  }
}

export const getEquipmentDisposalHistory = async (req: Request, res: Response) => {
  try {
    const visibility = getDisposalVisibility(res)
    const equipmentId = parseListPositiveInteger(req.params.equipment_id, '资产ID', 0)
    const history = await prisma.disposalRecord.findMany({
      where: {
        AND: [visibility, { OR: [
          { equipment_id: equipmentId },
          { items: { some: { equipment_id: equipmentId } } }
        ] }]
      },
      orderBy: { created_at: 'desc' },
      include: {
        applier: { select: { id: true, name: true } },
        approver: { select: { id: true, name: true } },
        completer: { select: { id: true, name: true } },
        items: true,
        actions: { orderBy: { created_at: 'asc' } }
      }
    })
    successResponse(res, history, '获取成功')
  } catch (error: any) {
    errorResponse(res, error.message || '获取报废历史失败', error.status || 500)
  }
}