import { Router, Response, NextFunction } from 'express'
import prisma from '../lib/prisma'
import { authMiddleware, AuthRequest } from '../middleware/auth'
import { z } from 'zod'
import { decrypt } from '../lib/crypto'
import {
  getTemplate,
  calcBatchEntry,
  getPayrollRiskWarnings,
  generatePayslipFromBatches,
  prePayrollCheck,
} from '../services/payroll.service'

const router = Router()
router.use(authMiddleware)

// ========== 薪酬模版 ==========

// 获取薪酬模版
router.get('/template', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const items = await getTemplate(req.user!.orgId)
    res.json({ success: true, data: items })
  } catch (err) {
    next(err)
  }
})

// 更新薪酬模版项
const updateTemplateItemSchema = z.object({
  name: z.string().min(1).optional(),
  formula: z.string().nullable().optional(),
  order: z.number().int().optional(),
  isEditable: z.boolean().optional(),
})

router.put('/template/:id', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const data = updateTemplateItemSchema.parse(req.body)
    const item = await prisma.payslipItem.findFirst({
      where: { id: req.params.id, orgId: req.user!.orgId },
    })
    if (!item) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '模版项不存在' } })

    const updateData: any = {}
    if (data.name !== undefined && !item.isDefault) updateData.name = data.name
    if (data.formula !== undefined) updateData.formula = data.formula
    if (data.order !== undefined) updateData.order = data.order
    if (data.isEditable !== undefined) updateData.isEditable = data.isEditable

    const updated = await prisma.payslipItem.update({ where: { id: req.params.id }, data: updateData })
    res.json({ success: true, data: updated })
  } catch (err) {
    next(err)
  }
})

// 新增薪酬模版项
const createTemplateItemSchema = z.object({
  name: z.string().min(1),
  code: z.string().min(1),
  type: z.enum(['INPUT', 'CALCULATED']),
  formula: z.string().nullable().optional(),
  order: z.number().int().default(99),
  isEditable: z.boolean().default(true),
})

router.post('/template', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const data = createTemplateItemSchema.parse(req.body)
    const item = await prisma.payslipItem.create({
      data: { ...data, orgId: req.user!.orgId, isDefault: false },
    })
    res.json({ success: true, data: item })
  } catch (err) {
    next(err)
  }
})

// 删除薪酬模版项（仅非预置项）
router.delete('/template/:id', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const item = await prisma.payslipItem.findFirst({
      where: { id: req.params.id, orgId: req.user!.orgId },
    })
    if (!item) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '模版项不存在' } })
    if (item.isDefault) return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '预置项不可删除' } })

    await prisma.payslipItem.delete({ where: { id: req.params.id } })
    res.json({ success: true })
  } catch (err) {
    next(err)
  }
})

// ========== 发薪批次 ==========

// 检查本月是否已发薪
router.get('/batches/check', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const { month } = req.query
    if (!month) return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '缺少 month 参数' } })

    const archivedBatches = await prisma.payrollBatch.count({
      where: { orgId: req.user!.orgId, month: String(month), status: 'ARCHIVED' },
    })
    const draftBatches = await prisma.payrollBatch.count({
      where: { orgId: req.user!.orgId, month: String(month), status: 'DRAFT' },
    })
    const publishedPayslips = await prisma.payslip.count({
      where: { orgId: req.user!.orgId, month: String(month), status: 'PUBLISHED' },
    })

    res.json({
      success: true,
      data: {
        hasArchivedBatch: archivedBatches > 0,
        archivedCount: archivedBatches,
        draftCount: draftBatches,
        payslipsPublished: publishedPayslips > 0,
      },
    })
  } catch (err) {
    next(err)
  }
})

// 获取可复制的归档批次列表
router.get('/batches/archived/list', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const orgId = req.user!.orgId
    const batches = await prisma.payrollBatch.findMany({
      where: { orgId, status: 'ARCHIVED' },
      orderBy: [{ month: 'desc' }, { batchNo: 'desc' }],
      select: { id: true, name: true, month: true, type: true, employeeCount: true, totalPay: true, totalNetPay: true },
      take: 20,
    })
    res.json({ success: true, data: batches })
  } catch (err) {
    next(err)
  }
})

// 获取批次列表
router.get('/batches', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const { month, monthFrom, monthTo, status, type } = req.query
    const batches = await prisma.payrollBatch.findMany({
      where: {
        orgId: req.user!.orgId,
        ...(month ? { month: String(month) } : {}),
        ...(monthFrom ? { month: { gte: String(monthFrom) } } : {}),
        ...(monthTo ? { month: { lte: String(monthTo) } } : {}),
        ...(status ? { status: String(status) as any } : {}),
        ...(type ? { type: String(type) as any } : {}),
      },
      orderBy: [{ month: 'desc' }, { batchNo: 'asc' }],
    })
    res.json({ success: true, data: batches })
  } catch (err) {
    next(err)
  }
})

// 获取批次详情
router.get('/batches/:id', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const batch = await prisma.payrollBatch.findFirst({
      where: { id: req.params.id, orgId: req.user!.orgId },
      include: {
        entries: {
          include: {
            employee: { select: { id: true, name: true, department: true, status: true, bankAccount: true, bankName: true } },
          },
          orderBy: { employee: { name: 'asc' } },
        },
      },
    })
    if (!batch) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '批次不存在' } })
    res.json({ success: true, data: batch })
  } catch (err) {
    next(err)
  }
})

// 重命名批次
router.put('/batches/:id/name', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const { name } = req.body
    if (!name || typeof name !== 'string' || name.trim().length === 0) {
      return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '批次名称不能为空' } })
    }
    const batch = await prisma.payrollBatch.findFirst({
      where: { id: req.params.id, orgId: req.user!.orgId },
    })
    if (!batch) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '批次不存在' } })
    if (batch.status === 'ARCHIVED') {
      return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '已归档批次不可重命名' } })
    }
    const updated = await prisma.payrollBatch.update({
      where: { id: req.params.id },
      data: { name: name.trim() },
    })
    res.json({ success: true, data: { id: updated.id, name: updated.name } })
  } catch (err) {
    next(err)
  }
})

// 创建批次
const createBatchSchema = z.object({
  month: z.string().regex(/^\d{4}-\d{2}$/),
  type: z.enum(['REGULAR', 'TERMINATION', 'BONUS', 'SEVERANCE']).default('REGULAR'),
  mode: z.enum(['copy_last', 'blank_employees', 'blank_all', 'copy_batch']).default('copy_last'),
  sourceBatchId: z.string().optional(),
  name: z.string().optional(),
  remark: z.string().optional(),
})

router.post('/batches', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const { month, type, mode, sourceBatchId, name, remark } = createBatchSchema.parse(req.body)
    const orgId = req.user!.orgId

    // 检查当月是否有未归档批次，有则拒绝创建（确保个税按批次累计计算）
    const draftBatches = await prisma.payrollBatch.count({
      where: { orgId, month, status: 'DRAFT' },
    })
    if (draftBatches > 0) {
      return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '当月存在未归档的批次，请先归档后再创建新批次' } })
    }

    // 查询当月最大批次号，避免删除后 count 不准导致唯一键冲突
    const lastBatch = await prisma.payrollBatch.findFirst({
      where: { orgId, month },
      orderBy: { batchNo: 'desc' },
      select: { batchNo: true },
    })
    const batchNo = (lastBatch?.batchNo || 0) + 1

    // 获取在职员工 + 本月离职员工
    const monthStart = new Date(`${month}-01`)
    const monthEnd = new Date(monthStart.getFullYear(), monthStart.getMonth() + 1, 0, 23, 59, 59)

    // 获取上月发薪数据
    const prevMonth = new Date(monthStart.getFullYear(), monthStart.getMonth() - 1, 1)
    const prevMonthStr = `${prevMonth.getFullYear()}-${String(prevMonth.getMonth() + 1).padStart(2, '0')}`

    const batchName = name || `${month} 第${batchNo}批 ${type === 'BONUS' ? '奖金' : type === 'TERMINATION' ? '离职结算' : type === 'SEVERANCE' ? '补偿金' : '发薪'}`

    // 根据模式确定员工列表和数据来源
    let employees: any[] = []
    let sourceEntries: any[] | null = null

    if (mode === 'blank_all') {
      // 全空白：不拉入员工
      employees = []
    } else if (mode === 'copy_batch' && sourceBatchId) {
      // 复制指定批次：从源批次复制条目
      const sourceBatch = await prisma.payrollBatch.findFirst({
        where: { id: sourceBatchId, orgId, status: 'ARCHIVED' },
        include: { entries: true },
      })
      if (!sourceBatch) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '源批次不存在或未归档' } })
      sourceEntries = sourceBatch.entries
      // 提取员工 ID，后续按此创建条目
      const employeeIds = sourceEntries.map(e => e.employeeId)
      employees = await prisma.employee.findMany({
        where: { id: { in: employeeIds }, orgId },
        include: { contracts: { orderBy: { createdAt: 'desc' }, take: 1 } },
      })
    } else {
      // copy_last 或 blank_employees：拉入员工
      if (type === 'TERMINATION' || type === 'SEVERANCE') {
        const terminations = await prisma.terminationRecord.findMany({
          where: { orgId, terminationDate: { gte: monthStart, lte: monthEnd } },
          include: { employee: { include: { contracts: { orderBy: { createdAt: 'desc' }, take: 1 } } } },
        })
        employees = terminations.map(t => t.employee)
      } else {
        employees = await prisma.employee.findMany({
          where: {
            orgId,
            OR: [
              { status: 'ACTIVE' },
              { status: 'RESIGNED', updatedAt: { gte: monthStart, lte: monthEnd } },
            ],
          },
          include: { contracts: { orderBy: { createdAt: 'desc' }, take: 1 } },
        })
      }
    }

    // 创建批次
    const batch = await prisma.payrollBatch.create({
      data: {
        orgId,
        month,
        batchNo,
        name: batchName,
        type,
        remark,
        createdBy: req.user!.id,
        employeeCount: employees.length,
      },
    })

    // 创建批次条目
    const entries: any[] = []
    const failedEmployees: { employeeId: string; name: string; error: string }[] = []
    for (const emp of employees) {
      let baseSalary = 0
      let overtimePay = 0
      let allowance = 0
      let deduction = 0
      let bonus = 0

      if (mode === 'copy_batch' && sourceEntries) {
        // 复制指定批次：从源条目复制数据
        const srcEntry = sourceEntries.find(e => e.employeeId === emp.id)
        if (srcEntry) {
          baseSalary = srcEntry.baseSalary
          overtimePay = srcEntry.overtimePay
          allowance = srcEntry.allowance
          deduction = srcEntry.deduction
          bonus = srcEntry.bonus
        }
      } else if (mode === 'copy_last') {
        // 复制上月：从上月工资条复制
        const prevPayslip = await prisma.payslip.findUnique({
          where: { employeeId_month: { employeeId: emp.id, month: prevMonthStr } },
        })
        const overtime = await prisma.overtimeRecord.findUnique({
          where: { employeeId_month: { employeeId: emp.id, month } },
        })

        if (emp.contracts?.[0]?.probationSalary && new Date(emp.contracts[0].startDate) > new Date(Date.now() - 365 * 24 * 60 * 60 * 1000)) {
          baseSalary = emp.contracts[0].probationSalary
        } else if (emp.monthlySalary) {
          try { baseSalary = Number(decrypt(emp.monthlySalary)) || 0 } catch { baseSalary = Number(emp.monthlySalary) || 0 }
        }
        if (prevPayslip) baseSalary = prevPayslip.baseSalary
        overtimePay = overtime?.totalPay || 0
        allowance = prevPayslip?.allowance || 0
        deduction = prevPayslip?.deduction || 0
      }
      // blank_employees 和 blank_all: 所有金额默认 0
      // blank_employees 模式下尝试从员工记录获取基本工资
      if (mode === 'blank_employees' && emp.monthlySalary) {
        try { baseSalary = Number(decrypt(emp.monthlySalary)) || 0 } catch { baseSalary = Number(emp.monthlySalary) || 0 }
      }

      // calcBatchEntry 内部会按员工检查当月已归档批次是否已扣社保，已扣则跳过
      let calcResult: any
      try {
        calcResult = await calcBatchEntry(orgId, emp.id, month, { baseSalary, overtimePay, allowance, deduction, bonus }, type)
      } catch (calcErr: any) {
        // 单个员工计算失败不阻塞整个批次，记录错误并使用零值
        failedEmployees.push({ employeeId: emp.id, name: emp.name, error: calcErr?.message || '计算失败' })
        calcResult = { socialEmp: 0, socialOrg: 0, housingEmp: 0, housingOrg: 0, tax: 0, totalPay: baseSalary + overtimePay + allowance + bonus - deduction, netPay: baseSalary + overtimePay + allowance + bonus - deduction }
      }

      // 风险提示
      const riskWarnings = await getPayrollRiskWarnings(orgId, emp.id)

      const entry = await prisma.batchEntry.create({
        data: {
          batchId: batch.id,
          orgId,
          employeeId: emp.id,
          baseSalary,
          overtimePay,
          allowance,
          deduction,
          bonus,
          socialEmp: calcResult.socialEmp,
          socialOrg: calcResult.socialOrg,
          housingEmp: calcResult.housingEmp,
          housingOrg: calcResult.housingOrg,
          tax: calcResult.tax,
          totalPay: calcResult.totalPay,
          netPay: calcResult.netPay,
          riskWarnings,
        },
      })
      entries.push(entry)
    }

    // 更新批次汇总
    const totals = entries.reduce((acc, e) => ({
      totalPay: acc.totalPay + e.totalPay,
      totalNetPay: acc.totalNetPay + e.netPay,
      totalSocialOrg: acc.totalSocialOrg + e.socialOrg,
      totalSocialEmp: acc.totalSocialEmp + e.socialEmp,
      totalHousingOrg: acc.totalHousingOrg + e.housingOrg,
      totalHousingEmp: acc.totalHousingEmp + e.housingEmp,
      totalTax: acc.totalTax + e.tax,
    }), { totalPay: 0, totalNetPay: 0, totalSocialOrg: 0, totalSocialEmp: 0, totalHousingOrg: 0, totalHousingEmp: 0, totalTax: 0 })

    const updatedBatch = await prisma.payrollBatch.update({
      where: { id: batch.id },
      data: {
        totalPay: Math.round(totals.totalPay * 100) / 100,
        totalNetPay: Math.round(totals.totalNetPay * 100) / 100,
        totalSocialOrg: Math.round(totals.totalSocialOrg * 100) / 100,
        totalSocialEmp: Math.round(totals.totalSocialEmp * 100) / 100,
        totalHousingOrg: Math.round(totals.totalHousingOrg * 100) / 100,
        totalHousingEmp: Math.round(totals.totalHousingEmp * 100) / 100,
        totalTax: Math.round(totals.totalTax * 100) / 100,
      },
      include: { entries: { include: { employee: { select: { id: true, name: true, department: true, status: true } } } } },
    })

    res.json({ success: true, data: updatedBatch, failedEmployees: failedEmployees.length > 0 ? failedEmployees : undefined })
  } catch (err) {
    next(err)
  }
})

// 编辑批次条目（计算依据项 + 社保公积金手动覆盖）
const updateEntrySchema = z.object({
  baseSalary: z.number().min(0).optional(),
  overtimePay: z.number().min(0).optional(),
  allowance: z.number().min(0).optional(),
  deduction: z.number().min(0).optional(),
  bonus: z.number().min(0).optional(),
  socialEmp: z.number().min(0).optional(),
  socialOrg: z.number().min(0).optional(),
  housingEmp: z.number().min(0).optional(),
  housingOrg: z.number().min(0).optional(),
})

router.put('/batches/:batchId/entries/:employeeId', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const { batchId, employeeId } = req.params
    const data = updateEntrySchema.parse(req.body)
    const orgId = req.user!.orgId

    const batch = await prisma.payrollBatch.findFirst({ where: { id: batchId, orgId } })
    if (!batch) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '批次不存在' } })
    if (batch.status === 'ARCHIVED') return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '已归档批次不可编辑' } })

    const entry = await prisma.batchEntry.findUnique({
      where: { batchId_employeeId: { batchId, employeeId } },
    })
    if (!entry) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '条目不存在' } })

    // 合并输入项
    const inputs = {
      baseSalary: data.baseSalary ?? entry.baseSalary,
      overtimePay: data.overtimePay ?? entry.overtimePay,
      allowance: data.allowance ?? entry.allowance,
      deduction: data.deduction ?? entry.deduction,
      bonus: data.bonus ?? entry.bonus,
    }

    // 构建社保覆盖参数（如果请求中包含社保字段）
    const overrideSocial: any = {}
    if (data.socialEmp !== undefined) overrideSocial.socialEmp = data.socialEmp
    if (data.socialOrg !== undefined) overrideSocial.socialOrg = data.socialOrg
    if (data.housingEmp !== undefined) overrideSocial.housingEmp = data.housingEmp
    if (data.housingOrg !== undefined) overrideSocial.housingOrg = data.housingOrg

    // calcBatchEntry 内部会按员工检查当月已归档批次是否已扣社保，手动覆盖优先
    const options = Object.keys(overrideSocial).length > 0
      ? { overrideSocial }
      : undefined

    // 重新计算
    const calcResult = await calcBatchEntry(orgId, employeeId, batch.month, inputs, batch.type, options)

    const updated = await prisma.batchEntry.update({
      where: { id: entry.id },
      data: { ...inputs, ...calcResult },
    })

    // 更新批次汇总
    const allEntries = await prisma.batchEntry.findMany({ where: { batchId } })
    const totals = allEntries.reduce((acc, e) => ({
      totalPay: acc.totalPay + (e.id === entry.id ? calcResult.totalPay : e.totalPay),
      totalNetPay: acc.totalNetPay + (e.id === entry.id ? calcResult.netPay : e.netPay),
      totalSocialOrg: acc.totalSocialOrg + (e.id === entry.id ? calcResult.socialOrg : e.socialOrg),
      totalSocialEmp: acc.totalSocialEmp + (e.id === entry.id ? calcResult.socialEmp : e.socialEmp),
      totalHousingOrg: acc.totalHousingOrg + (e.id === entry.id ? calcResult.housingOrg : e.housingOrg),
      totalHousingEmp: acc.totalHousingEmp + (e.id === entry.id ? calcResult.housingEmp : e.housingEmp),
      totalTax: acc.totalTax + (e.id === entry.id ? calcResult.tax : e.tax),
    }), { totalPay: 0, totalNetPay: 0, totalSocialOrg: 0, totalSocialEmp: 0, totalHousingOrg: 0, totalHousingEmp: 0, totalTax: 0 })

    await prisma.payrollBatch.update({
      where: { id: batchId },
      data: {
        totalPay: Math.round(totals.totalPay * 100) / 100,
        totalNetPay: Math.round(totals.totalNetPay * 100) / 100,
        totalSocialOrg: Math.round(totals.totalSocialOrg * 100) / 100,
        totalSocialEmp: Math.round(totals.totalSocialEmp * 100) / 100,
        totalHousingOrg: Math.round(totals.totalHousingOrg * 100) / 100,
        totalHousingEmp: Math.round(totals.totalHousingEmp * 100) / 100,
        totalTax: Math.round(totals.totalTax * 100) / 100,
      },
    })

    res.json({ success: true, data: updated })
  } catch (err) {
    next(err)
  }
})

// 批次增加人员
router.post('/batches/:batchId/employees', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const { batchId } = req.params
    const { employeeIds } = req.body as { employeeIds: string[] }
    const orgId = req.user!.orgId

    const batch = await prisma.payrollBatch.findFirst({ where: { id: batchId, orgId } })
    if (!batch) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '批次不存在' } })
    if (batch.status === 'ARCHIVED') return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '已归档批次不可编辑' } })

    const results: any[] = []
    for (const employeeId of employeeIds) {
      // 检查是否已在批次中
      const existing = await prisma.batchEntry.findUnique({
        where: { batchId_employeeId: { batchId, employeeId } },
      })
      if (existing) continue

      const emp = await prisma.employee.findFirst({
        where: { id: employeeId, orgId },
        include: { contracts: { orderBy: { createdAt: 'desc' }, take: 1 } },
      })
      if (!emp) continue

      let baseSalary = 0
      if (emp.contracts?.[0]?.probationSalary && new Date(emp.contracts[0].startDate) > new Date(Date.now() - 365 * 24 * 60 * 60 * 1000)) {
        baseSalary = emp.contracts[0].probationSalary
      } else if (emp.monthlySalary) {
        try { baseSalary = Number(decrypt(emp.monthlySalary)) || 0 } catch { baseSalary = Number(emp.monthlySalary) || 0 }
      }

      const overtime = await prisma.overtimeRecord.findUnique({
        where: { employeeId_month: { employeeId, month: batch.month } },
      })
      const overtimePay = overtime?.totalPay || 0

      // calcBatchEntry 内部会按员工检查当月已归档批次是否已扣社保，已扣则跳过
      const calcResult = await calcBatchEntry(orgId, employeeId, batch.month, { baseSalary, overtimePay, allowance: 0, deduction: 0, bonus: 0 }, batch.type)
      const riskWarnings = await getPayrollRiskWarnings(orgId, employeeId)

      const entry = await prisma.batchEntry.create({
        data: {
          batchId, orgId, employeeId,
          baseSalary, overtimePay, allowance: 0, deduction: 0, bonus: 0,
          ...calcResult, riskWarnings,
        },
      })
      results.push(entry)
    }

    // 更新批次人数和汇总
    const allEntries = await prisma.batchEntry.findMany({ where: { batchId } })
    const totals = allEntries.reduce((acc, e) => ({
      totalPay: acc.totalPay + e.totalPay,
      totalNetPay: acc.totalNetPay + e.netPay,
      totalSocialOrg: acc.totalSocialOrg + e.socialOrg,
      totalSocialEmp: acc.totalSocialEmp + e.socialEmp,
      totalHousingOrg: acc.totalHousingOrg + e.housingOrg,
      totalHousingEmp: acc.totalHousingEmp + e.housingEmp,
      totalTax: acc.totalTax + e.tax,
    }), { totalPay: 0, totalNetPay: 0, totalSocialOrg: 0, totalSocialEmp: 0, totalHousingOrg: 0, totalHousingEmp: 0, totalTax: 0 })
    await prisma.payrollBatch.update({
      where: { id: batchId },
      data: {
        employeeCount: allEntries.length,
        totalPay: Math.round(totals.totalPay * 100) / 100,
        totalNetPay: Math.round(totals.totalNetPay * 100) / 100,
        totalSocialOrg: Math.round(totals.totalSocialOrg * 100) / 100,
        totalSocialEmp: Math.round(totals.totalSocialEmp * 100) / 100,
        totalHousingOrg: Math.round(totals.totalHousingOrg * 100) / 100,
        totalHousingEmp: Math.round(totals.totalHousingEmp * 100) / 100,
        totalTax: Math.round(totals.totalTax * 100) / 100,
      },
    })

    res.json({ success: true, data: { added: results.length } })
  } catch (err) {
    next(err)
  }
})

// 批次移除人员
router.delete('/batches/:batchId/employees/:employeeId', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const { batchId, employeeId } = req.params
    const orgId = req.user!.orgId

    const batch = await prisma.payrollBatch.findFirst({ where: { id: batchId, orgId } })
    if (!batch) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '批次不存在' } })
    if (batch.status === 'ARCHIVED') return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '已归档批次不可编辑' } })

    await prisma.batchEntry.deleteMany({ where: { batchId, employeeId } })

    // 更新批次人数和汇总
    const allEntries = await prisma.batchEntry.findMany({ where: { batchId } })
    const totals = allEntries.reduce((acc, e) => ({
      totalPay: acc.totalPay + e.totalPay,
      totalNetPay: acc.totalNetPay + e.netPay,
      totalSocialOrg: acc.totalSocialOrg + e.socialOrg,
      totalSocialEmp: acc.totalSocialEmp + e.socialEmp,
      totalHousingOrg: acc.totalHousingOrg + e.housingOrg,
      totalHousingEmp: acc.totalHousingEmp + e.housingEmp,
      totalTax: acc.totalTax + e.tax,
    }), { totalPay: 0, totalNetPay: 0, totalSocialOrg: 0, totalSocialEmp: 0, totalHousingOrg: 0, totalHousingEmp: 0, totalTax: 0 })
    await prisma.payrollBatch.update({
      where: { id: batchId },
      data: {
        employeeCount: allEntries.length,
        totalPay: Math.round(totals.totalPay * 100) / 100,
        totalNetPay: Math.round(totals.totalNetPay * 100) / 100,
        totalSocialOrg: Math.round(totals.totalSocialOrg * 100) / 100,
        totalSocialEmp: Math.round(totals.totalSocialEmp * 100) / 100,
        totalHousingOrg: Math.round(totals.totalHousingOrg * 100) / 100,
        totalHousingEmp: Math.round(totals.totalHousingEmp * 100) / 100,
        totalTax: Math.round(totals.totalTax * 100) / 100,
      },
    })

    res.json({ success: true })
  } catch (err) {
    next(err)
  }
})

// 删除批次（仅限草稿状态）
router.delete('/batches/:batchId', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const { batchId } = req.params
    const orgId = req.user!.orgId

    const batch = await prisma.payrollBatch.findFirst({ where: { id: batchId, orgId } })
    if (!batch) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '批次不存在' } })
    if (batch.status === 'ARCHIVED') return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '已归档批次不可删除' } })

    await prisma.batchEntry.deleteMany({ where: { batchId } })
    await prisma.payrollBatch.delete({ where: { id: batchId } })

    res.json({ success: true })
  } catch (err) {
    next(err)
  }
})

// 归档批次
router.post('/batches/:batchId/archive', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const { batchId } = req.params
    const orgId = req.user!.orgId

    const batch = await prisma.payrollBatch.findFirst({ where: { id: batchId, orgId } })
    if (!batch) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '批次不存在' } })
    if (batch.status === 'ARCHIVED') return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '批次已归档' } })

    await prisma.payrollBatch.update({
      where: { id: batchId },
      data: { status: 'ARCHIVED', archivedAt: new Date() },
    })

    res.json({ success: true, data: { archived: true } })
  } catch (err) {
    next(err)
  }
})

// 取消归档（只能取消最后一个归档批次，依次取消）
router.post('/batches/:batchId/unarchive', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const { batchId } = req.params
    const orgId = req.user!.orgId

    const batch = await prisma.payrollBatch.findFirst({ where: { id: batchId, orgId } })
    if (!batch) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '批次不存在' } })
    if (batch.status !== 'ARCHIVED') return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '仅已归档批次可取消归档' } })

    // 检查是否是最后一个归档批次（按 batchNo 倒序）
    const lastArchived = await prisma.payrollBatch.findFirst({
      where: { orgId, month: batch.month, status: 'ARCHIVED' },
      orderBy: { batchNo: 'desc' },
      select: { id: true },
    })
    if (lastArchived?.id !== batchId) {
      return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '只能依次取消归档，请先取消最后归档的批次' } })
    }

    // 取消归档
    await prisma.payrollBatch.update({
      where: { id: batchId },
      data: { status: 'DRAFT', archivedAt: null },
    })

    // 如果当月已无归档批次，删除对应工资条（取消个税累计）
    const remainingArchived = await prisma.payrollBatch.count({
      where: { orgId, month: batch.month, status: 'ARCHIVED' },
    })
    if (remainingArchived === 0) {
      // 查找该月所有批次的员工，删除其工资条
      const entries = await prisma.batchEntry.findMany({
        where: { orgId, batch: { month: batch.month } },
        select: { employeeId: true },
        distinct: ['employeeId'],
      })
      if (entries.length > 0) {
        await prisma.payslip.deleteMany({
          where: {
            orgId,
            employeeId: { in: entries.map(e => e.employeeId) },
            month: batch.month,
          },
        })
      }
    } else {
      // 还有归档批次，重新生成工资条（基于剩余归档批次汇总）
      await generatePayslipFromBatches(orgId, batch.month)
    }

    res.json({ success: true, data: { unarchived: true } })
  } catch (err) {
    next(err)
  }
})

// 从已归档批次汇总生成工资条
router.post('/payslips/generate', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const { month } = req.body
    const orgId = req.user!.orgId

    if (!month || !/^\d{4}-\d{2}$/.test(month)) {
      return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '请提供有效的月份（YYYY-MM）' } })
    }

    // 检查是否有已归档批次
    const archivedBatches = await prisma.payrollBatch.count({
      where: { orgId, month, status: 'ARCHIVED' },
    })
    if (archivedBatches === 0) {
      return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '当月无已归档批次，无法生成工资条' } })
    }

    const result = await generatePayslipFromBatches(orgId, month)

    // 自动标记"生成工资条"待办为已完成
    await prisma.riskItem.updateMany({
      where: { orgId, status: 'PENDING', type: 'SALARY', title: { startsWith: `${month}月 生成工资条` } },
      data: { status: 'RESOLVED', resolvedAt: new Date(), resolvedBy: req.user!.id },
    })

    res.json({ success: true, data: { generated: result.generated } })
  } catch (err) {
    next(err)
  }
})

// 银行代发文件导出（接口预留）
router.get('/batches/:batchId/export', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const { batchId } = req.params
    const orgId = req.user!.orgId
    const { format = 'csv' } = req.query

    const batch = await prisma.payrollBatch.findFirst({
      where: { id: batchId, orgId },
      include: {
        entries: {
          include: { employee: { select: { name: true, bankAccount: true, bankName: true } } },
        },
      },
    })
    if (!batch) return res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: '批次不存在' } })
    if (batch.status !== 'ARCHIVED') return res.status(400).json({ success: false, error: { code: 'BAD_REQUEST', message: '仅归档批次可导出' } })

    if (format === 'csv') {
      const header = '姓名,银行账号,开户行,实发金额\n'
      const rows = batch.entries.map(e => `${e.employee.name},${e.employee.bankAccount || ''},${e.employee.bankName || ''},${e.netPay}`).join('\n')
      res.setHeader('Content-Type', 'text/csv; charset=utf-8')
      res.setHeader('Content-Disposition', `attachment; filename="payroll-${batch.month}-batch${batch.batchNo}.csv"`)
      return res.send('\ufeff' + header + rows)
    }

    res.json({ success: true, data: batch })
  } catch (err) {
    next(err)
  }
})

// 算薪前 AI 校验
router.get('/batches/:batchId/pre-check', async (req: AuthRequest, res: Response, next: NextFunction) => {
  try {
    const result = await prePayrollCheck(req.user!.orgId, req.params.batchId)
    res.json({ success: true, data: result })
  } catch (err: any) {
    if (err?.code === 'NOT_FOUND') {
      return res.status(404).json({ success: false, error: { code: err.code, message: err.message } })
    }
    next(err)
  }
})

export default router