package com.ruoyi.staff.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.project.system.domain.SysDept;
import com.ruoyi.project.system.mapper.SysDeptMapper;
import com.ruoyi.project.system.mapper.SysUserDeptMapper;
import com.ruoyi.production.mapper.ProductionAccountMapper;
import com.ruoyi.production.pojo.ProductionAccount;
import com.ruoyi.technology.mapper.TechnologyOperationMapper;
import com.ruoyi.technology.pojo.TechnologyOperation;
import com.ruoyi.staff.excel.StaffSalaryExportData;
import jakarta.servlet.http.HttpServletResponse;
import com.ruoyi.staff.dto.CalculateSalaryDto;
import com.ruoyi.staff.dto.StaffSalaryCalculateDto;
import com.ruoyi.staff.mapper.StaffLeaveMapper;
import com.ruoyi.staff.mapper.StaffSalaryDetailMapper;
import com.ruoyi.staff.mapper.StaffSalaryMainMapper;
import com.ruoyi.staff.pojo.StaffLeave;
import com.ruoyi.staff.pojo.StaffSalaryDetail;
import com.ruoyi.staff.pojo.StaffSalaryMain;
import com.ruoyi.staff.service.StaffSalaryDetailService;
import com.ruoyi.staff.service.StaffSalaryMainService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.stream.Collectors;
import java.time.LocalDate;
import java.time.YearMonth;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.IOException;

/**
 * <p>
 * 员工工资主表 服务实现类
 * </p>
 *
 * @author 芯导软件（江苏）有限公司
 * @since 2026-03-06 01:22:05
 */
@Service
@RequiredArgsConstructor
public class StaffSalaryMainServiceImpl extends ServiceImpl<StaffSalaryMainMapper, StaffSalaryMain> implements StaffSalaryMainService {

    private final StaffSalaryMainMapper staffSalaryMainMapper;
    private final StaffSalaryDetailService staffSalaryDetailService;
    private final StaffSalaryDetailMapper staffSalaryDetailMapper;
    private final SchemeApplicableStaffServiceImpl schemeApplicableStaffService;
    private final SysUserDeptMapper sysUserDeptMapper;
    private final StaffLeaveMapper staffLeaveMapper;
    private final SysDeptMapper sysDeptMapper;
    private final ProductionAccountMapper productionAccountMapper;
    private final TechnologyOperationMapper technologyOperationMapper;

    @Override
    public AjaxResult listPage(Page page, StaffSalaryMain staffSalaryMain) {
        LambdaQueryWrapper<StaffSalaryMain> staffSalaryMainLambdaQueryWrapper = new LambdaQueryWrapper<>();
        if(staffSalaryMain != null){
            if(StringUtils.isNotEmpty(staffSalaryMain.getSalaryTitle())){
                staffSalaryMainLambdaQueryWrapper.like(StaffSalaryMain::getSalaryTitle, staffSalaryMain.getSalaryTitle());
            }
            if(StringUtils.isNotEmpty(staffSalaryMain.getSalaryMonth())){
                staffSalaryMainLambdaQueryWrapper.like(StaffSalaryMain::getSalaryMonth, staffSalaryMain.getSalaryMonth());
            }
            if(staffSalaryMain.getStatus() != null){
                staffSalaryMainLambdaQueryWrapper.eq(StaffSalaryMain::getStatus, staffSalaryMain.getStatus());
            }
        }
        staffSalaryMainLambdaQueryWrapper.orderByDesc(StaffSalaryMain::getId);
        Page<StaffSalaryMain> page1 = staffSalaryMainMapper.selectPage(page, staffSalaryMainLambdaQueryWrapper);
        page1.getRecords().forEach(main -> {
            List<StaffSalaryDetail> staffSalaryDetailList = staffSalaryDetailMapper.selectList(new LambdaQueryWrapper<StaffSalaryDetail>().eq(StaffSalaryDetail::getMainId, main.getId()));
            main.setStaffSalaryDetailList(staffSalaryDetailList);
        });
        return AjaxResult.success(page1);
    }

    @Override
    public AjaxResult add(StaffSalaryMain staffSalaryMain) {
        if (staffSalaryMain == null || StringUtils.isEmpty(staffSalaryMain.getSalaryMonth())) {
            return AjaxResult.error("参数错误");
        }

        Integer status = staffSalaryMain.getStatus();
        if (status != null && status == 5) {
            String salaryMonth = staffSalaryMain.getSalaryMonth();
            String deptIds = staffSalaryMain.getDeptIds();

            List<StaffSalaryMain> issuedList = staffSalaryMainMapper.selectList(new LambdaQueryWrapper<StaffSalaryMain>()
                    .eq(StaffSalaryMain::getSalaryMonth, salaryMonth)
                    .eq(StaffSalaryMain::getStatus, 5));

            for (StaffSalaryMain issued : issuedList) {
                if (hasOverlappingDept(deptIds, issued.getDeptIds())) {
                    return AjaxResult.error("同一月份同一部门工资不可以发放多次");
                }
            }
        }

        staffSalaryMainMapper.insert(staffSalaryMain);
        staffSalaryMain.getStaffSalaryDetailList().forEach(detail -> {
            detail.setMainId(staffSalaryMain.getId());
        });
        staffSalaryDetailService.saveBatch(staffSalaryMain.getStaffSalaryDetailList());
        return AjaxResult.success("新增成功");
    }

    @Override
    public AjaxResult updateStaffSalaryMain(StaffSalaryMain staffSalaryMain) {
        if(staffSalaryMain == null){
            return AjaxResult.error("参数错误");
        }
        StaffSalaryMain staffSalaryMain1 = staffSalaryMainMapper.selectById(staffSalaryMain.getId());
        if(staffSalaryMain1 == null){
            return AjaxResult.error("参数错误");
        }

        Integer newStatus = staffSalaryMain.getStatus();
        if (newStatus != null && newStatus == 5) {
            String salaryMonth = staffSalaryMain.getSalaryMonth();
            if (StringUtils.isEmpty(salaryMonth)) {
                salaryMonth = staffSalaryMain1.getSalaryMonth();
            }
            String deptIds = staffSalaryMain.getDeptIds();
            if (StringUtils.isEmpty(deptIds)) {
                deptIds = staffSalaryMain1.getDeptIds();
            }

            List<StaffSalaryMain> issuedList = staffSalaryMainMapper.selectList(new LambdaQueryWrapper<StaffSalaryMain>()
                    .eq(StaffSalaryMain::getSalaryMonth, salaryMonth)
                    .eq(StaffSalaryMain::getStatus, 5)
                    .ne(StaffSalaryMain::getId, staffSalaryMain.getId()));

            for (StaffSalaryMain issued : issuedList) {
                if (hasOverlappingDept(deptIds, issued.getDeptIds())) {
                    return AjaxResult.error("同一月份同一部门工资不可以发放多次");
                }
            }
        }

        // 待审核不可编辑
//        if(staffSalaryMain1.getStatus() > 3){
//            return AjaxResult.error("待审核不可编辑");
//        }
        staffSalaryMainMapper.updateById(staffSalaryMain);
        if(org.apache.commons.collections4.CollectionUtils.isNotEmpty(staffSalaryMain.getStaffSalaryDetailList())){
            staffSalaryDetailMapper.delete(new LambdaQueryWrapper<StaffSalaryDetail>().eq(StaffSalaryDetail::getMainId, staffSalaryMain.getId()));
            staffSalaryMain.getStaffSalaryDetailList().forEach(detail -> {
                detail.setMainId(staffSalaryMain.getId());
            });
            staffSalaryDetailService.saveBatch(staffSalaryMain.getStaffSalaryDetailList());
        }
        return AjaxResult.success("修改成功");
    }

    @Override
    public AjaxResult delete(List<Long> ids) {
        if(CollectionUtils.isEmpty(ids)){
            return AjaxResult.error("参数错误");
        }
        staffSalaryMainMapper.deleteBatchIds(ids);
        staffSalaryDetailMapper.delete(new LambdaQueryWrapper<StaffSalaryDetail>().in(StaffSalaryDetail::getMainId, ids));
        return AjaxResult.success("删除成功");
    }

    @Override
    public AjaxResult calculateSalary(CalculateSalaryDto calculateSalaryDto) {
        if(CollectionUtils.isEmpty(calculateSalaryDto.getIds())){
            return AjaxResult.error("参数错误");
        }
        java.math.BigDecimal deductAmount = calculateSalaryDto.getDeductAmount() == null
                ? java.math.BigDecimal.ZERO
                : calculateSalaryDto.getDeductAmount();
        List<Map<String, Object>> longs = setSchemeApplicableStaffUserInfo(calculateSalaryDto.getIds()); // 通过部门ids获取用户信息
        if(CollectionUtils.isEmpty(longs)){
            return AjaxResult.error("无员工");
        }
        List<Map<String, Object>> mapList = new ArrayList<>();
        for (Map<String, Object> id : longs) {
            Long staffOnJobId = id.get("id") == null ? null : ((Number) id.get("id")).longValue();
            // 判断员工是否为当月离职
            if((Integer) id.get("staffState") == 0){
                StaffLeave id1 = staffLeaveMapper.selectOne(new LambdaQueryWrapper<StaffLeave>()
                        .eq(StaffLeave::getStaffOnJobId, staffOnJobId)
                        .like(StaffLeave::getLeaveDate, calculateSalaryDto.getDate()));
                if(id1 == null){
                    continue;
                }
            }
            id.put("otherDeduct", deductAmount);
            Long sysUserId = schemeApplicableStaffService.getUidByStaffId(staffOnJobId);
            BigDecimal monthTimeTotal = resolveMonthTimeTotal(sysUserId, calculateSalaryDto.getDate());
            id.put("monthTimeTotal", monthTimeTotal);
            id.put("convertedWorkHours", monthTimeTotal);
            schemeApplicableStaffService.calculateByEmployeeId(staffOnJobId == null ? null : staffOnJobId.intValue(), id, calculateSalaryDto.getDate());
            mapList.add(id);
        }
        return AjaxResult.success(mapList);
    }

    @Override
    public AjaxResult calculateSalaryByEmployee(StaffSalaryCalculateDto staffSalaryCalculateDto) {
        if (staffSalaryCalculateDto == null
                || staffSalaryCalculateDto.getStaffOnJobId() == null
                || StringUtils.isEmpty(staffSalaryCalculateDto.getSalaryMonth())) {
            return AjaxResult.error("参数错误");
        }
        Map<String, Object> map = new HashMap<>();
        map.put("id", staffSalaryCalculateDto.getStaffOnJobId());
        map.put("staffOnJobId", staffSalaryCalculateDto.getStaffOnJobId());
        map.put("salaryMonth", staffSalaryCalculateDto.getSalaryMonth());
        map.put("staffName", staffSalaryCalculateDto.getStaffName());
        map.put("postName", staffSalaryCalculateDto.getPostName());
        map.put("deptName", staffSalaryCalculateDto.getDeptName());
        if (staffSalaryCalculateDto.getBasicSalary() != null) {
            map.put("basicSalary", staffSalaryCalculateDto.getBasicSalary());
        }
        map.put("attendanceBonus", staffSalaryCalculateDto.getAttendanceBonus());
        map.put("pieceSalary", staffSalaryCalculateDto.getPieceSalary());
        map.put("hourlySalary", staffSalaryCalculateDto.getHourlySalary());
        map.put("monthWorkDays", staffSalaryCalculateDto.getMonthWorkDays());
        map.put("standardHours", staffSalaryCalculateDto.getStandardHours());
        map.put("monthTimeTotal", staffSalaryCalculateDto.getMonthTimeTotal());
        map.put("conversionRatio", staffSalaryCalculateDto.getConversionRatio());
        map.put("convertedWorkHours", staffSalaryCalculateDto.getConvertedWorkHours());
        map.put("actualOutput", staffSalaryCalculateDto.getActualOutput());
        map.put("standardQuantity", staffSalaryCalculateDto.getStandardQuantity());
        map.put("conversionFactor", staffSalaryCalculateDto.getConversionFactor());
        map.put("otherIncome", staffSalaryCalculateDto.getOtherIncome());
        map.put("socialPersonal", staffSalaryCalculateDto.getSocialPersonal());
        map.put("fundPersonal", staffSalaryCalculateDto.getFundPersonal());
        map.put("otherDeduct", staffSalaryCalculateDto.getOtherDeduct());
        map.put("socialSupplementAmount", staffSalaryCalculateDto.getSocialSupplementAmount());
        map.put("salaryTax", staffSalaryCalculateDto.getSalaryTax());
        map.put("grossSalary", staffSalaryCalculateDto.getGrossSalary());
        map.put("deductSalary", staffSalaryCalculateDto.getDeductSalary());
        map.put("netSalary", staffSalaryCalculateDto.getNetSalary());
        map.put("remark", staffSalaryCalculateDto.getRemark());
        schemeApplicableStaffService.calculateByEmployeeId(
                staffSalaryCalculateDto.getStaffOnJobId().intValue(),
                map,
                staffSalaryCalculateDto.getSalaryMonth()
        );
        return AjaxResult.success(map);
    }

    @Override
    public void exportSalaryDetail(HttpServletResponse response, String salaryMonth) {
        LambdaQueryWrapper<StaffSalaryMain> mainWrapper = new LambdaQueryWrapper<>();
        if (StringUtils.isNotEmpty(salaryMonth)) {
            mainWrapper.eq(StaffSalaryMain::getSalaryMonth, salaryMonth);
        }
        List<StaffSalaryMain> mainList = staffSalaryMainMapper.selectList(mainWrapper);

        List<StaffSalaryExportData> exportDataList = new ArrayList<>();
        for (StaffSalaryMain main : mainList) {
            List<StaffSalaryDetail> detailList = staffSalaryDetailMapper.selectList(
                    new LambdaQueryWrapper<StaffSalaryDetail>().eq(StaffSalaryDetail::getMainId, main.getId())
            );

            for (StaffSalaryDetail detail : detailList) {
                StaffSalaryExportData exportData = new StaffSalaryExportData();
                exportData.setSalaryMonth(main.getSalaryMonth());
                exportData.setSalaryTitle(main.getSalaryTitle());
                exportData.setStaffName(detail.getStaffName());
                exportData.setDeptName(detail.getDeptName());
                exportData.setBasicSalary(detail.getBasicSalary());
                exportData.setAttendanceBonus(detail.getAttendanceBonus());
                exportData.setPieceSalary(detail.getPieceSalary());
                exportData.setHourlySalary(detail.getHourlySalary());
                exportData.setMonthWorkDays(detail.getMonthWorkDays());
                exportData.setStandardHours(detail.getStandardHours());
                exportData.setMonthTimeTotal(detail.getMonthTimeTotal());
                exportData.setConversionRatio(detail.getConversionRatio());
                exportData.setConvertedWorkHours(detail.getConvertedWorkHours());
                exportData.setOtherIncome(detail.getOtherIncome());
                exportData.setSocialPersonal(detail.getSocialPersonal());
                exportData.setFundPersonal(detail.getFundPersonal());
                exportData.setOtherDeduct(detail.getOtherDeduct());
                exportData.setSocialSupplementAmount(detail.getSocialSupplementAmount());
                exportData.setSalaryTax(detail.getSalaryTax());
                exportData.setGrossSalary(detail.getGrossSalary());
                exportData.setDeductSalary(detail.getDeductSalary());
                exportData.setNetSalary(detail.getNetSalary());
                exportData.setRemark(detail.getRemark());
                exportDataList.add(exportData);
            }
        }

        ExcelUtil<StaffSalaryExportData> util = new ExcelUtil<>(StaffSalaryExportData.class);
        util.exportExcel(response, exportDataList, "员工薪资明细");
    }

    /**
     * 汇总员工当月月时间合计。
     * 计时工序直接取工时，计件工序按产量折算后再叠加补修理工时。
     */
    private java.math.BigDecimal resolveMonthTimeTotal(Long sysUserId, String date) {
        if (sysUserId == null || sysUserId <= 0 || StringUtils.isEmpty(date)) {
            return java.math.BigDecimal.ZERO.setScale(2, java.math.RoundingMode.HALF_UP);
        }
        java.math.BigDecimal total = java.math.BigDecimal.ZERO.setScale(2, java.math.RoundingMode.HALF_UP);
        java.util.List<java.util.Map<String, Object>> items = productionAccountMapper.selectMonthSalaryCalcItems(sysUserId, date);
        for (java.util.Map<String, Object> item : items) {
            Integer operationType = item.get("operationType") == null ? null : ((Number) item.get("operationType")).intValue();
            java.math.BigDecimal finishedNum = toDecimal(item.get("finishedNum"));
            java.math.BigDecimal workHour = toDecimal(item.get("workHour"));
            java.math.BigDecimal repairWorkHour = toDecimal(item.get("repairWorkHour"));
            java.math.BigDecimal standardQuantity = toDecimal(item.get("standardQuantity"));
            java.math.BigDecimal conversionFactor = toDecimal(item.get("conversionFactor"));
            java.math.BigDecimal rowTotal;
            if (Integer.valueOf(0).equals(operationType)) {
                rowTotal = workHour.add(repairWorkHour);
            } else {
                if (standardQuantity.compareTo(java.math.BigDecimal.ZERO) <= 0) {
                    rowTotal = java.math.BigDecimal.ZERO.setScale(2, java.math.RoundingMode.HALF_UP);
                } else {
                    rowTotal = finishedNum
                            .divide(standardQuantity, 8, java.math.RoundingMode.HALF_UP)
                            .multiply(new java.math.BigDecimal("8"))
                            .multiply(conversionFactor)
                            .add(repairWorkHour)
                            .setScale(2, java.math.RoundingMode.HALF_UP);
                }
            }
            total = total.add(rowTotal).setScale(2, java.math.RoundingMode.HALF_UP);
        }
        return total;
    }

    private java.math.BigDecimal toDecimal(Object value) {
        if (value == null) {
            return java.math.BigDecimal.ZERO.setScale(2, java.math.RoundingMode.HALF_UP);
        }
        if (value instanceof java.math.BigDecimal) {
            return ((java.math.BigDecimal) value).setScale(2, java.math.RoundingMode.HALF_UP);
        }
        if (value instanceof Number) {
            return new java.math.BigDecimal(String.valueOf(value)).setScale(2, java.math.RoundingMode.HALF_UP);
        }
        String text = String.valueOf(value).trim();
        if (text.isEmpty()) {
            return java.math.BigDecimal.ZERO.setScale(2, java.math.RoundingMode.HALF_UP);
        }
        return new java.math.BigDecimal(text).setScale(2, java.math.RoundingMode.HALF_UP);
    }

    @Override
    public void exportWorkHours(HttpServletResponse response, String salaryMonth) {
        List<ProductionAccount> accountList = queryProductionAccounts(salaryMonth);
        List<String> operationNames = accountList.stream()
                .map(ProductionAccount::getTechnologyOperationName)
                .filter(StringUtils::isNotEmpty)
                .distinct()
                .sorted()
                .collect(Collectors.toList());
        Workbook workbook = new XSSFWorkbook();
        CellStyle titleStyle = createStyle(workbook, true, HorizontalAlignment.CENTER, 14, false);
        CellStyle headerStyle = createStyle(workbook, false, HorizontalAlignment.CENTER, 11, false);
        CellStyle labelStyle = createStyle(workbook, false, HorizontalAlignment.CENTER, 10, false);
        CellStyle numStyle = createStyle(workbook, false, HorizontalAlignment.CENTER, 10, false);
        DataFormat dataFormat = workbook.createDataFormat();
        numStyle.setDataFormat(dataFormat.getFormat("0.00"));

        if (CollectionUtils.isEmpty(operationNames)) {
            operationNames = new ArrayList<>();
        }

        int sheetIndex = 1;
        for (String operationName : operationNames) {
            TechnologyOperation operation = technologyOperationMapper.selectOne(
                    new LambdaQueryWrapper<TechnologyOperation>().eq(TechnologyOperation::getName, operationName).last("limit 1"));
            String sheetName = operationName;
            if (sheetName.length() > 31) {
                sheetName = sheetName.substring(0, 31);
            }
            Sheet sheet = workbook.createSheet(sheetName);
            int rowIdx = 0;
            Row titleRow = sheet.createRow(rowIdx++);
            titleRow.setHeightInPoints(52.5f);
            titleRow.createCell(0).setCellValue(operationName + "工时统计");
            titleRow.getCell(0).setCellStyle(titleStyle);
            sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 3));

            Row workDayRow = sheet.createRow(rowIdx++);
            workDayRow.createCell(0).setCellValue("工作日");
            workDayRow.getCell(0).setCellStyle(headerStyle);
            Integer monthWorkDays = calculateWorkDays(salaryMonth);
            createNumberCell(workDayRow, 2, monthWorkDays == null ? null : new java.math.BigDecimal(monthWorkDays), headerStyle);
            workDayRow.createCell(3).setCellValue("天");
            workDayRow.getCell(3).setCellStyle(headerStyle);
            createNumberCell(workDayRow, 4, monthWorkDays == null ? null : new java.math.BigDecimal(monthWorkDays * 8), headerStyle);
            workDayRow.createCell(5).setCellValue("小时");
            workDayRow.getCell(5).setCellStyle(headerStyle);

            Row headRow = sheet.createRow(rowIdx++);
            headRow.createCell(0).setCellValue("人员");
            headRow.getCell(0).setCellStyle(headerStyle);
            headRow.createCell(1).setCellValue("月产量");
            headRow.getCell(1).setCellStyle(headerStyle);
            headRow.createCell(2).setCellValue("折算时长");
            headRow.getCell(2).setCellStyle(headerStyle);
            headRow.createCell(3).setCellValue("工资");
            headRow.getCell(3).setCellStyle(headerStyle);

            Map<String, java.math.BigDecimal> standardMap = buildStandardQuantityMap(List.of(operationName));
            Map<String, java.math.BigDecimal> opQtyMap = buildOperationQuantityMap(accountList, operationName);
            Set<String> employeeNames = accountList.stream()
                    .map(ProductionAccount::getSchedulingUserName)
                    .filter(StringUtils::isNotEmpty)
                    .collect(Collectors.toCollection(LinkedHashSet::new));
            for (String staffName : employeeNames) {
                Row row = sheet.createRow(rowIdx++);
                row.createCell(0).setCellValue(staffName);
                row.getCell(0).setCellStyle(labelStyle);
                java.math.BigDecimal qty = opQtyMap.getOrDefault(staffName, java.math.BigDecimal.ZERO);
                createNumberCell(row, 1, qty, numStyle);
                java.math.BigDecimal standardQty = standardMap.getOrDefault(operationName, java.math.BigDecimal.ONE);
                createNumberCell(row, 2, standardQty.compareTo(java.math.BigDecimal.ZERO) == 0 ? java.math.BigDecimal.ZERO : qty.divide(standardQty, 2, java.math.RoundingMode.HALF_UP).multiply(new java.math.BigDecimal("8")), numStyle);
                java.math.BigDecimal wage = operation == null || operation.getSalaryQuota() == null
                        ? java.math.BigDecimal.ZERO
                        : (Integer.valueOf(1).equals(operation.getType()) ? operation.getSalaryQuota().multiply(qty) : operation.getSalaryQuota());
                createNumberCell(row, 3, wage, numStyle);
            }

            for (int i = 0; i <= 3; i++) {
                sheet.autoSizeColumn(i);
            }
            sheetIndex++;
        }

        try {
            response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
            response.setCharacterEncoding("UTF-8");
            String fileName = java.net.URLEncoder.encode("工时表.xlsx", java.nio.charset.StandardCharsets.UTF_8);
            response.setHeader("Content-Disposition", "attachment; filename*=UTF-8''" + fileName);
            workbook.write(response.getOutputStream());
            workbook.close();
        } catch (IOException e) {
            throw new RuntimeException("导出工时表失败", e);
        }
    }

    public List<Map<String, Object>> setSchemeApplicableStaffUserInfo(List<Long> ids) {
        if(CollectionUtils.isEmpty(ids)){
            return new ArrayList<>();
        }
        // 通过部门获取人员id
        return sysUserDeptMapper.setSchemeApplicableStaffUserInfo(ids);
    }

    @Override
    public AjaxResult getAvailableDepts(String salaryMonth) {
        if (StringUtils.isEmpty(salaryMonth)) {
            return AjaxResult.error("工资月份不能为空");
        }

        List<String> issuedDeptIdStrings = staffSalaryMainMapper.selectIssuedDeptIds(salaryMonth);

        Set<Long> issuedDeptIds = new HashSet<>();
        for (String deptIds : issuedDeptIdStrings) {
            if (StringUtils.isNotEmpty(deptIds)) {
                String[] ids = deptIds.split(",");
                for (String id : ids) {
                    issuedDeptIds.add(Long.parseLong(id.trim()));
                }
            }
        }

        List<SysDept> allDepts = sysDeptMapper.selectList(new LambdaQueryWrapper<SysDept>()
                .eq(SysDept::getStatus, "0")
                .eq(SysDept::getDelFlag, "0"));

        List<SysDept> availableDepts = new ArrayList<>();
        for (SysDept dept : allDepts) {
            if (!issuedDeptIds.contains(dept.getDeptId())) {
                availableDepts.add(dept);
            }
        }

        return AjaxResult.success(availableDepts);
    }

    private boolean hasOverlappingDept(String deptIds1, String deptIds2) {
        if (StringUtils.isEmpty(deptIds1) || StringUtils.isEmpty(deptIds2)) {
            return false;
        }

        Set<String> deptSet1 = new HashSet<>(Arrays.asList(deptIds1.split(",")));
        String[] deptArray2 = deptIds2.split(",");

        for (String deptId : deptArray2) {
            if (deptSet1.contains(deptId.trim())) {
                return true;
            }
        }
        return false;
    }

    private String buildWorkHoursTitle(StaffSalaryMain main) {
        String month = StringUtils.isNotEmpty(main.getSalaryMonth()) ? main.getSalaryMonth() : "未知月份";
        return month + "工时统计";
    }

    private Integer calculateWorkDays(String salaryMonth) {
        if (StringUtils.isEmpty(salaryMonth)) {
            return 0;
        }
        java.time.YearMonth yearMonth = java.time.YearMonth.parse(salaryMonth);
        int workDays = 0;
        for (int day = 1; day <= yearMonth.lengthOfMonth(); day++) {
            java.time.DayOfWeek dayOfWeek = yearMonth.atDay(day).getDayOfWeek();
            if (dayOfWeek != java.time.DayOfWeek.SATURDAY && dayOfWeek != java.time.DayOfWeek.SUNDAY) {
                workDays++;
            }
        }
        return workDays;
    }

    private CellStyle createStyle(Workbook workbook, boolean bold, HorizontalAlignment alignment, int fontSize, boolean fill) {
        Font font = workbook.createFont();
        font.setFontName("Microsoft YaHei");
        font.setFontHeightInPoints((short) fontSize);
        font.setBold(bold);
        CellStyle style = workbook.createCellStyle();
        style.setFont(font);
        style.setAlignment(alignment);
        style.setVerticalAlignment(VerticalAlignment.CENTER);
        style.setBorderTop(BorderStyle.THIN);
        style.setBorderBottom(BorderStyle.THIN);
        style.setBorderLeft(BorderStyle.THIN);
        style.setBorderRight(BorderStyle.THIN);
        if (fill) {
            style.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
            style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
        }
        return style;
    }

    private void createTextCell(Row row, int colIndex, String value, CellStyle style) {
        Cell cell = row.createCell(colIndex);
        cell.setCellValue(value == null ? "" : value);
        cell.setCellStyle(style);
    }

    private void createNumberCell(Row row, int colIndex, java.math.BigDecimal value, CellStyle style) {
        Cell cell = row.createCell(colIndex);
        if (value != null) {
            cell.setCellValue(value.doubleValue());
        }
        cell.setCellStyle(style);
    }

    private void createFormulaCell(Row row, int colIndex, String formula, CellStyle style) {
        Cell cell = row.createCell(colIndex);
        cell.setCellFormula(formula.startsWith("=") ? formula.substring(1) : formula);
        cell.setCellStyle(style);
    }

    private String toCellRef(int colIndex, int rowNum1Based) {
        return cellRef(colIndex) + rowNum1Based;
    }

    private String cellRef(int colIndex) {
        StringBuilder sb = new StringBuilder();
        int col = colIndex;
        do {
            int rem = col % 26;
            sb.insert(0, (char) ('A' + rem));
            col = col / 26 - 1;
        } while (col >= 0);
        return sb.toString();
    }

    private List<ProductionAccount> queryProductionAccounts(String salaryMonth) {
        if (StringUtils.isEmpty(salaryMonth)) {
            return new ArrayList<>();
        }
        YearMonth ym = YearMonth.parse(salaryMonth);
        LocalDate start = ym.atDay(1);
        LocalDate end = ym.atEndOfMonth();
        return productionAccountMapper.selectList(new LambdaQueryWrapper<ProductionAccount>()
                .ge(ProductionAccount::getSchedulingDate, start.atStartOfDay())
                .le(ProductionAccount::getSchedulingDate, end.atTime(23, 59, 59)));
    }

    private Map<String, java.math.BigDecimal> buildOperationQuantityMap(List<ProductionAccount> accountList, String operationName) {
        Map<String, java.math.BigDecimal> map = new LinkedHashMap<>();
        if (CollectionUtils.isEmpty(accountList) || StringUtils.isEmpty(operationName)) {
            return map;
        }
        accountList.stream()
                .filter(item -> item != null && operationName.equals(item.getTechnologyOperationName()))
                .filter(item -> StringUtils.isNotEmpty(item.getSchedulingUserName()))
                .forEach(item -> map.merge(item.getSchedulingUserName(),
                        item.getFinishedNum() == null ? java.math.BigDecimal.ZERO : item.getFinishedNum(),
                        java.math.BigDecimal::add));
        return map;
    }

    private Map<String, java.math.BigDecimal> buildStandardQuantityMap(List<String> operationNames) {
        Map<String, java.math.BigDecimal> map = new LinkedHashMap<>();
        if (CollectionUtils.isEmpty(operationNames)) {
            return map;
        }
        List<TechnologyOperation> operations = technologyOperationMapper.selectList(
                new LambdaQueryWrapper<TechnologyOperation>()
                        .in(TechnologyOperation::getName, operationNames)
        );
        Map<String, java.math.BigDecimal> opMap = operations.stream()
                .filter(item -> item != null && StringUtils.isNotEmpty(item.getName()))
                .collect(Collectors.toMap(
                        TechnologyOperation::getName,
                        item -> item.getStandardQuantity() == null ? java.math.BigDecimal.ZERO : item.getStandardQuantity(),
                        (left, right) -> left,
                        LinkedHashMap::new
                ));
        for (String operationName : operationNames) {
            map.put(operationName, opMap.getOrDefault(operationName, java.math.BigDecimal.ZERO));
        }
        return map;
    }

}