mes-server-api/application/service/UnifiedCostCalculationService.php

<?php

namespace app\service;

use think\Db;
use think\Exception;
use think\Log;

/**
 * 统一成本核算服务类
 * 五项计算完成后统一插入数据库
 */
class UnifiedCostCalculationService
{
    // 存储中间数据的数组
    protected $monthlyCostDetails = [];
    protected $allocationFactors = [];

    // 配置常量
    const FLOOR_GROUP_MAP = [
        '1' => ['02、胶印机组', '03、卷凹机组', '06、单凹机组', '05、圆切机组', '04、圆烫机组', '10、模切机组', '09、烫金机组'],
        '2' => ['01、切纸机组', '11、检品机组', '07、丝印机组', '12、覆膜机组', '08、喷码机组'],
    ];

    // 科目名称映射
    const SUBJECT_MAPPING = [
        '废气处理' => '废气处理',
        '锅炉' => '锅炉',
        '空压机' => '空压机',
        '热水锅炉' => '热水锅炉',
        '真空鼓风机' => '真空鼓风机',
        '中央空调' => '中央空调',
        '待分摊总额' => '待分摊总额',
    ];

    // 字段默认值
    const DEFAULT_FIELD_VALUES = [
        '直接水电' => 0,
        '分摊材料' => 0,
        '车间人工' => 0,
        '部门人工附加' => 0,
        '分摊水电' => 0,
        '废气处理' => 0,
        '锅炉' => 0,
        '空压机' => 0,
        '热水锅炉' => 0,
        '真空鼓风机' => 0,
        '中央空调' => 0,
        '分摊其他' => 0,
        'A_小时折旧额' => 0,
        '直接材料' => 0,
        '考核直接材料' => 0,
        '直接折旧' => 0,
        '分摊折旧' => 0,
        '场地租金' => 0,
        '成本合计' => 0,
    ];

    /** 参与「成本合计」汇总的金额字段（不含考核直接材料，避免与直接材料重复） */
    const COST_TOTAL_SUM_FIELDS = [
        '直接材料',
        '车间人工',
        '部门人工附加',
        '分摊材料',
        '直接水电',
        '分摊水电',
        '废气处理',
        '锅炉',
        '热水锅炉',
        '空压机',
        '真空鼓风机',
        '中央空调',
        '分摊其他',
        '分摊折旧',
        '场地租金',
        '直接折旧',
        'A_小时折旧额',
    ];

    // 添加科目名称到数据库字段的映射
    const SUBJECT_TO_FIELD_MAP = [
        // 真空鼓风机相关
        '真空鼓风机' => '真空鼓风机',
        '真空鼓风' => '真空鼓风机',
        '6#楼真空鼓风' => '真空鼓风机',
        '真空风机' => '真空鼓风机',

        // 废气处理相关
        '废气处理' => '废气处理',
        '废气' => '废气处理',

        // 锅炉相关
        '锅炉' => '锅炉',
        '热水锅炉' => '热水锅炉',

        // 空压机相关
        '空压机' => '空压机',
        '空压' => '空压机',

        // 中央空调相关
        '中央空调' => '中央空调',
        '空调' => '中央空调',

        // 待分摊总额
        '待分摊总额' => '分摊水电',
        '分摊总额' => '分摊水电',
    ];

    // 批次大小
    const BATCH_SIZE = 100;

    /**
     * 主入口：执行所有成本计算并统一入库
     */
    public function calculateAndSaveAll(array $param): array
    {
        Db::startTrans();
        try {


            if (!isset($param['month'])) {
                throw new Exception("缺少必要参数: month");
            }

            $month = $param['month'];
            $sysId = $param['sys_id'] ?? uniqid();

            // 重置数据数组，确保是空数组
            $this->monthlyCostDetails = [];
            $this->allocationFactors = [];

            // 1. 清空旧数据
            $this->clearOldData($month);

            // 2. 执行五项计算
            $this->calculateDirectLabor($param);


            $this->calculateDirectUtilities($param);
            $this->calculateMaterialAllocation($month);
            $this->calculateIndirectLabor($month);
            $this->calculatePrepaidExpenses($month);
            $this->calculateApportionedUtilities($param);
            $this->calculateDirectDepreciation();

            $this->calculateTotalCostSummary();

            // 3. 统一插入数据
            $this->saveAllData($month, $sysId);

            Db::commit();

            $this->logSuccess($month);

            return $this->buildSuccessResponse($month);

        } catch (\Throwable $t) {
            Db::rollback();

            // 直接记录错误，不通过 logError 方法
            try {
                error_log("成本核算失败: " . $t->getMessage() . " at " . $t->getFile() . ":" . $t->getLine());
                error_log("堆栈跟踪: " . $t->getTraceAsString());

            } catch (\Throwable $logError) {
                // 忽略日志记录错误
            }

            return [
                'success' => false,
                'message' => '成本核算失败: ' . $t->getMessage(),
                'error' => $t->getMessage(),
                'file' => $t->getFile(),
                'line' => $t->getLine()
            ];
        }
    }


    /**
     * 清空旧数据
     */
    protected function clearOldData(string $month): void
    {
        // 确保数据数组是有效的数组
        $this->monthlyCostDetails = [];
        $this->allocationFactors = [];

    }

    /**
     * 1. 计算直接人工
     */
    protected function calculateDirectLabor(array $param): void
    {
        try {
            $month = $param['month'];
            $sysId = $param['sys_id'] ?? '';
            $now = date('Y-m-d H:i:s');

            $list = Db::name('绩效工资汇总')
                ->alias('a')
                ->join('工单_工艺资料 b', 'a.sczl_gdbh = b.Gy0_gdbh and a.sczl_yjno = b.Gy0_yjno and a.sczl_gxh = b.Gy0_gxh')
                ->join('设备_基本资料 c', 'a.sczl_jtbh = c.设备编号', 'LEFT')
                ->join('工单_印件资料 d', 'a.sczl_gdbh = d.Yj_Gdbh and a.sczl_yjno = d.yj_Yjno')
                ->field($this->getDirectLaborFields())
                ->where('a.sys_ny', $month)
                ->group('a.sczl_gdbh,a.sczl_yjno,a.sczl_gxh,a.sczl_jtbh')
                ->select();

            // 转换为数组（如果返回的是对象）
            if (!is_array($list)) {
                $list = $list->toArray();
            }


            foreach ($list as $item) {
                // 确保 $item 是数组
                $itemArray = is_object($item) ? (array)$item : $item;
                if (!is_array($itemArray)) {

                    continue;
                }

                $this->monthlyCostDetails[] = $this->buildMonthlyCostDetail($itemArray, $month, $sysId, $now);
            }

        } catch (\Exception $e) {

            throw new Exception("直接人工计算失败: " . $e->getMessage());
        }
    }


    /**
     * 获取直接人工查询字段
     */
    protected function getDirectLaborFields(): string
    {
        return 'a.sczl_gdbh as 工单编号,a.sczl_yjno as 印件号,a.sczl_gxh as 工序号,
                sum(a.班组车头产量) as 班组车头产量,b.Gy0_gxmc as 工序名称,
                a.sczl_ms as 墨色数,c.使用部门,b.印刷方式,b.版距,b.工价系数,
                a.sczl_jtbh,d.yj_yjmc as 印件名称,sum(a.车头产量占用机时) as 占用机时,
                a.sys_rq as 年月,a.工序难度系数,sum(a.班组换算产量) as 班组换算产量,
                a.千件工价';
    }

    /**
     * 构建月度成本明细记录
     */
    protected function buildMonthlyCostDetail(array $data, string $month, string $sysId, string $now): array
    {
        $banju = $data['版距'] === '0.0' ? 1000 : $data['版距'];
        $moshushu = $this->calculateMoshushu($data);
        $chanliang = $this->calculateChanliang($data);
        $renGongFenTan = $this->calculateRenGongFenTan($chanliang, $data);

        return array_merge([
            '车间名称' => $data['使用部门'] ?? '',
            'sys_ny' => $month,
            'sczl_gdbh' => $data['工单编号'],
            '印件名称' => $data['印件名称'] ?? '',
            'sczl_yjno' => $data['印件号'],
            'sczl_gxh' => $data['工序号'],
            '工序名称' => $data['工序名称'] ?? '',
            'sczl_jtbh' => $data['sczl_jtbh'] ?? '',
            '卷张换算系数' => floatval($banju) / 1000,
            '占用机时' => floatval($data['占用机时']) ?? 0,
            '班组车头产量' => floatval($data['班组车头产量']) ?? 0,
            'sczl_ms' => floatval($moshushu),
            '工序难度系数' => floatval($data['工序难度系数']) ?? 1,
            '班组换算产量' => floatval($data['班组换算产量']) ?? 0,
            '千件工价' => floatval($data['千件工价']) ?? 0,
            '计件产量' => floatval($chanliang),
            '水电分摊因子' => floatval($data['占用机时']) ?? 0,
            '材料分摊因子' => floatval($chanliang),
            '人工分摊因子' => floatval($renGongFenTan),
            'Sys_id' => $sysId,
            'Sys_rq' => $now
        ], self::DEFAULT_FIELD_VALUES);
    }

    /**
     * 计算墨色数
     */
    protected function calculateMoshushu(array $data): float
    {
        if (strpos($data['工序名称'] ?? '', '切废') !== false) {
            return 0.2;
        }
        return $data['墨色数'] === '0.00' ? 1.0 : floatval($data['墨色数']);
    }

    /**
     * 计算产量
     */
    protected function calculateChanliang(array $data): float
    {
        return ($data['班组车头产量'] * $data['工序难度系数']) + $data['班组换算产量'];
    }

    /**
     * 计算人工分摊
     */
    protected function calculateRenGongFenTan(float $chanliang, array $data): float
    {
        return ($chanliang / 1000) * $data['千件工价'];
    }

    /**
     * 2. 计算直接水电
     */
    protected function calculateDirectUtilities(array $param): void
    {
        $month = $param['month'];

        if (empty($this->monthlyCostDetails)) {
            throw new Exception("请先执行直接人工计算");
        }

        $utilityData = $this->fetchDirectUtilities($month);
        if (empty($utilityData)) {

            return;
        }

        $machineUtilities = $this->calculateMachineUtilities($utilityData);
        $workOrderHours = $this->getMachineWorkHours();
        $machineTotalHours = $this->calculateMachineTotalHours($workOrderHours);

        $allocationResults = $this->allocateUtilitiesToWorkOrders(
            $machineUtilities,
            $workOrderHours,
            $machineTotalHours
        );

        $this->updateDirectUtilitiesToCostDetails($allocationResults);
    }

    /**
     * 获取直接水电数据
     */
    protected function fetchDirectUtilities(string $month): array
    {
        return Db::name('成本_各月水电气')
            ->where('Sys_ny', $month)
            ->where('费用类型', '直接')
            ->field('设备编号, 部门名称, 科目名称, 耗电量, 单位电价, 耗气量, 单位气价')
            ->select();
    }

    /**
     * 计算机台水电费用
     */
    protected function calculateMachineUtilities(array $utilityData): array
    {
        $machineUtilities = [];

        foreach ($utilityData as $item) {
            $machineCode = $item['设备编号'] ?? '';
            if (empty($machineCode)) {
                continue;
            }

            $electricityCost = $this->calculateElectricityCost($item);
            $gasCost = $this->calculateGasCost($item);
            $totalCost = $electricityCost + $gasCost;

            if (!isset($machineUtilities[$machineCode])) {
                $machineUtilities[$machineCode] = [
                    '机器编号' => $machineCode,
                    '部门名称' => $item['部门名称'] ?? '',
                    '总费用' => 0,
                    '电费' => 0,
                    '气费' => 0,
                ];
            }

            $machineUtilities[$machineCode]['总费用'] += $totalCost;
            $machineUtilities[$machineCode]['电费'] += $electricityCost;
            $machineUtilities[$machineCode]['气费'] += $gasCost;
        }

        return $machineUtilities;
    }

    /**
     * 计算电费
     */
    protected function calculateElectricityCost(array $item): float
    {
        return round(floatval($item['耗电量'] ?? 0) * floatval($item['单位电价'] ?? 0), 2);
    }

    /**
     * 计算气费
     */
    protected function calculateGasCost(array $item): float
    {
        return round(floatval($item['耗气量'] ?? 0) * floatval($item['单位气价'] ?? 0), 2);
    }

    /**
     * 获取机台工作小时数
     */
    protected function getMachineWorkHours(): array
    {
        $workHours = [];

        foreach ($this->monthlyCostDetails as $detail) {
            try {
                // 确保 $detail 是数组
                $detailArray = is_object($detail) ? (array)$detail : $detail;
                if (!is_array($detailArray)) {

                    continue;
                }

                $machineCode = $detailArray['sczl_jtbh'] ?? '';
                $hours = floatval($detailArray['占用机时'] ?? 0);

                if (!empty($machineCode) && $hours > 0) {
                    $workHours[] = [
                        'sczl_gdbh' => $detailArray['sczl_gdbh'] ?? '',
                        'sczl_yjno' => $detailArray['sczl_yjno'] ?? '',
                        'sczl_gxh' => $detailArray['sczl_gxh'] ?? '',
                        'sczl_jtbh' => $machineCode,
                        '占用机时' => $hours,
                        '车间名称' => $detailArray['车间名称'] ?? '',
                    ];
                }
            } catch (\Exception $e) {

                continue;
            }
        }


        return $workHours;
    }

    /**
     * 计算机台总小时数
     */
    protected function calculateMachineTotalHours(array $workOrderHours): array
    {
        $machineTotalHours = [];

        foreach ($workOrderHours as $workOrder) {
            $machineCode = $workOrder['sczl_jtbh'] ?? '';
            $hours = floatval($workOrder['占用机时'] ?? 0);

            if (!empty($machineCode) && $hours > 0) {
                $machineTotalHours[$machineCode] = ($machineTotalHours[$machineCode] ?? 0) + $hours;
            }
        }

        return $machineTotalHours;
    }

    /**
     * 分摊水电到工单
     */
    protected function allocateUtilitiesToWorkOrders(
        array $machineUtilities,
        array $workOrderHours,
        array $machineTotalHours
    ): array {
        $allocationResults = [];
        $processedCount = 0;
        $skippedCount = 0;

        foreach ($workOrderHours as $workOrder) {
            try {
                // 确保 $workOrder 是数组
                $orderArray = is_object($workOrder) ? (array)$workOrder : $workOrder;
                if (!is_array($orderArray)) {

                    $skippedCount++;
                    continue;
                }

                $machineCode = $orderArray['sczl_jtbh'] ?? '';
                $hours = floatval($orderArray['占用机时'] ?? 0);

                if (empty($machineCode)) {

                    $skippedCount++;
                    continue;
                }

                if (!isset($machineUtilities[$machineCode])) {

                    $skippedCount++;
                    continue;
                }

                if ($machineUtilities[$machineCode]['总费用'] <= 0) {

                    $skippedCount++;
                    continue;
                }

                if (!isset($machineTotalHours[$machineCode]) || $machineTotalHours[$machineCode] <= 0) {

                    $skippedCount++;
                    continue;
                }

                $allocationRatio = $hours / $machineTotalHours[$machineCode];
                $allocatedAmount = round($machineUtilities[$machineCode]['总费用'] * $allocationRatio, 2);

                $uniqueKey = $this->getWorkOrderUniqueKey($orderArray);

                $allocationResults[$uniqueKey] = [
                    'unique_key' => $uniqueKey,
                    'sczl_gdbh' => $orderArray['sczl_gdbh'] ?? '',
                    'sczl_yjno' => $orderArray['sczl_yjno'] ?? '',
                    'sczl_gxh' => $orderArray['sczl_gxh'] ?? '',
                    'sczl_jtbh' => $machineCode,
                    '占用机时' => $hours,
                    '分摊比例' => $allocationRatio,
                    '分摊金额' => $allocatedAmount,
                    '机台总费用' => $machineUtilities[$machineCode]['总费用'],
                    '机台总工时' => $machineTotalHours[$machineCode],
                ];

                $processedCount++;

            } catch (\Exception $e) {

                $skippedCount++;
                continue;
            }
        }



        return $allocationResults;
    }


    /**
     * 获取工单唯一键
     */
    protected function getWorkOrderUniqueKey($workOrder): string
    {
        // 记录传入参数的类型和内容（用于调试）
        $type = gettype($workOrder);
        // 如果是对象，转换为数组
        if (is_object($workOrder)) {
            $workOrder = (array)$workOrder;
        }

        // 安全地获取所有可能键名
        $gdbh = '';
        $yjno = '';
        $gxh = '';
        $jtbh = '';

        // 尝试各种可能的键名
        if (isset($workOrder['sczl_gdbh'])) {
            $gdbh = $workOrder['sczl_gdbh'];
        } elseif (isset($workOrder['工单编号'])) {
            $gdbh = $workOrder['工单编号'];
        }

        if (isset($workOrder['sczl_yjno'])) {
            $yjno = $workOrder['sczl_yjno'];
        } elseif (isset($workOrder['印件号'])) {
            $yjno = $workOrder['印件号'];
        }

        if (isset($workOrder['sczl_gxh'])) {
            $gxh = $workOrder['sczl_gxh'];
        } elseif (isset($workOrder['工序号'])) {
            $gxh = $workOrder['工序号'];
        }

        if (isset($workOrder['sczl_jtbh'])) {
            $jtbh = $workOrder['sczl_jtbh'];
        } elseif (isset($workOrder['机器编号'])) {
            $jtbh = $workOrder['机器编号'];
        }



        $key = sprintf('%s-%s-%s-%s', $gdbh, $yjno, $gxh, $jtbh);

        return $key;
    }

    /**
     * 更新直接水电到成本明细
     */
    protected function updateDirectUtilitiesToCostDetails(array $allocationResults): void
    {
        if (empty($allocationResults) || empty($this->monthlyCostDetails)) {

            return;
        }

        $updatedCount = 0;
        $totalAllocatedAmount = 0;
        $notFoundCount = 0;

        foreach ($this->monthlyCostDetails as &$costDetail) {
            try {
                // 确保 $costDetail 是数组
                $detailArray = is_object($costDetail) ? (array)$costDetail : $costDetail;

                $uniqueKey = $this->getWorkOrderUniqueKey($detailArray);

                if (isset($allocationResults[$uniqueKey])) {
                    $allocatedAmount = $allocationResults[$uniqueKey]['分摊金额'] ?? 0;
                    $costDetail['直接水电'] = $allocatedAmount;
                    $totalAllocatedAmount += $allocatedAmount;
                    $updatedCount++;
                } else {
                    $notFoundCount++;
                }
            } catch (\Exception $e) {

                continue;
            }
        }


    }

    /**
     * 3. 材料出库分摊（材料出库单列表）
     */
    protected function calculateMaterialAllocation(string $month): void
    {
        if (empty($this->monthlyCostDetails)) {
            return;
        }

        $datePrefix = substr($month, 0, 4) . '-' . substr($month, 4, 2);
        $rows = $this->fetchMaterialOutboundRows($datePrefix);
        if (empty($rows)) {
            return;
        }

        $directRows = [];
        $plateRows = [];
        $repairRows = [];
        $otherRows = [];

        foreach ($rows as $row) {
            $row = is_object($row) ? (array)$row : $row;
            $amount = $this->getMaterialLineAmount($row);
            if ($amount <= 0) {
                continue;
            }

            if (!$this->isBlankWorkOrderNo($row['表体生产订单号'] ?? null)) {
                $directRows[] = $row;
                continue;
            }

            if ($this->isRepairOutboundRow($row)) {
                $repairRows[] = $row;
                continue;
            }

            if ($this->isPlateOutboundRow($row)) {
                $plateRows[] = $row;
                continue;
            }

            $otherRows[] = $row;
        }

        foreach ($directRows as $row) {
            $this->allocateDirectMaterialRow($row);
        }

        foreach ($plateRows as $row) {
            $this->allocatePlateMaterialRow($row);
        }

        foreach ($repairRows as $row) {
            $this->allocateRepairMaterialRow($row);
        }

        $this->allocateOtherMaterialRows($otherRows);
    }

    /**
     * 当月印刷成本中心材料出库
     */
    protected function fetchMaterialOutboundRows(string $datePrefix): array
    {
        $list = Db::name('材料出库单列表')
            ->where('出库日期', 'like', $datePrefix . '%')
            ->where('部门', '印刷成本中心')
            ->select();

        if (!is_array($list)) {
            return $list ? $list->toArray() : [];
        }

        return $list;
    }

    protected function getMaterialLineAmount(array $row): float
    {
        if (isset($row['金额']) && floatval($row['金额']) != 0) {
            return round(floatval($row['金额']), 2);
        }

        return round(floatval($row['数量'] ?? 0) * floatval($row['单价'] ?? 0), 2);
    }

    protected function isBlankWorkOrderNo($orderNo): bool
    {
        return $orderNo === null || trim((string)$orderNo) === '';
    }

    protected function getDetailChroma(array $detail): float
    {
        return floatval($detail['班组车头产量']) * floatval($detail['sczl_ms']);
    }

    /**
     * 有工单号：计入直接材料（数量×单价，优先取金额）
     */
    protected function allocateDirectMaterialRow(array $row): void
    {
        $gdbh = trim((string)($row['表体生产订单号'] ?? ''));
        $amount = $this->getMaterialLineAmount($row);
        if ($gdbh === '' || $amount <= 0) {
            return;
        }

        $this->addMaterialAmountByChromaRatio('直接材料', $amount, function ($detail) use ($gdbh) {
            return trim((string)($detail['sczl_gdbh'] ?? '')) === $gdbh;
        });
        $this->syncAssessedDirectMaterial();
    }

    /**
     * 板材（印版库）：仅首次领用时绑定到对应工单直接材料
     */
    protected function allocatePlateMaterialRow(array $row): void
    {
        $stockCode = $this->getOutboundStockCode($row);
        if ($stockCode === '') {
            return;
        }

        $batch = $this->getOutboundBatchNo($row);
        if ($batch === '') {
            $batch = Db::name('产品_印版库')
                ->where('存货编码', $stockCode)
                ->order('UniqID asc')
                ->value('供方批号');
            $batch = trim((string)$batch);
        }

        if ($batch === '') {
            return;
        }

        $existsInStock = Db::name('产品_印版库')
            ->where('存货编码', $stockCode)
            ->where('供方批号', $batch)
            ->count();
        if (!$existsInStock) {
            return;
        }

        $usageCount = Db::name('工单_印版领用记录')
            ->where('Yb_存货编码', $stockCode)
            ->where('Yb_供方批号', $batch)
            ->count();
        if ($usageCount !== 1) {
            return;
        }

        $usage = Db::name('工单_印版领用记录')
            ->where('Yb_存货编码', $stockCode)
            ->where('Yb_供方批号', $batch)
            ->order('Yb_领用日期 asc, UniqID asc')
            ->find();
        if (empty($usage)) {
            return;
        }

        $gdbh = trim((string)($usage['Yb_工单编号'] ?? ''));
        $yjno = trim((string)($usage['Yb_印件号'] ?? ''));
        $machine = trim((string)($usage['Yb_领用机台'] ?? ''));
        $amount = $this->getMaterialLineAmount($row);
        if ($gdbh === '' || $amount <= 0) {
            return;
        }

        $this->addMaterialAmountByChromaRatio('直接材料', $amount, function ($detail) use ($gdbh, $yjno, $machine) {
            if (trim((string)($detail['sczl_gdbh'] ?? '')) !== $gdbh) {
                return false;
            }
            if ($yjno !== '' && trim((string)($detail['sczl_yjno'] ?? '')) !== $yjno) {
                return false;
            }
            if ($machine !== '' && trim((string)($detail['sczl_jtbh'] ?? '')) !== $machine) {
                return false;
            }
            return true;
        });
        $this->syncAssessedDirectMaterial();
    }

    /**
     * 修理领用：有机台则摊到机台工单，否则摊到车间各机台
     */
    protected function allocateRepairMaterialRow(array $row): void
    {
        $amount = $this->getMaterialLineAmount($row);
        if ($amount <= 0) {
            return;
        }

        $machine = $this->getOutboundMachineCode($row);
        if ($machine !== '') {
            $this->addMaterialAmountByChromaRatio('分摊材料', $amount, function ($detail) use ($machine) {
                return trim((string)($detail['sczl_jtbh'] ?? '')) === $machine;
            });
            return;
        }

        $workshop = $this->resolveOutboundWorkshop($row);
        if ($workshop === '') {
            return;
        }

        $machineHours = $this->getWorkshopMachineHours($workshop);
        if (empty($machineHours)) {
            return;
        }

        $totalHours = array_sum($machineHours);
        if ($totalHours <= 0) {
            return;
        }

        foreach ($machineHours as $machineCode => $hours) {
            if ($hours <= 0) {
                continue;
            }
            $machineAmount = round($amount * ($hours / $totalHours), 2);
            $this->addMaterialAmountByChromaRatio('分摊材料', $machineAmount, function ($detail) use ($machineCode) {
                return trim((string)($detail['sczl_jtbh'] ?? '')) === $machineCode;
            });
        }
    }

    /**
     * 其他无工单材料：按车间内 工序色度/车间总色度 分摊
     */
    protected function allocateOtherMaterialRows(array $rows): void
    {
        if (empty($rows)) {
            return;
        }

        $workshopTotals = [];
        foreach ($rows as $row) {
            $amount = $this->getMaterialLineAmount($row);
            if ($amount <= 0) {
                continue;
            }
            $workshop = $this->resolveOutboundWorkshop($row);
            if ($workshop === '') {
                $workshop = '__ALL__';
            }
            $workshopTotals[$workshop] = ($workshopTotals[$workshop] ?? 0) + $amount;
        }

        foreach ($workshopTotals as $workshop => $totalAmount) {
            if ($totalAmount <= 0) {
                continue;
            }
            if ($workshop === '__ALL__') {
                $this->addMaterialAmountByChromaRatio('分摊材料', $totalAmount, function () {
                    return true;
                });
                continue;
            }

            $this->addMaterialAmountByChromaRatio('分摊材料', $totalAmount, function ($detail) use ($workshop) {
                return trim((string)($detail['车间名称'] ?? '')) === $workshop;
            });
        }
    }

    protected function addMaterialAmountByChromaRatio(string $targetField, float $amount, callable $detailFilter): void
    {
        if ($amount <= 0) {
            return;
        }

        $weighted = [];
        $totalChroma = 0;

        foreach ($this->monthlyCostDetails as $index => $detail) {
            if (!$detailFilter($detail)) {
                continue;
            }
            $chroma = $this->getDetailChroma($detail);
            if ($chroma <= 0) {
                continue;
            }
            $weighted[] = ['index' => $index, 'chroma' => $chroma];
            $totalChroma += $chroma;
        }

        if ($totalChroma <= 0) {
            return;
        }

        foreach ($weighted as $item) {
            $share = round($amount * ($item['chroma'] / $totalChroma), 2);
            $this->monthlyCostDetails[$item['index']][$targetField] =
                floatval($this->monthlyCostDetails[$item['index']][$targetField] ?? 0) + $share;
        }
    }

    protected function syncAssessedDirectMaterial(): void
    {
        foreach ($this->monthlyCostDetails as &$detail) {
            $detail['考核直接材料'] = floatval($detail['直接材料'] ?? 0);
        }
        unset($detail);
    }

    protected function isRepairOutboundRow(array $row): bool
    {
        $fields = ['出库类别', '收发类别', '业务类型', '交易类别', '领料类型'];
        foreach ($fields as $field) {
            if (empty($row[$field])) {
                continue;
            }
            if (mb_strpos((string)$row[$field], '修理领用') !== false) {
                return true;
            }
        }

        return false;
    }

    protected function isPlateOutboundRow(array $row): bool
    {
        $stockCode = $this->getOutboundStockCode($row);
        if ($stockCode === '') {
            return false;
        }

        $batch = $this->getOutboundBatchNo($row);
        $query = Db::name('产品_印版库')->where('存货编码', $stockCode);
        if ($batch !== '') {
            $query->where('供方批号', $batch);
        }

        return $query->count() > 0;
    }

    protected function getOutboundStockCode(array $row): string
    {
        foreach (['存货编码', '物料编码', '表体存货编码'] as $field) {
            if (!empty($row[$field])) {
                return trim((string)$row[$field]);
            }
        }

        return '';
    }

    protected function getOutboundBatchNo(array $row): string
    {
        foreach (['供方批号', '批号', '供应商批号', '表体批号'] as $field) {
            if (!empty($row[$field])) {
                return trim((string)$row[$field]);
            }
        }

        return '';
    }

    protected function getOutboundMachineCode(array $row): string
    {
        foreach (['机台编号', '设备编号', '表体机台', '领用机台', 'st_jtbh'] as $field) {
            if (!empty($row[$field])) {
                return trim((string)$row[$field]);
            }
        }

        return '';
    }

    protected function resolveOutboundWorkshop(array $row): string
    {
        foreach (['车间', '车间名称', '领用车间', '使用部门'] as $field) {
            if (!empty($row[$field])) {
                $name = trim((string)$row[$field]);
                if ($name !== '' && $name !== '印刷成本中心') {
                    return $name;
                }
            }
        }

        $machine = $this->getOutboundMachineCode($row);
        if ($machine !== '') {
            $dept = Db::name('设备_基本资料')
                ->where('设备编号', $machine)
                ->value('使用部门');
            return trim((string)$dept);
        }

        return '';
    }

    /**
     * @return array<string, float> 机台 => 占用机时合计
     */
    protected function getWorkshopMachineHours(string $workshop): array
    {
        $hours = [];

        foreach ($this->monthlyCostDetails as $detail) {
            if (trim((string)($detail['车间名称'] ?? '')) !== $workshop) {
                continue;
            }
            $machine = trim((string)($detail['sczl_jtbh'] ?? ''));
            if ($machine === '') {
                continue;
            }
            $hour = floatval($detail['占用机时'] ?? 0);
            if ($hour <= 0) {
                continue;
            }
            $hours[$machine] = ($hours[$machine] ?? 0) + $hour;
        }

        return $hours;
    }

    /**
     * 4. 计算间接人工分摊
     */
    protected function calculateIndirectLabor(string $month): void
    {
        $workshopLaborTotal = $this->getWorkshopLaborTotalFromPerformancePayroll($month);
        if ($workshopLaborTotal > 0) {
            $this->allocateMonthlyTotalByWorkshopAndChroma(
                $workshopLaborTotal,
                '车间人工'
            );
        }

        $monthWage = $this->getMonthlyWage($month);
        if (!empty($monthWage)) {
            $this->allocateMonthlyTotalByWorkshopAndChroma(
                floatval($monthWage['管理人员工资'] ?? 0),
                '部门人工附加'
            );
        }
    }

    /**
     * 直接折旧：工单通电工时（占用机时）× 设备 A_小时折旧额
     */
    protected function calculateDirectDepreciation(): void
    {
        if (empty($this->monthlyCostDetails)) {
            return;
        }

        $machineCodes = [];
        foreach ($this->monthlyCostDetails as $detail) {
            $code = trim((string)($detail['sczl_jtbh'] ?? ''));
            if ($code !== '') {
                $machineCodes[$code] = true;
            }
        }

        if (empty($machineCodes)) {
            return;
        }

        $depreciationRates = Db::name('设备_基本资料')
            ->where('设备编号', 'in', array_keys($machineCodes))
            ->column('A_小时折旧额', '设备编号');

        foreach ($this->monthlyCostDetails as &$detail) {
            $machine = trim((string)($detail['sczl_jtbh'] ?? ''));
            $hourlyRate = floatval($depreciationRates[$machine] ?? 0);
            $powerHours = floatval($detail['占用机时'] ?? 0);

            $detail['A_小时折旧额'] = round($hourlyRate, 4);
            $detail['直接折旧'] = round($powerHours * $hourlyRate, 2);
        }
        unset($detail);
    }

    /**
     * 6. 租金、待摊折旧、其他待摊（成本_各月其他费用）
     */
    protected function calculatePrepaidExpenses(string $month): void
    {
        if (empty($this->monthlyCostDetails)) {
            return;
        }

        $expenses = Db::name('成本_各月其他费用')
            ->where('sys_ny', $month)
            ->field('场地租金,待摊折旧,其他')
            ->find();

        if (empty($expenses)) {
            return;
        }

        $this->allocateMonthlyTotalByWorkshopAndChroma(
            floatval($expenses['场地租金'] ?? 0),
            '场地租金'
        );
        $this->allocateMonthlyTotalByWorkshopAndChroma(
            floatval($expenses['待摊折旧'] ?? 0),
            '分摊折旧'
        );
        $this->allocateMonthlyTotalByWorkshopAndChroma(
            floatval($expenses['其他'] ?? 0),
            '分摊其他'
        );
    }

    /**
     * 按车间直接人工占比、再按车间内色度数占比分摊月度总额
     */
    protected function allocateMonthlyTotalByWorkshopAndChroma(float $totalAmount, string $targetField): void
    {
        if ($totalAmount <= 0) {
            return;
        }

        $wageRatio = $this->getWageRatio();
        if (empty($wageRatio)) {
            return;
        }

        foreach ($wageRatio as $workshopName => $ratio) {
            $chromaData = $this->getChromaDataForWorkshop($workshopName);
            if (empty($chromaData['total'])) {
                continue;
            }

            $workshopAmount = $ratio * $totalAmount;
            $this->allocateWageToDetails($workshopName, $workshopAmount, $chromaData, $targetField);
        }
    }

    /**
     * 获取工资比例
     */
    protected function getWageRatio(): array
    {
        $workshopTotals = [];

        foreach ($this->monthlyCostDetails as $detail) {
            $workshop = $detail['车间名称'];
            $amount = floatval($detail['人工分摊因子']);
            $workshopTotals[$workshop] = ($workshopTotals[$workshop] ?? 0) + $amount;
        }

        $total = array_sum($workshopTotals);
        if ($total <= 0) {
            return [];
        }

        $ratios = [];
        foreach ($workshopTotals as $workshop => $workshopTotal) {
            $ratios[$workshop] = round($workshopTotal / $total, 4);
        }

        return $ratios;
    }

    /**
     * 获取月度工资数据
     */
    protected function getMonthlyWage(string $month): array
    {
        return Db::name('成本_各月其他费用')
            ->where('sys_ny', $month)
            ->field('部门人员工资,管理人员工资')
            ->find() ?: [];
    }

    /**
     * 车间人工总额：绩效工资汇总表计件工资 + 加班工资（与成本人工维护口径一致）
     */
    protected function getWorkshopLaborTotalFromPerformancePayroll(string $month): float
    {
        $row = Db::name('绩效工资汇总')
            ->where('sys_ny', $month)
            ->field('SUM(个人计件工资) AS piece_wage, SUM(个人加班工资) AS overtime_wage')
            ->find();

        if (empty($row)) {
            return 0.0;
        }

        return floatval($row['piece_wage'] ?? 0) + floatval($row['overtime_wage'] ?? 0);
    }

    /**
     * 获取车间色度数数据
     */
    protected function getChromaDataForWorkshop(string $workshop): array
    {
        $data = ['total' => 0, 'list' => []];

        foreach ($this->monthlyCostDetails as $detail) {
            if ($detail['车间名称'] === $workshop) {
                $chroma = floatval($detail['班组车头产量']) * floatval($detail['sczl_ms']);
                $data['total'] += $chroma;
                $data['list'][] = [
                    'sczl_gdbh' => $detail['sczl_gdbh'],
                    'sczl_yjno' => $detail['sczl_yjno'],
                    'sczl_gxh' => $detail['sczl_gxh'],
                    'sczl_jtbh' => $detail['sczl_jtbh'],
                    'chroma' => $chroma
                ];
            }
        }

        return $data;
    }

    /**
     * 分配工资到明细记录
     */
    protected function allocateWageToDetails(
        string $workshop,
        float $workshopAmount,
        array $chromaData,
        string $fieldName
    ): void {
        foreach ($this->monthlyCostDetails as &$detail) {
            if ($detail['车间名称'] === $workshop) {
                $chroma = floatval($detail['班组车头产量']) * floatval($detail['sczl_ms']);
                $amount = round($chroma / $chromaData['total'] * $workshopAmount, 2);
                $detail[$fieldName] += $amount;
            }
        }
    }

    /**
     * 5. 计算分摊水电
     */
    protected function calculateApportionedUtilities(array $param): void
    {
        try {
            $month = $param['month'];
            $sysId = $param['sys_id'] ?? '';

            $utilityData = $this->fetchApportionedUtilities($month);
            if (empty($utilityData)) {

                return;
            }

            // 记录原始科目名称用于调试
            $originalSubjects = array_unique(array_column($utilityData, '科目名称'));


            $machineAllocations = $this->calculateMachineAllocations($utilityData);

            if (!empty($machineAllocations)) {
                $this->generateAllocationFactors($machineAllocations, $month, $sysId);
                $this->allocateApportionedUtilities($machineAllocations);
            }
        } catch (\Exception $e) {

            throw new Exception("分摊水电计算失败: " . $e->getMessage());
        }
    }

    /**
     * 获取分摊水电数据
     */
    protected function fetchApportionedUtilities(string $month): array
    {
        return Db::name('成本_各月水电气')
            ->where('Sys_ny', $month)
            ->whereLike('费用类型', '%分摊%')
            ->select();
    }

    /**
     * 计算机台分摊金额
     */
    protected function calculateMachineAllocations(array $utilityData): array
    {
        $allocations = [];
        $machineHours = $this->getMachineHours();

        foreach ($utilityData as $item) {
            try {
                $subject = $this->simplifySubjectName($item['科目名称']);
                $amount = $this->calculateUtilityAmount($item);

                if ($amount <= 0) {
                    continue;
                }

                $this->allocateBySubject($allocations, $subject, $amount, $machineHours);
            } catch (\Exception $e) {

                continue;
            }
        }

        return $allocations;
    }


    /**
     * 获取机台运行时间
     */
    protected function getMachineHours(): array
    {
        $hours = [];

        foreach ($this->monthlyCostDetails as $detail) {
            $machine = $detail['sczl_jtbh'];
            $hour = floatval($detail['占用机时']);

            if (!empty($machine)) {
                $hours[$machine] = ($hours[$machine] ?? 0) + $hour;
            }
        }

        return $hours;
    }

    /**
     * 按科目分摊
     */
    protected function allocateBySubject(
        array &$allocations,
        string $subject,
        float $amount,
        array $machineHours
    ): void {
        try {
            if ($subject === '待分摊总额') {
                $this->allocateByFloor($allocations, $amount, $machineHours);
            } elseif (in_array($subject, ['锅炉', '热水锅炉'])) {
                $this->allocateToRollCoater($allocations, $subject, $amount, $machineHours);
            } else {
                $this->allocateGlobally($allocations, $subject, $amount, $machineHours);
            }
        } catch (\Exception $e) {

        }
    }

    /**
     * 按楼层分摊
     */
    protected function allocateByFloor(array &$allocations, float $amount, array $machineHours): void
    {
        $floorData = $this->groupMachinesByFloor($machineHours);

        if ($floorData['totalHours'] <= 0) {
            return;
        }

        foreach ($floorData['floors'] as $floor => $data) {
            if ($data['hours'] <= 0) {
                continue;
            }

            $floorAmount = $amount * ($data['hours'] / $floorData['totalHours']);
            $this->allocateToFloorMachines($allocations, $floorAmount, $data['machines'], $machineHours);
        }
    }

    /**
     * 按楼层分组机台
     */
    protected function groupMachinesByFloor(array $machineHours): array
    {
        $floors = ['1' => ['hours' => 0, 'machines' => []], '2' => ['hours' => 0, 'machines' => []]];
        $totalHours = 0;

        foreach ($machineHours as $machine => $hours) {
            $floor = $this->getFloorByMachine($machine);
            if ($floor && isset($floors[$floor])) {
                $floors[$floor]['hours'] += $hours;
                $floors[$floor]['machines'][] = $machine;
                $totalHours += $hours;
            }
        }

        return ['floors' => $floors, 'totalHours' => $totalHours];
    }

    /**
     * 分摊到楼层机台
     */
    protected function allocateToFloorMachines(
        array &$allocations,
        float $floorAmount,
        array $machines,
        array $machineHours
    ): void {
        $floorHours = 0;
        foreach ($machines as $machine) {
            $floorHours += $machineHours[$machine];
        }

        if ($floorHours <= 0) {
            return;
        }

        foreach ($machines as $machine) {
            $machineHoursAmount = $machineHours[$machine];
            if ($machineHoursAmount <= 0) {
                continue;
            }

            $allocations[$machine]['待分摊总额'] =
                ($allocations[$machine]['待分摊总额'] ?? 0) +
                round($floorAmount * ($machineHoursAmount / $floorHours), 2);
        }
    }

    /**
     * 只分摊到卷凹机组
     */
    protected function allocateToRollCoater(
        array &$allocations,
        string $subject,
        float $amount,
        array $machineHours
    ): void {
        $rollCoaterMachines = $this->filterRollCoaterMachines(array_keys($machineHours));
        $totalHours = 0;

        foreach ($rollCoaterMachines as $machine) {
            $totalHours += $machineHours[$machine];
        }

        if ($totalHours <= 0) {
            return;
        }

        foreach ($rollCoaterMachines as $machine) {
            $machineHoursAmount = $machineHours[$machine];
            if ($machineHoursAmount <= 0) {
                continue;
            }

            $allocations[$machine][$subject] =
                ($allocations[$machine][$subject] ?? 0) +
                round($amount * ($machineHoursAmount / $totalHours), 2);
        }
    }

    /**
     * 全局分摊
     */
    protected function allocateGlobally(
        array &$allocations,
        string $subject,
        float $amount,
        array $machineHours
    ): void {
        $totalHours = array_sum($machineHours);
        if ($totalHours <= 0) {

            return;
        }

        foreach ($machineHours as $machine => $hours) {
            try {
                // 确保 $machine 是有效的字符串键名
                if (!is_string($machine) && !is_numeric($machine)) {

                    continue;
                }

                $machine = (string)$machine;

                if ($hours <= 0) {
                    continue;
                }

                if (!isset($allocations[$machine])) {
                    $allocations[$machine] = [];
                }

                $machineAmount = round($amount * ($hours / $totalHours), 2);
                $allocations[$machine][$subject] =
                    ($allocations[$machine][$subject] ?? 0) + $machineAmount;

            } catch (\Exception $e) {

                continue;
            }
        }
    }


    /**
     * 根据机台获取楼层
     */
    protected function getFloorByMachine(string $machine): ?string
    {
        $group = Db::name('设备_基本资料')
            ->where('设备编号', $machine)
            ->value('设备编组');

        if (!$group) {
            return null;
        }

        foreach (self::FLOOR_GROUP_MAP as $floor => $groupNames) {
            foreach ($groupNames as $groupName) {
                if (strpos($group, $groupName) !== false) {
                    return $floor;
                }
            }
        }

        return null;
    }

    /**
     * 筛选卷凹机组的机台
     */
    protected function filterRollCoaterMachines(array $machines): array
    {
        $rollCoater = [];

        foreach ($machines as $machine) {
            $group = Db::name('设备_基本资料')
                ->where('设备编号', $machine)
                ->value('设备编组');

            if ($group && strpos($group, '03、卷凹机组') !== false) {
                $rollCoater[] = $machine;
            }
        }

        return $rollCoater;
    }

    /**
     * 简化科目名称
     */
    protected function simplifySubjectName(string $subject): string
    {
        // 先尝试完全匹配
        $subject = trim($subject);

        foreach (self::SUBJECT_TO_FIELD_MAP as $keyword => $mappedField) {
            if ($subject === $keyword) {
                return $mappedField;
            }
        }

        // 尝试部分匹配
        foreach (self::SUBJECT_TO_FIELD_MAP as $keyword => $mappedField) {
            if (strpos($subject, $keyword) !== false) {

                return $mappedField;
            }
        }

       
        return '分摊水电';
    }

    /**
     * 计算水电金额
     */
    protected function calculateUtilityAmount(array $item): float
    {
        $electricity = $this->calculateElectricityCost($item);
        $gas = $this->calculateGasCost($item);
        return $electricity + $gas;
    }

    /**
     * 生成分摊系数记录
     */
    protected function generateAllocationFactors(array $allocations, string $month, string $sysId): void
    {
        $now = date('Y-m-d H:i:s');

        foreach ($allocations as $machine => $subjects) {
            if (!is_string($machine) && !is_numeric($machine)) {

                continue;
            }

            foreach ($subjects as $subject => $amount) {
                if (!is_string($subject)) {

                    continue;
                }

                // 使用简化后的科目名称
                $simplifiedSubject = $this->simplifySubjectName($subject);

                $this->allocationFactors[] = [
                    'Sys_ny' => $month,
                    '科目名称' => $simplifiedSubject,  // 原始科目名称
                    '设备编号' => (string)$machine,
                    '分摊系数' => 1,
                    '分摊金额' => floatval($amount),
                    'Sys_id' => $sysId,
                    'Sys_rq' => $now,
                ];
            }
        }
    }
    /**
     * 分配分摊水电
     */
    protected function allocateApportionedUtilities(array $machineAllocations): void
    {
        $machineRates = $this->calculateMachineRates($machineAllocations);

        foreach ($this->monthlyCostDetails as &$detail) {
            $machine = $detail['sczl_jtbh'];
            $hours = floatval($detail['占用机时']);

            if ($hours <= 0 || !isset($machineRates[$machine])) {
                continue;
            }

            // 直接水电费（保持不变）
            $detail['直接水电'] = round($hours * 0.69, 2);

            // 分摊水电费 - 使用映射后的字段名
            foreach ($machineRates[$machine] as $subject => $rate) {
                $field = $this->getUtilityFieldName($subject);
                if (!isset($detail[$field])) {

                    continue;
                }
                $detail[$field] = round($hours * $rate, 2);
            }
        }
    }
    /**
     * 计算机台每机时费用
     */
    protected function calculateMachineRates(array $allocations): array
    {
        $rates = [];
        $machineHours = $this->getMachineHours();

        foreach ($allocations as $machine => $subjects) {
            $totalHours = $machineHours[$machine] ?? 0;

            if ($totalHours <= 0) {
                continue;
            }

            $rates[$machine] = [];
            foreach ($subjects as $subject => $amount) {
                $rates[$machine][$subject] = round($amount / $totalHours, 4);
            }
        }

        return $rates;
    }

    /**
     * 获取水电字段名
     */
    protected function getUtilityFieldName(string $subject): string
    {
        // 使用映射表
        if (isset(self::SUBJECT_TO_FIELD_MAP[$subject])) {
            return self::SUBJECT_TO_FIELD_MAP[$subject];
        }

        // 尝试部分匹配
        foreach (self::SUBJECT_TO_FIELD_MAP as $keyword => $mappedField) {
            if (strpos($subject, $keyword) !== false) {
                return $mappedField;
            }
        }

        // 默认映射到 '分摊水电'

        return '分摊水电';
    }

    /**
     * 汇总每条工序明细的成本合计
     */
    protected function calculateTotalCostSummary(): void
    {
        foreach ($this->monthlyCostDetails as &$detail) {
            $total = 0.0;
            foreach (self::COST_TOTAL_SUM_FIELDS as $field) {
                $total += floatval($detail[$field] ?? 0);
            }
            $detail['成本合计'] = round($total, 2);
        }
        unset($detail);
    }

    /**
     * 统一保存所有数据
     */
    protected function saveAllData(string $month, string $sysId): void
    {
        // 1. 删除旧数据
        $this->deleteOldData($month);

        // 2. 插入前检查数据结构
        $this->validateDataStructure();

        // 3. 插入新数据
        $this->insertAllData();
    }

    /**
     * 删除旧数据
     */
    protected function deleteOldData(string $month): void
    {
        Db::name('成本v23_月度成本明细')->where('sys_ny', $month)->delete();
        Db::name('成本_各月分摊系数')->where('Sys_ny', $month)->delete();
    }

    /**
     * 验证数据结构
     */
    protected function validateDataStructure(): void
    {
        try {
            if (!is_array($this->monthlyCostDetails)) {
                $this->monthlyCostDetails = [];
                return;
            }

            if (empty($this->monthlyCostDetails)) {

                return;
            }

            $tableName = '成本v23_月度成本明细';

            $columns = Db::query("DESCRIBE `{$tableName}`");
            if (empty($columns)) {
                return;
            }

            $columnNames = array_column($columns, 'Field');


            // 验证并修复每条记录
            foreach ($this->monthlyCostDetails as $index => &$row) {
                // 确保行是数组
                if (!is_array($row)) {
                    $row = [];
                    continue;
                }

                // 检查字段数是否匹配
                $rowCount = count($row);
                $columnCount = count($columnNames);

                if ($rowCount !== $columnCount) {

                    $this->fixRowData($row, $columnNames, $index);
                }

                // 确保所有键名都是字符串
                foreach ($row as $key => $value) {
                    if (!is_string($key) && !is_int($key)) {

                        // 移除非法键名
                        unset($row[$key]);
                        // 如果有值，尝试保存
                        if ($value !== null) {
                            $row['invalid_key_' . $index] = $value;
                        }
                    }
                }
            }

        } catch (\Throwable $t) {

            // 不抛出异常，继续执行
        }
    }


    /**
     * 修复行数据
     */
    protected function fixRowData(array &$row, array $columnNames, int $index): void
    {
        $fixedRow = [];

        foreach ($columnNames as $column) {
            // 确保列名是字符串
            $column = (string)$column;

            // 获取值，如果不存在则设置默认值
            if (array_key_exists($column, $row)) {
                $value = $row[$column];
            } else {
                // 根据列名设置默认值
                if (in_array($column, ['直接水电', '分摊材料', '直接材料', '考核直接材料', '车间人工', '部门人工附加', '分摊水电',
                    '废气处理', '锅炉', '空压机', '热水锅炉', '真空鼓风机', '中央空调', '分摊其他',
                    '分摊折旧', '场地租金', '直接折旧', 'A_小时折旧额', '成本合计'])) {
                    $value = 0;
                } else {
                    $value = null;
                }
            }

            $fixedRow[$column] = $value;
        }

        $this->monthlyCostDetails[$index] = $fixedRow;
    }


    /**
     * 插入所有数据
     */
    protected function insertAllData(): void
    {
        $this->insertMonthlyCostDetails();
        $this->insertAllocationFactors();
    }

    /**
     * 插入月度成本明细
     */
    protected function insertMonthlyCostDetails(): void
    {
        if (empty($this->monthlyCostDetails)) {
            return;
        }

        $total = count($this->monthlyCostDetails);

        for ($i = 0; $i < $total; $i += self::BATCH_SIZE) {
            $batch = array_slice($this->monthlyCostDetails, $i, self::BATCH_SIZE);
            $this->insertBatch($batch, '成本v23_月度成本明细', $i);
        }
    }

    /**
     * 插入批次数据
     */
    protected function insertBatch(array $batch, string $tableName, int $startIndex): void
    {
        if (empty($batch)) {

            return;
        }

        $firstRow = reset($batch);
        $fields = array_keys($firstRow);

        // 验证字段名不包含特殊字符
        foreach ($fields as $field) {
            if (preg_match('/[#@$%^&*()+\-=\[\]{}|;:"<>,.?\/]/', $field)) {

                throw new Exception("字段名 '{$field}' 包含非法字符");
            }
        }

        $fieldStr = '`' . implode('`,`', $fields) . '`';

        $values = [];
        foreach ($batch as $rowIndex => $row) {
            $rowValues = [];
            foreach ($fields as $field) {
                $value = $row[$field] ?? null;
                if (is_numeric($value)) {
                    $rowValues[] = $value;
                } elseif (is_null($value)) {
                    $rowValues[] = 'NULL';
                } else {
                    $rowValues[] = "'" . addslashes((string)$value) . "'";
                }
            }
            $values[] = '(' . implode(',', $rowValues) . ')';


        }

        $sql = "INSERT INTO `{$tableName}` ({$fieldStr}) VALUES " . implode(',', $values);

        try {
            $result = Db::execute($sql); 

        } catch (\Exception $e) {

            throw $e;
        }
    }


    /**
     * 插入分摊系数
     */
    protected function insertAllocationFactors(): void
    {
        if (!empty($this->allocationFactors)) {
            $total = count($this->allocationFactors);

            for ($i = 0; $i < $total; $i += self::BATCH_SIZE) {
                $batch = array_slice($this->allocationFactors, $i, self::BATCH_SIZE);
                $this->insertBatch($batch, '成本_各月分摊系数', $i);
            }
        }
    }

    /**
     * 记录成功日志
     */
    protected function logSuccess(string $month): void
    {
        try {
            // 确保记录数为整数
            $monthlyCostDetailsCount = is_countable($this->monthlyCostDetails) ? count($this->monthlyCostDetails) : 0;
            $allocationFactorsCount = is_countable($this->allocationFactors) ? count($this->allocationFactors) : 0;

            $logData = [
                'month' => $month,
                '月度成本明细记录数' => $monthlyCostDetailsCount,
                '分摊系数记录数' => $allocationFactorsCount,
                'timestamp' => date('Y-m-d H:i:s')
            ];

            // 记录每个字段的数据类型，用于调试
            if (!empty($this->monthlyCostDetails)) {
                $firstRecord = reset($this->monthlyCostDetails);
                $logData['first_record_keys'] = is_array($firstRecord) ? array_keys($firstRecord) : 'invalid';
                $logData['first_record_type'] = gettype($firstRecord);
            }



        } catch (\Throwable $t) {

        }
    }

    /**
     * 构建成功响应
     */
    protected function buildSuccessResponse(string $month): array
    {
        try {
            return [
                'success' => true,
                'message' => '成本核算完成',
                'month' => $month,
                'stats' => [
                    'monthly_cost_details' => is_countable($this->monthlyCostDetails) ? count($this->monthlyCostDetails) : 0,
                    'allocation_factors' => is_countable($this->allocationFactors) ? count($this->allocationFactors) : 0
                ],
                'timestamp' => date('Y-m-d H:i:s')
            ];
        } catch (\Throwable $t) {
            // 即使构建响应失败，也返回基本成功信息
            return [
                'success' => true,
                'message' => '成本核算完成（统计信息获取失败）',
                'month' => $month,
                'error' => $t->getMessage()
            ];
        }
    }

    /**
     * 记录错误日志
     */
    protected function logError(\Throwable $t): void
    {
        try {
            $errorDetails = [
                '时间' => date('Y-m-d H:i:s'),
                '错误类型' => get_class($t),
                '错误信息' => $t->getMessage(),
                '错误代码' => $t->getCode(),
                '文件' => $t->getFile(),
                '行号' => $t->getLine(),
                '堆栈跟踪' => $t->getTraceAsString(),
                '月度成本明细数' => is_countable($this->monthlyCostDetails) ? count($this->monthlyCostDetails) : 'N/A',
                '分摊系数数' => is_countable($this->allocationFactors) ? count($this->allocationFactors) : 'N/A',
            ];


        } catch (\Throwable $logError) {

        }
    }

    /**
     * 构建错误响应
     */
    protected function buildErrorResponse(Exception $e): array
    {
        return [
            'success' => false,
            'message' => '成本核算失败: ' . $e->getMessage(),
            'error' => $e->getMessage()
        ];
    }

    /**
     * 清理字段名中的特殊字符
     */
    protected function sanitizeFieldNames(array &$row): void
    {
        $sanitized = [];
        foreach ($row as $key => $value) {
            // 移除字段名中的特殊字符，只保留字母、数字、下划线和中文字符
            $cleanKey = preg_replace('/[^\w\x{4e00}-\x{9fa5}]/u', '', $key);

            $sanitized[$cleanKey] = $value;
        }
        $row = $sanitized;
    }
}