package com.ruoyi.buss.controller;


import com.ruoyi.buss.common.DateUtils;
import com.ruoyi.buss.common.NumberUtils;
import com.ruoyi.buss.domain.*;
import com.ruoyi.buss.domain.vo.TaskAssess;
import com.ruoyi.buss.service.*;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.system.service.ISysDictDataService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.text.DecimalFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 支队效能评估逻辑Controller
 *
 * @author yl
 * @date 2025-03-20
 */

@Tag(name = "支队效能评估")
@Controller
@RequestMapping("/buss/zd/effect")
public class ZdEffectEstimateController extends BaseController {
    private static final Logger log = LoggerFactory.getLogger(ZdEffectEstimateController.class);


    private static DecimalFormat df = new DecimalFormat("#.00");
    private static DecimalFormat df2 = new DecimalFormat("#.0");

    @Autowired
    private IDsTaskList2Service dsTaskList2Service;
    @Autowired
    private IDmBerth2Service dmBerth2Service;
    @Autowired
    private ISysDictDataService sysDictDataService;
    @Autowired
    private IDsTaskDetailService iDsTaskDetailService;
    @Autowired
    private IDsEffectAssessService dsEffectAssessService;
    @Autowired
    private IDsEffectAssessListService dsEffectAssessListService;
    @Autowired
    private IDmHarbor2Service dmHarbor2Service;

    private final static double B11_VALUE = 24; // 舰船平均任务时间

    private final static int X_TOLERANCE_VALUE = 0; // 船舶数量

    private final static Double OIL_PLACE_PER = 0.3;
    private final static Double MAT_PLACE_PER = 0.2;
    private final static Double AMMO_PLACE_PER = 0.5;

    private final static int SUPPLY_X_TIME = 2;

    /**
     * 计算支队效能评估
     * @return
     */
    @Operation(description = "支队效能评估计算")
    @Log(title = "支队效能评估计算", businessType = BusinessType.INSERT)
    @PostMapping("/estimate")
    @ResponseBody
    public AjaxResult estimate(@Parameter(name = "type", required = true, description = "评估类型") String type,
                               @Parameter(name = "taskId", required = true, description = "任务ID") Long taskId,
                               @Parameter(name = "deptId", required = true, description = "部门ID") Long deptId) {
        DmHarbor2 dmHarbor2 = new DmHarbor2();
        dmHarbor2.setDeptId(deptId);
        List<DmHarbor2> dmHarbor2List = dmHarbor2Service.selectDmHarborList(dmHarbor2);
        String dmHarborPkIds = "";
        if (dmHarbor2List != null || dmHarbor2List.size() > 0) {
            for (DmHarbor2 dmHarbor : dmHarbor2List){
                dmHarbor.getPKID();
                dmHarborPkIds += dmHarbor.getPKID() + ",";
            }
            dmHarborPkIds = dmHarborPkIds.substring(0, dmHarborPkIds.length() - 1);
            dmHarborPkIds = "(" + dmHarborPkIds + ")";
        }

        DsEffectAssessList assess = new DsEffectAssessList();
        assess.setTYPE(type);
        List<DsEffectAssessList> dsEffectAssessLists = dsEffectAssessListService.selectDsEffectAssessListList(assess);
        List<DsTaskDetail> dsTaskDetailList = iDsTaskDetailService.selectDsTaskDetailByTaskIdAndHarborIds(taskId, dmHarborPkIds);
        if (dsEffectAssessLists != null && dsEffectAssessLists.size() > 0) {
            for(int i = 0; i < dsEffectAssessLists.size(); i++){
                DsEffectAssessList dsEffectAssessList = dsEffectAssessLists.get(i);
                log.debug("【" + dsEffectAssessList.getCODE() + "】 DsEffectAssessList Obj =====: " + dsEffectAssessList);
                String code = dsEffectAssessList.getCODE();
                double weights = dsEffectAssessList.getWEIGHT();
                double classifyWeight = dsEffectAssessList.getClassifyWeight();

                double itemResult = calcNormItemResult(code, weights, dsTaskDetailList);
                DsEffectAssessList asscessList = new DsEffectAssessList();
                asscessList.setPKID(dsEffectAssessList.getPKID());
                asscessList.setVal(itemResult);
                dsEffectAssessListService.updateDsEffectAssessList(asscessList);
            }
        }

        // 计算最终评估结果
        List<DsEffectAssessList> dsEffectAssessLists2 = dsEffectAssessListService.selectDsEffectAssessListList(assess);
        double score = getScore(dsEffectAssessLists2);
        log.debug("Score =====： " + score);
        DsEffectAssess dsEffectAssess =  new DsEffectAssess(taskId, score);
        dsEffectAssess.setCreateTime(new Date());
        dsEffectAssess.setCreateBy(getUsername());
        dsEffectAssess.setDeptId(getDeptId());
        // 保存评估结果
        dsEffectAssessService.updateOrInsertDsEffectAssess(dsEffectAssess);
        log.debug("完成更新/新增Access记录。");

        TaskAssess taskAssess = new TaskAssess();
        taskAssess.setList(dsEffectAssessLists);
        taskAssess.setAssess(dsEffectAssess);
        if(null != dsEffectAssessLists){
            return success(taskAssess);
        }
        return error("获取能效评估详情失败，请重试");
    }

    private double calcNormItemResult(String code, double weights, List<DsTaskDetail> dsTaskDetailList) {
        int result = 0;
        if ("B11".equals(code)) {
            // 独立参考指标不参与加权计算
        } else if ("B12".equals(code)) {
            result = calcB12(dsTaskDetailList);
        } else if ("B13".equals(code)) {
            result = calcB13(dsTaskDetailList);
        } else if ("B14".equals(code)) {
            result = calcB14(dsTaskDetailList);
        } else if ("B15".equals(code)) {
            result = calcB15(dsTaskDetailList);
        } else if ("B16".equals(code)) {
            result = calcB16(dsTaskDetailList);
        } else if ("B17".equals(code)) {
            result = calcB17(dsTaskDetailList);
        } else if ("B21".equals(code)) {
            result = calcB21(dsTaskDetailList);
        } else if ("B22".equals(code)) {
            result = calcB22(dsTaskDetailList);
        } else if ("B23".equals(code)) {
            result = calcB23(dsTaskDetailList);
        } else if ("B24".equals(code)) {
            result = calcB24(dsTaskDetailList);
        } else if ("B25".equals(code)) {
            result = calcB25(dsTaskDetailList);
        } else if ("B31".equals(code)) {
            // 独立参考指标不参与加权计算
        } else if ("B32".equals(code)) {
            result = calcB32(dsTaskDetailList);
        } else if ("B33".equals(code)) {
            // 独立参考指标不参与加权计算
        } else if ("B34".equals(code)) {
            result = calcB34(dsTaskDetailList);
        } else if ("B35".equals(code)) {
            // 独立参考指标不参与加权计算
        } else if ("B36".equals(code)) {
            result = calcB36(dsTaskDetailList);
        } else if ("B41".equals(code)) {
            result = calcB41(dsTaskDetailList);
        } else if ("B42".equals(code)) {
            result = calcB42(dsTaskDetailList);
        } else if ("B43".equals(code)) {
            result = calcB43(dsTaskDetailList);
        } else if ("B44".equals(code)) {
            result = calcB44(dsTaskDetailList);
        } else if ("B45".equals(code)) {
            result = calcB45(dsTaskDetailList);
        }
        log.debug("【" + code + "】权重值 ===：" + weights);
        log.debug("【" + code + "】计算结果 ===：" + result);
        log.debug("【" + code + "】加权值 ===：" + result * weights);
        return result * weights;
    }

    // 计算最终分数
    private Double getScore(List<DsEffectAssessList> list){
        Double score = 0.0;
        if(null != list  && list.size() > 0){
            Map<String, List<DsEffectAssessList>> groupedByCode = list.stream()
                    .collect(Collectors.groupingBy(item -> item.getCODE().substring(0, 2)));

            for (Map.Entry<String, List<DsEffectAssessList>> berthEntry : groupedByCode.entrySet()) {
                DsEffectAssessList effectAssess = berthEntry.getValue().get(0);
                Double classifyWeight = null == effectAssess.getClassifyWeight()?0.0:effectAssess.getClassifyWeight();

                Double totalValue = berthEntry.getValue().stream()
                        .mapToDouble(item -> item.getVal() * item.getWEIGHT())
                        .sum();
                score += totalValue * classifyWeight;
            }
        }
        return NumberUtils.roundToTwoDecimalPlaces(score);
    }

    /**
     * B12：舰船平均任务时间：本港从T时刻起算，所有舰船从等待到完成补给的平均时间。
     * 公式：10*(该原始指标/B11)。注：计算的是舰船平均补给时间与平均任务时间的比例，该值越大越好
     * @return
     */
    private int calcB12(List<DsTaskDetail> dsTaskDetails) {
        double result = 0;
        if (dsTaskDetails != null && dsTaskDetails.size() > 0) {
            for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
                DsTaskDetail dsTaskDetail1 = dsTaskDetails.get(i);
                int oilTime = dsTaskDetail1.getOilTime();
                int matTime = dsTaskDetail1.getMatTime();
                int ammoTime = dsTaskDetail1.getAmmoTime();
                int waterTime = dsTaskDetail1.getWaterTime();
                // result += DateUtils.getDisHourOfTowDate(tTime,eTime1);
                result += oilTime + matTime +  ammoTime + waterTime;
            }
        }
        double temp = (result / dsTaskDetails.size() / B11_VALUE) > 1 ? 1 : (result / dsTaskDetails.size() / B11_VALUE);
        log.debug("B12 Value =====：" + (10 * Double.parseDouble(df2.format(temp))));
        return (int) (10 * Double.parseDouble(df2.format(temp)));
    }

    /**
     * B13：舰船平均等待时间：本港从T时刻起算，后续所有舰船等待时间均值。
     * 公式：10*(1-该原始指标/B11)。注：计算的是舰船平均等待时间与平均任务时间的比例，等待时间越小越好，所以折算指标用1减去该值
     * @return
     */
    private int calcB13(List<DsTaskDetail> dsTaskDetails){
        // 按加油需求、船类型和抵港时间排序
        dsTaskDetails.sort(Comparator.comparing(DsTaskDetail::getBerthId).thenComparing(DsTaskDetail::getSupplySeq));

        // 按泊位号进行分组
        Map<Long, List<DsTaskDetail>> detailMap = new HashMap<>();
        for (DsTaskDetail detail : dsTaskDetails) {
            Long berthId = detail.getBerthId();
            detailMap.computeIfAbsent(berthId, k -> new ArrayList<>()).add(detail);
        }
        double waitTime = 0.0;
        for (List<DsTaskDetail> groupDsTaskDetails : detailMap.values()) {
            Date startTDate = null;
            for (int i = 0; i < groupDsTaskDetails.size(); i++) {
                DsTaskDetail detail = groupDsTaskDetails.get(i);
                if (i == 0) {
                    startTDate = detail.getT1();
                }
                Date sTime = detail.getSTIME();
                waitTime += DateUtils.getDisHourOfTowDate(startTDate, sTime);
            }
        }
        double temp = (waitTime / B11_VALUE) > 1 ? 1 : (waitTime / B11_VALUE);
        log.debug("B13 Value =====：" + (10 * (1 - Double.parseDouble(df2.format(temp)))));
        return (int) (10 * (1 - Double.parseDouble(df2.format(temp))));
    }

    /**
     * B14：单舰折叠补给时间：本港补给起止时间差/舰艇数量。
     * 24小时以上0分，18-24小时2分，12-18小时4分，8-12小时6分，4-8小时8分，4小时以下10分
     * @return
     */
    private int calcB14(List<DsTaskDetail> dsTaskDetails){
        double result = 0;
        if (dsTaskDetails != null && dsTaskDetails.size() > 0) {
            for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
                DsTaskDetail dsTaskDetail = dsTaskDetails.get(i);
                // Date sTime1 = dsTaskDetail.getSTIME();
                int oilTime = dsTaskDetail.getOilTime();
                int matTime = dsTaskDetail.getMatTime();
                int ammoTime = dsTaskDetail.getAmmoTime();
                int waterTime = dsTaskDetail.getWaterTime();
                result += oilTime + matTime +  ammoTime + waterTime;
                // result += DateUtils.getDisHourOfTowDate(sTime1, eTime1);
            }
            double point = result / (dsTaskDetails.size());
            log.debug("B14 Value =====：" + point);
            if(point >= 24){
                return 0;
            }else if(point > 18 && point <= 24){
                return 2;
            }else if(point > 12 && point <= 18){
                return 4;
            }else if(point > 8 && point <= 12){
                return 6;
            }else if(point > 4 && point <= 8){
                return 8;
            }else if(point <= 4){
                return 10;
            }
        }
        return 0;
    }

    /**
     * B15：舰船同时补给数量：本港根据泊位数和并靠策略，计算可同时补给的舰船数。
     * 10*原始指标/（2*总泊位数），注：按本港所有泊位可用且双舰并靠为参考数，大于10时取10
     * @return
     */
    private int calcB15(List<DsTaskDetail> dsTaskDetails){
        int berthCount = getBerthCountOfHarbor();

        if (dsTaskDetails != null && dsTaskDetails.size() > 0) {
            String parkingType = dsTaskDetails.get(0).getParkingType();
            if ("1".equals(parkingType)) {
                if (dsTaskDetails.size() >= berthCount) {
                    return berthCount;
                } else if (dsTaskDetails.size() < berthCount) {
                    return dsTaskDetails.size();
                }
            } else if ("2".equals(parkingType)) {
                if (dsTaskDetails.size() / 2 >= berthCount) {
                    return berthCount * 2;
                } else if (dsTaskDetails.size() / 2 < berthCount) {
                    if (dsTaskDetails.size() % 2 == 0) {
                        return dsTaskDetails.size() / 2;
                    } else {
                        return (dsTaskDetails.size() / 2) + 1;
                    }
                }
            } else if ("3".equals(parkingType)) {
                if (dsTaskDetails.size() / 3 >= berthCount) {
                    return berthCount * 3;
                } else if (dsTaskDetails.size() / 3 < berthCount) {
                    if (dsTaskDetails.size() % 3 == 0) {
                        return dsTaskDetails.size() / 3;
                    } else {
                        return (dsTaskDetails.size() / 3) + 1;
                    }
                }
            }
        }
        return 0;
    }

    /**
     * B16：各泊位结束时间最大差：本港各泊位补给作业最终结束时间最大差值。
     * 24小时以上0分，16-24小时2分，12-16小时4分，8-12小时6分，4-8小时8分，4小时以内10分
     * @return
     */
    private int calcB16(List<DsTaskDetail> dsTaskDetails){
        List<Date> eTimeList = new ArrayList<>();
        if(dsTaskDetails != null && dsTaskDetails.size() > 0){
            for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
                DsTaskDetail dsTaskDetail1 = dsTaskDetails.get(i);
                Date sTime = dsTaskDetail1.getSTIME();
                int oilTime = dsTaskDetail1.getOilTime();
                int matTime = dsTaskDetail1.getMatTime();
                int ammoTime = dsTaskDetail1.getAmmoTime();
                int waterTime = dsTaskDetail1.getWaterTime();
                int result = oilTime + matTime +  ammoTime + waterTime;
                Date eTime = DateUtils.getDateAfterHours(sTime, result);
                eTimeList.add(eTime);
            }
            // 获取最小时间
            Date minDate = Collections.min(eTimeList);
            // 获取最大时间
            Date maxDate = Collections.max(eTimeList);
            // 计算时间差
            double dateInterval = DateUtils.getDisHourOfTowDate(minDate, maxDate);
            log.debug("B16 Value =====：" + dateInterval);
            if(dateInterval >= 24){
                return 0;
            }else if(dateInterval >= 16 && dateInterval < 24){
                return 2;
            }else if(dateInterval >= 12 && dateInterval < 16){
                return 4;
            }else if (dateInterval >= 8 && dateInterval < 12){
                return 6;
            }else if (dateInterval >= 4 && dateInterval < 8){
                return 8;
            }else if (dateInterval < 4){
                return 10;
            }
        }
        return 0;
    }

    /**
     * B17：补给容差占比均值：本港各舰容差X相对于补给时间A2所占比例的平均值。
     * 10*(1-该原始指标值)
     * @return
     */
    private int calcB17(List<DsTaskDetail> dsTaskDetails) {
        double allValue = 0.0;
        for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
            DsTaskDetail detail = dsTaskDetails.get(i);
            int oilTime = detail.getOilTime();
            int ammoTime = detail.getAmmoTime();
            int matTime = detail.getMatTime();
            int waterTime = detail.getWaterTime();
            int totalTime = oilTime + ammoTime + matTime + waterTime;
            allValue += (double) totalTime / SUPPLY_X_TIME;
        }
        double avg = allValue / dsTaskDetails.size() > 1 ? 1 : allValue / dsTaskDetails.size();
        log.debug("B17 Value =====：" + (10 * (1 - Double.parseDouble(df2.format(avg)))));
        return (int) (10 * (1 - Double.parseDouble(df2.format(avg))));
    }

    /**
     * B21：单舰平均停靠时间：本港各舰艇从T时刻到T+X补给结束的平均值。
     * 48小时以上4分，36-48小时6分，24-30小时8分，18-24小时10分，12-18小时8分，12小时以下6分，以24小时为中心的正态分布。
     * @return
     */
    private int calcB21(List<DsTaskDetail> dsTaskDetails) {
        double dateInterval = 0;
        if (dsTaskDetails != null && dsTaskDetails.size() > 0) {
            for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
                DsTaskDetail dsTaskDetail1 = dsTaskDetails.get(i);
                Date tTime = dsTaskDetail1.getT1();
                int oilTime = dsTaskDetail1.getOilTime();
                int ammoTime = dsTaskDetail1.getAmmoTime();
                int matTime = dsTaskDetail1.getMatTime();
                int waterTime = dsTaskDetail1.getWaterTime();
                int totalTime = oilTime + ammoTime + matTime + waterTime;
                dateInterval += totalTime + 1;
            }
            double avg = dateInterval / dsTaskDetails.size();
            log.debug("B21 Value =====：" + avg);
            if (avg >= 48) {
                return 4;
            } else if (avg >= 36 && avg < 48) {
                return 6;
            } else if (avg >= 24 && avg < 30) {
                return 8;
            } else if (avg >= 18 && avg < 24) {
                return 10;
            } else if (avg >= 12 && avg < 18) {
                return 8;
            } else if (avg < 12) {
                return 6;
            }
        }
        return 0;
    }

    /**
     * B22：补给作业时间均值：各舰艇主线补给作业时间的平均值。
     * 36小时以上4分，24-36小时6分，20-24小时8分，16-20小时10分，12-16小时8分，8小时以下6分，以18小时为中心的正态分布。
     * @return
     */
    private int calcB22(List<DsTaskDetail> dsTaskDetails){
        double dateInterval = 0;
        if (dsTaskDetails != null && dsTaskDetails.size() > 0) {
            for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
                DsTaskDetail dsTaskDetail1 = dsTaskDetails.get(i);
                Date sTime = dsTaskDetail1.getSTIME();
                int oilTime = dsTaskDetail1.getOilTime();
                int matTime = dsTaskDetail1.getMatTime();
                int ammoTime = dsTaskDetail1.getAmmoTime();
                int waterTime = dsTaskDetail1.getWaterTime();
                int result = oilTime + matTime +  ammoTime + waterTime;
                dateInterval += result - X_TOLERANCE_VALUE;
            }
            double avg = dateInterval / dsTaskDetails.size();
            log.debug("B22 Value =====：" + avg);
            if(avg >= 36){
                return 4;
            }else if(avg >= 24 && avg < 36){
                return 6;
            }else if(avg >= 20 && avg < 24){
                return 8;
            }else if (avg >= 16 && avg < 20){
                return 10;
            }else if (avg >= 12 && avg < 16){
                return 8;
            }else if (avg < 8){
                return 6;
            }
        }
        return 0;
    }

    /**
     * B23：补给非作业时间均值：（各舰艇停泊时间-作业时间）的平均值。
     * 24小时以上0分，16-24小时2分，12-16小时4分，8-12小时6分，4-8小时8分，4小时以内10分。该值越小越好，但也不可能为0，所以4小时以下均为最好。
     * @return
     */
    private int calcB23(List<DsTaskDetail> dsTaskDetails){
        double allTime = 0;
        if (dsTaskDetails != null && dsTaskDetails.size() > 0) {
            for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
                DsTaskDetail dsTaskDetail1 = dsTaskDetails.get(i);
                int oilTime = dsTaskDetail1.getOilTime();
                int ammoTime = dsTaskDetail1.getAmmoTime();
                int matTime = dsTaskDetail1.getMatTime();
                int waterTime = dsTaskDetail1.getWaterTime();
                int totalTime = oilTime + ammoTime + matTime + waterTime;

                //int elecSTime = dsTaskDetail1.getElecStime();
                //int elecETime = dsTaskDetail1.getElecEtime();

                int waterSTime = dsTaskDetail1.getWaterStime();
                int waterETime = dsTaskDetail1.getWaterEtime();

                int oilSTime = dsTaskDetail1.getOilStime();
                int oilETime = dsTaskDetail1.getOilEtime();

                int ammoSTime = dsTaskDetail1.getAmmoStime();
                int ammoETime = dsTaskDetail1.getAmmoEtime();

                int matSTime = dsTaskDetail1.getMatStime();
                int matETime = dsTaskDetail1.getMatEtime();

                int workTime = (waterETime - waterSTime) + (oilETime - oilSTime) + (ammoETime - ammoSTime) + (matETime - matSTime);

                allTime += Math.abs(totalTime + 1 - workTime);
            }
            double avg = allTime / dsTaskDetails.size();
            log.debug("B23 Value =====：" + avg);
            if(avg >= 24){
                return 0;
            }else if(avg >= 16 && avg < 24){
                return 2;
            }else if(avg >= 12 && avg < 16){
                return 4;
            }else if (avg >= 8 && avg < 12){
                return 6;
            }else if (avg >= 4 && avg < 8){
                return 8;
            }else if (avg < 4){
                return 10;
            }
        }
        return 0;
    }

    /**
     * B24：补给作业停泊比例：各舰累计补给时间总和/累计靠泊时间总和
     * 10*该原始指标值。
     * @return
     */
    private int calcB24(List<DsTaskDetail> dsTaskDetails) {
        double allBerthTime = 0;
        double allWorkTime = 0;
        if (dsTaskDetails != null && dsTaskDetails.size() > 0) {
            for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
                DsTaskDetail dsTaskDetail1 = dsTaskDetails.get(i);
                int oilTime = dsTaskDetail1.getOilTime();
                int ammoTime = dsTaskDetail1.getAmmoTime();
                int matTime = dsTaskDetail1.getMatTime();
                int waterTime = dsTaskDetail1.getWaterTime();
                int totalTime = oilTime + ammoTime + matTime + waterTime;

                int waterSTime = dsTaskDetail1.getWaterStime();
                int waterETime = dsTaskDetail1.getWaterEtime();

                int oilSTime = dsTaskDetail1.getOilStime();
                int oilETime = dsTaskDetail1.getOilEtime();

                int ammoSTime = dsTaskDetail1.getAmmoStime();
                int ammoETime = dsTaskDetail1.getAmmoEtime();

                int matSTime = dsTaskDetail1.getMatStime();
                int matETime = dsTaskDetail1.getMatEtime();

                allWorkTime += (waterETime - waterSTime) + (oilETime - oilSTime) + (ammoETime - ammoSTime) + (matETime - matSTime);
                allBerthTime += Math.abs(totalTime);
            }
            double temp = allWorkTime / allBerthTime > 1 ? 1 : allWorkTime / allBerthTime;
            log.debug("B24 Value =====：" + (10 * (Double.parseDouble(df2.format(temp)))));
            return (int) (10 * (Double.parseDouble(df2.format(temp))));
        }
        return 0;
    }

    /**
     * B25：补给时间折叠比例：本批补给起止时间差/各舰补给时间总和
     * 10*(1-该原始指标值)
     * @return
     */
    private int calcB25(List<DsTaskDetail> dsTaskDetails){
        List<Date> eTimeList = new ArrayList<>();
        double allWorkTime = 0;
        if (dsTaskDetails != null && dsTaskDetails.size() > 0) {
            for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
                DsTaskDetail dsTaskDetail1 = dsTaskDetails.get(i);
                eTimeList.add(dsTaskDetail1.getSTIME());
                int oilTime = dsTaskDetail1.getOilTime();
                int ammoTime = dsTaskDetail1.getAmmoTime();
                int matTime = dsTaskDetail1.getMatTime();
                int waterTime = dsTaskDetail1.getWaterTime();
                int totalTime = oilTime + ammoTime + matTime + waterTime + X_TOLERANCE_VALUE;
                Date eTime = DateUtils.getDateAfterHours(dsTaskDetail1.getSTIME(), totalTime);
                eTimeList.add(eTime);

                int waterSTime = dsTaskDetail1.getWaterStime();
                int waterETime = dsTaskDetail1.getWaterEtime();

                int oilSTime = dsTaskDetail1.getOilStime();
                int oilETime = dsTaskDetail1.getOilEtime();

                int ammoSTime = dsTaskDetail1.getAmmoStime();
                int ammoETime = dsTaskDetail1.getAmmoEtime();

                int matSTime = dsTaskDetail1.getMatStime();
                int matETime = dsTaskDetail1.getMatEtime();

                allWorkTime += (waterETime - waterSTime) + (oilETime - oilSTime) + (ammoETime - ammoSTime) + (matETime - matSTime);
            }
            // 获取最小时间
            Date minDate = Collections.min(eTimeList);
            // 获取最大时间
            Date maxDate = Collections.max(eTimeList);
            // 计算时间差
            double dateInterval = DateUtils.getDisHourOfTowDate(maxDate, minDate);
            double temp = (dateInterval / allWorkTime) > 1 ? 1 : (dateInterval / allWorkTime);
            log.debug("B25 Value =====：" + (10 * (1 - Double.parseDouble(df2.format(temp)))));
            return (int) (10 * (1 - Double.parseDouble(df2.format(temp))));
        }
        return 0;
    }

    /**
     * B32：水电保障日作业强度：各水电小组24小时内平均作业时间/24小时，平均值
     * 10 * 该原始指标值
     * @return
     */
    private int calcB32(List<DsTaskDetail> dsTaskDetails){
        double allTime = 0;
        for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
            DsTaskDetail dsTaskDetail1 = dsTaskDetails.get(i);
            // int elecSTime = dsTaskDetail1.getElecStime();
            // int elecETime = dsTaskDetail1.getElecEtime();
            // int eleTime = elecETime - elecSTime;
            int waterTime = dsTaskDetail1.getWaterTime();
            allTime += waterTime;
        }
        double avgValue = (allTime / (dsTaskDetails.size() * 24)) > 1 ? 1 : (allTime / (dsTaskDetails.size() * 24));
        log.debug("B32 Value =====：" + (10 * Double.parseDouble(df2.format(avgValue))));
        return (int) (10 * Double.parseDouble(df2.format(avgValue)));
    }

    /**
     * B34：油料补给日作业强度：各加油小组24小时内平均作业时间/24小时，平均值
     * 10 * 该原始指标值
     * @return
     */
    private int calcB34(List<DsTaskDetail> dsTaskDetails){
        double days = 0;
        double allTime = 0;
        for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
            DsTaskDetail dsTaskDetail1 = dsTaskDetails.get(i);
            Date sTime= dsTaskDetail1.getSTIME();
            int oilTime = dsTaskDetail1.getOilTime();
            Date oilEndTime = DateUtils.getDateAfterHours(sTime, oilTime);

            double hourDistance = DateUtils.getDisHourOfTowDate(sTime, oilEndTime);
            if(hourDistance < 24){
                days += 1;
            }else {
                days += (int) Math.ceil(hourDistance / 24);
            }
            allTime += oilTime;
        }
        double avgValue = (allTime / (days * 24)) > 1 ? 1 : (allTime / (days * 24));
        log.debug("B34 Value =====：" + (10 * Double.parseDouble(df2.format(avgValue))));
        return (int) (10 * Double.parseDouble(df2.format(avgValue)));
    }

    /**
     * B36：物资补给日作业强度：各物资车辆24小时内作业时间/24小时，平均值
     * 10 * 该原始指标值
     * @return
     */
    private int calcB36(List<DsTaskDetail> dsTaskDetails) {
        double days = 0;
        double allTime = 0;
        for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
            DsTaskDetail dsTaskDetail1 = dsTaskDetails.get(i);
            Date sTime= dsTaskDetail1.getSTIME();
            int matTime = dsTaskDetail1.getMatTime();
            Date matEndTime = DateUtils.getDateAfterHours(sTime, matTime);

            double hourDistance = DateUtils.getDisHourOfTowDate(sTime, matEndTime);
            if(hourDistance < 24){
                days += 1;
            }else {
                days += (int) Math.ceil(hourDistance / 24);
            }
            allTime += matTime;
        }
        double avgValue = (allTime / (days * 24)) > 1 ? 1 : (allTime / (days * 24));
        log.debug("B36 Value =====：" + (10 * Double.parseDouble(df2.format(avgValue))));
        return (int) (10 * Double.parseDouble(df2.format(avgValue)));
    }

    /**
     * B41：泊位日均周转艘次：本港补给舰船总数量/天数/泊位数
     * 10 * 该原始指标值/3，注：3为参考值，通常最大周转量不大于3（就是三艘并靠1天的情况），如果大于10则取值为10
     * @return
     */
    private int calcB41(List<DsTaskDetail> dsTaskDetails) {
        List<Date> timeList = new ArrayList<>();
        for (int i = 0; i < dsTaskDetails.size() - 1; i++) {
            DsTaskDetail dsTaskDetail1 = dsTaskDetails.get(i);
            timeList.add(dsTaskDetail1.getSTIME());
            int oilTime = dsTaskDetail1.getOilTime();
            int ammoTime = dsTaskDetail1.getAmmoTime();
            int matTime = dsTaskDetail1.getMatTime();
            int waterTime = dsTaskDetail1.getWaterTime();
            int totalTime = oilTime + ammoTime + matTime + waterTime;
            Date eTime = DateUtils.getDateAfterHours(dsTaskDetail1.getSTIME(), totalTime + X_TOLERANCE_VALUE);
            timeList.add(eTime);
        }
        // 获取最小时间
        Date minDate = Collections.min(timeList);
        // 获取最大时间
        Date maxDate = Collections.max(timeList);
        // 计算时间差
        double days = DateUtils.getSubtractOfTowDate(maxDate, minDate);
        int berthCount = getBerthCountOfHarbor();
        double originalValue = (dsTaskDetails.size() / days / berthCount / 3) > 1 ? 1 : (dsTaskDetails.size() / days / berthCount / 3);
        log.debug("B41 Value =====：" + (10 * Double.parseDouble(df2.format(originalValue))));
        return (int) (10 * Double.parseDouble(df2.format(originalValue)));
    }

    /**
     * B42：前沿占地最大均值：本港补给各港各码头各泊位最大占地均值
     * 检索各前沿场地占用率，取最大值均值
     * @return
     */
    private int calcB42(List<DsTaskDetail> dsTaskDetails) {
        double allValue = 0.0;
        for (int i = 1; i <= 24; i++) {
            String timeSlot = "t" + i;
            int oilCount = 0;
            int ammoCount = 0;
            int matCount = 0;
            for (DsTaskDetail task : dsTaskDetails) {
                if (task.getOilStime() != null && task.getOilStime() <= i && task.getOilEtime() >= i) {
                    oilCount++;
                } else if (task.getAmmoStime() != null && task.getAmmoStime() <= i && task.getAmmoEtime() >= i) {
                    ammoCount++;
                } else if (task.getMatStime() != null && task.getMatStime() <= i && task.getMatEtime() >= i) {
                    matCount++;
                }
            }

            Double totalSupply = NumberUtils.roundToTwoDecimalPlaces(oilCount * OIL_PLACE_PER + ammoCount * AMMO_PLACE_PER + matCount * MAT_PLACE_PER);
            double maxPlat = 0.0;
            if(maxPlat < totalSupply){
                maxPlat = totalSupply;
            }
            allValue += maxPlat;
        }
        double temp = (allValue / dsTaskDetails.size()) > 1 ? 1 : (allValue / dsTaskDetails.size());
        log.debug("B42 Value =====：" + (10 * Double.parseDouble(df2.format(temp))));
        return (int) (10 * Double.parseDouble(df2.format(temp)));
    }

    /**
     * B43：前沿占半时长均值：本港补给各泊位首个24小时内占地0.5以上的时间均值
     * 10*该原始指标值/24，注：基准值取24小时
     * @return
     */
    private int calcB43(List<DsTaskDetail> dsTaskDetails) {
        Integer platTime = 0;
        for (int i = 1; i <= 24; i++) {
            int oilCount = 0;
            int ammoCount = 0;
            int matCount = 0;
            for (DsTaskDetail task : dsTaskDetails) {
                if (task.getOilStime() != null && task.getOilStime() <= i && task.getOilEtime() >= i) {
                    oilCount++;
                } else if (task.getAmmoStime() != null && task.getAmmoStime() <= i && task.getAmmoEtime() >= i) {
                    ammoCount++;
                } else if (task.getMatStime() != null && task.getMatStime() <= i && task.getMatEtime() >= i) {
                    matCount++;
                }
            }
            Double totalSupply = NumberUtils.roundToTwoDecimalPlaces(oilCount * OIL_PLACE_PER + ammoCount * AMMO_PLACE_PER + matCount * MAT_PLACE_PER);
            if(totalSupply >= 0.5){
                platTime++;
            }
        }
        double temp = (platTime / 24) > 1 ? 1 : (platTime / 24);
        log.debug("B43 Value =====：" + (10 * Double.parseDouble(df2.format(temp))));
        return (int) (10 * Double.parseDouble(df2.format(temp)));
    }

    /**
     * B44：加油设施日均使用率：本港按泊位统计设施首个24小时内加油作业时间/24小时，求均值
     * 检索各泊位首个24小时内加油作业时间/24
     * @return
     */
    private int calcB44(List<DsTaskDetail> dsTaskDetails) {
        // 按加油需求、船类型和抵港时间排序
        dsTaskDetails.sort(Comparator.comparing(DsTaskDetail::getBerthId).thenComparing(DsTaskDetail::getSupplySeq));

        // 按泊位号进行分组
        Map<Long, List<DsTaskDetail>> detailMap = new HashMap<>();
        for (DsTaskDetail detail : dsTaskDetails) {
            Long berthId = detail.getBerthId();
            detailMap.computeIfAbsent(berthId, k -> new ArrayList<>()).add(detail);
        }
        Date after24Hour = null; // 首个24小时截止时间
        double allTime = 0.0;
        for (List<DsTaskDetail> groupDsTaskDetails : detailMap.values()) {
            for (int i = 0; i < groupDsTaskDetails.size(); i++) {
                DsTaskDetail detail1 = groupDsTaskDetails.get(i);
                int oilStartTime = detail1.getOilStime();
                int oilEndTime = detail1.getOilEtime();
                int oilTime = detail1.getOilTime();
                Date t1Date = detail1.getT1();
                Date oilStartDate = DateUtils.getDateAfterHours(t1Date, oilStartTime);
                Date oilEndDate = DateUtils.getDateAfterHours(t1Date, oilTime);

                if (i == 0) {
                    after24Hour = DateUtils.getDateAfterHours(t1Date, 24);
                }

                if (oilStartDate.before(after24Hour) && oilEndDate.before(after24Hour)) {
                    allTime += oilTime;
                } else if (oilStartDate.before(after24Hour) && oilEndDate.after(after24Hour)) {
                    allTime += DateUtils.getDisHourOfTowDate(oilStartDate, after24Hour);
                } else {
                    allTime += 0;
                }
            }
        }
        double temp = (allTime / 24) > 1 ? 1 : (allTime / 24);
        log.debug("B44 Value =====：" + (10 * Double.parseDouble(df2.format(temp))));
        return (int) (10 * Double.parseDouble(df2.format(temp)));
    }

    /**
     * B45：各泊位物资车次均值：本港补给各泊位首个24小时内物资车辆来往次数的均值
     * 10 * 该原始指标值/24，注：基准值取24，即平均每小时1车次补给。
     * @return
     */
    private static final int VECHILE_COUNT = 10; // 车辆数量
    private int calcB45(List<DsTaskDetail> dsTaskDetails) {
        // 按泊位、补给顺序排序
        dsTaskDetails.sort(Comparator.comparing(DsTaskDetail::getBerthId).thenComparing(DsTaskDetail::getSupplySeq));

        // 按泊位号进行分组
        Map<Long, List<DsTaskDetail>> detailMap = new HashMap<>();
        for (DsTaskDetail detail : dsTaskDetails) {
            Long berthId = detail.getBerthId();
            detailMap.computeIfAbsent(berthId, k -> new ArrayList<>()).add(detail);
        }
        Date after24Hour = null; // 首个24小时截止时间
        double allCount = 0.0;
        for (List<DsTaskDetail> groupDsTaskDetails : detailMap.values()) {
            for (int i = 0; i < groupDsTaskDetails.size(); i++) {
                DsTaskDetail detail1 = groupDsTaskDetails.get(i);
                int matStartTime = detail1.getMatStime();
                int matEndTime = detail1.getMatEtime();
                int matTime = detail1.getMatTime();
                Date t1Date = detail1.getT1();
                Date matStartDate = DateUtils.getDateAfterHours(t1Date, matStartTime);
                Date matEndDate = DateUtils.getDateAfterHours(t1Date, matEndTime);

                if (i == 0) {
                    after24Hour = DateUtils.getDateAfterHours(t1Date, 24);
                }

                if (matStartDate.before(after24Hour) && matEndDate.before(after24Hour)) {
                    allCount += detail1.getFood() + detail1.getFoodO() + detail1.getFoodW();
                } else {
                    allCount += 0;
                }
            }
        }
        double temp = (allCount / VECHILE_COUNT / 24) > 1? 1 : (allCount / VECHILE_COUNT / 24);
        log.debug("B45 Value =====：" + (10 * Double.parseDouble(df2.format(temp))));
        return  (int) (10 * Double.parseDouble(df2.format(temp)));
    }

    /**
     * 根据用户当前所在部门，获取用户管辖下的港口泊位数量。
     * @return
     */
    private int getBerthCountOfHarbor(){
        LoginUser sysUser = getLoginUser();
        Long deptId = sysUser.getDeptId();
        DmBerth2 dmBerth2 = new DmBerth2();
        dmBerth2.setDeptId(deptId);
        List<DmBerth2> dmBerth2List = dmBerth2Service.selectDmBerthList(dmBerth2);
        return dmBerth2List.size();
    }

}