package org.dromara.eims.service.impl;

import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.RequiredArgsConstructor;
import org.dromara.common.core.utils.DateUtils;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.eims.domain.*;
import org.dromara.eims.domain.vo.EimsEquVo;
import org.dromara.eims.mapper.*;
import org.dromara.eims.service.IReportService;
import org.dromara.system.mapper.SysDeptMapper;
import org.springframework.stereotype.Service;

import java.time.*;
import java.util.*;
import java.util.stream.Collectors;

@RequiredArgsConstructor
@Service
public class ReportServiceImpl implements IReportService {

    private static final String UNCHECKED = "未点检";
    private static final String PENDING_VERIFICATION = "待验证";
    private static final String COMPLETED = "已完成";
    private static final String NOT_APPLICABLE = "/";


    private static final String MAINT_0 = "待保养";
    private static final String MAINT_1 = "保养中";
    private static final String MAINT_2 = "待验证";
    private static final String MAINT_3 = "已完成";

    private final EimsInspectRecordMapper baseMapper;
    private final EimsInspectStMapper inspectStMapper;
    private final EimsInspectPlanMapper inspectPlanMapper;
    private final SysDeptMapper sysDeptMapper;
    private final EimsEquMapper equMapper;
    private final EimsMaintOrderMapper maintOrderMapper;
    private final EimsMaintPlanMapper maintPlanMapper;

    @Override
    public TableDataInfo<Map<String, Object>> queryPageListCustom(Map<String, Object> queryParams, PageQuery pageQuery) {
        LambdaQueryWrapper<EimsEqu> equWrapper = Wrappers.lambdaQuery();

        if (queryParams.containsKey("keyword")) {
            String keyword = (String) queryParams.get("keyword");
            equWrapper.and(StringUtils.isNotBlank(keyword),
                wrapper -> wrapper
                    .like(EimsEqu::getEquName, keyword)
                    .or()
                    .like(EimsEqu::getAssetNo, keyword)
            );
        }

        Page<EimsEquVo> equList = equMapper.selectVoPage(pageQuery.build(), equWrapper);
        return TableDataInfo.build(fitInspData(equList, queryParams));
    }

    @Override
    public TableDataInfo<Map<String, Object>> queryMaintList(Map<String, Object> queryParams, PageQuery pageQuery) {
        LambdaQueryWrapper<EimsEqu> equWrapper = Wrappers.lambdaQuery();

        if (queryParams.containsKey("keyword")) {
            String keyword = (String) queryParams.get("keyword");
            equWrapper.and(StringUtils.isNotBlank(keyword),
                wrapper -> wrapper
                    .like(EimsEqu::getEquName, keyword)
                    .or()
                    .like(EimsEqu::getAssetNo, keyword)
            );
        }

        Page<EimsEquVo> equList = equMapper.selectVoPage(pageQuery.build(), equWrapper);
        return TableDataInfo.build(fitMaintData(equList, queryParams));
    }

    private  Page<Map<String, Object>> fitMaintData(Page<EimsEquVo> equPageList, Map<String, Object> queryParams) {
        Integer selectYear = getYearFromParams(queryParams);
        LocalDate firstDay = Year.of(selectYear).atDay(1); // 第一天
        LocalDate lastDay = Year.of(selectYear).atDay(Year.of(selectYear).length());
        Page<Map<String, Object>> page = new Page<>(
            equPageList.getCurrent(),
            equPageList.getSize(),
            equPageList.getTotal(),
            equPageList.searchCount()
        );
        if (equPageList.getRecords().isEmpty()) {
            return page;
        }

        List<Long> equIds = equPageList.getRecords().stream()
            .map(EimsEquVo::getEquId)
            .collect(Collectors.toList());

        Map<Long, List<EimsMaintOrder>> maintOrderMap = getMaintOrderMap(equIds, firstDay, lastDay);
        Map<Long, List<EimsMaintPlan>> maintPlanMap = getMaintPlanMap(equIds,selectYear);

        List<Map<String, Object>> resultList = equPageList.getRecords().stream()
            .map(equ -> buildMaintReport(equ, maintOrderMap, maintPlanMap))
            .collect(Collectors.toList());

        page.setRecords(resultList);

        return page;
    }

    private Page<Map<String, Object>> fitInspData(Page<EimsEquVo> equPageList, Map<String, Object> queryParams) {
        YearMonth yearMonth = getYearMonthFromParams(queryParams);
        LocalDate firstDay = yearMonth.atDay(1);
        LocalDate lastDay = yearMonth.atEndOfMonth();

        Page<Map<String, Object>> page = new Page<>(
            equPageList.getCurrent(),
            equPageList.getSize(),
            equPageList.getTotal(),
            equPageList.searchCount()
        );

        if (equPageList.getRecords().isEmpty()) {
            return page;
        }

        List<Long> equIds = equPageList.getRecords().stream()
            .map(EimsEquVo::getEquId)
            .collect(Collectors.toList());

        Map<Long, List<EimsInspectSt>> inspectStMap = getInspectStMap(equIds, firstDay, lastDay);
        Map<Long, List<EimsInspectPlan>> inspectPlanMap = getInspectPlanMap(equIds, yearMonth);

        List<Map<String, Object>> resultList = equPageList.getRecords().stream()
            .map(equ -> buildEquipmentReport(equ, inspectStMap, inspectPlanMap, yearMonth))
            .collect(Collectors.toList());

        page.setRecords(resultList);
        return page;
    }

    private YearMonth getYearMonthFromParams(Map<String, Object> queryParams) {
        if (queryParams.containsKey("selectMonth")) {
            String[] parts = queryParams.get("selectMonth").toString().split("-");
            return YearMonth.of(Integer.parseInt(parts[0]), Integer.parseInt(parts[1]));
        }
        return YearMonth.now();
    }

    private Map<Long, List<EimsInspectSt>> getInspectStMap(List<Long> equIds, LocalDate firstDay, LocalDate lastDay) {
        LambdaQueryWrapper<EimsInspectSt> sWrapper = Wrappers.lambdaQuery();
        sWrapper.in(EimsInspectSt::getEquId, equIds)
            .between(EimsInspectSt::getPlanTime, firstDay, lastDay)
            .eq(EimsInspectSt::getType, "Day");

        return inspectStMapper.selectList(sWrapper).stream()
            .collect(Collectors.groupingBy(EimsInspectSt::getEquId));
    }

    private Map<Long, List<EimsInspectPlan>> getInspectPlanMap(List<Long> equIds, YearMonth yearMonth) {
        LocalDateTime firstDayTime = yearMonth.atDay(1).atStartOfDay();
        LocalDateTime lastDayTime = yearMonth.atEndOfMonth().atTime(23, 59, 59);

        LambdaQueryWrapper<EimsInspectPlan> pWrapper = Wrappers.lambdaQuery();
        pWrapper.in(EimsInspectPlan::getEquId, equIds)
            .between(EimsInspectPlan::getCreateTime, firstDayTime, lastDayTime);

        return inspectPlanMapper.selectList(pWrapper).stream()
            .collect(Collectors.groupingBy(EimsInspectPlan::getEquId));
    }

    private Map<String, Object> buildEquipmentReport(EimsEquVo equ,
                                                     Map<Long, List<EimsInspectSt>> inspectStMap,
                                                     Map<Long, List<EimsInspectPlan>> inspectPlanMap,
                                                     YearMonth yearMonth) {
        Map<String, Object> item = new HashMap<>();
        item.put("equName", equ.getEquName());
        item.put("assetNo", equ.getAssetNo());

        List<EimsInspectSt> equInspList = inspectStMap.getOrDefault(equ.getEquId(), Collections.emptyList());
        List<EimsInspectPlan> equPlanList = inspectPlanMap.getOrDefault(equ.getEquId(), Collections.emptyList());

        Map<String, EimsInspectSt> stMap = equInspList.stream()
            .collect(Collectors.toMap(
                inspSt -> String.valueOf(inspSt.getPlanTime().toInstant()
                    .atZone(ZoneId.systemDefault())
                    .toLocalDate().getDayOfMonth()),
                inspSt -> inspSt,
                (existing, replacement) -> existing
            ));

        Map<String, EimsInspectPlan> planMap = equPlanList.stream()
            .collect(Collectors.toMap(
                inspPlan -> String.valueOf(inspPlan.getCreateTime().toInstant()
                    .atZone(ZoneId.systemDefault())
                    .toLocalDate().getDayOfMonth()),
                inspPlan -> inspPlan,
                (existing, replacement) -> existing
            ));

        int daysInMonth = yearMonth.lengthOfMonth();
        for (int day = 1; day <= daysInMonth; day++) {
            String dayKey = "day_" + day;
            if (planMap.containsKey(String.valueOf(day))) {
                item.put(dayKey, UNCHECKED);
            } else if (stMap.containsKey(String.valueOf(day))) {
                EimsInspectSt st = stMap.get(String.valueOf(day));
                switch (st.getStatus()) {
                    case "0":
                        item.put(dayKey, UNCHECKED);
                        break;
                    case "1":
                        item.put(dayKey, PENDING_VERIFICATION);
                        break;
                    case "2":
                        item.put(dayKey, COMPLETED);
                        break;
                    default:
                        item.put(dayKey, NOT_APPLICABLE);
                }
            } else {
                item.put(dayKey, NOT_APPLICABLE);
            }
        }

        return item;
    }





    private Integer getYearFromParams(Map<String, Object> queryParams) {
        if (queryParams.containsKey("selectYear")) {
            String year = queryParams.get("selectYear").toString();
            return  Integer.parseInt(year);
        }
        return LocalDate.now().getYear();
    }
    private Map<Long, List<EimsMaintOrder>> getMaintOrderMap(List<Long> equIds, LocalDate firstDay, LocalDate lastDay) {
        LambdaQueryWrapper<EimsMaintOrder> sWrapper = Wrappers.lambdaQuery();
        sWrapper.in(EimsMaintOrder::getEquId, equIds)
            .between(EimsMaintOrder::getPlanTime, firstDay, lastDay);

        return maintOrderMapper.selectList(sWrapper).stream()
            .collect(Collectors.groupingBy(EimsMaintOrder::getEquId));
    }

    private Map<Long, List<EimsMaintPlan>> getMaintPlanMap(List<Long> equIds, Integer year) {
        LocalDateTime firstDay = Year.of(year).atDay(1).atStartOfDay();
        LocalDateTime lastDay = Year.of(year).atDay(Year.of(year).length())
            .atTime(23, 59, 59);

        LambdaQueryWrapper<EimsMaintPlan> pWrapper = Wrappers.lambdaQuery();
        pWrapper.in(EimsMaintPlan::getEquId, equIds)
            .between(EimsMaintPlan::getCreateTime, firstDay, lastDay);

        return maintPlanMapper.selectList(pWrapper).stream()
            .collect(Collectors.groupingBy(EimsMaintPlan::getEquId));
    }

    private Map<String, Object> buildMaintReport(EimsEquVo equ,
                                                     Map<Long, List<EimsMaintOrder>> maintOrderMap,
                                                     Map<Long, List<EimsMaintPlan>> maintPlanMap) {
        Map<String, Object> item = new HashMap<>();
        item.put("equName", equ.getEquName());
        item.put("assetNo", equ.getAssetNo());

        List<EimsMaintOrder> equMaintOrderList = maintOrderMap.getOrDefault(equ.getEquId(), Collections.emptyList());
        List<EimsMaintPlan> equMaintPlanList = maintPlanMap.getOrDefault(equ.getEquId(), Collections.emptyList());


        Map<String, String> orderMap = equMaintOrderList.stream()
            .collect(Collectors.groupingBy(
                order -> String.valueOf(order.getPlanTime().toInstant()
                    .atZone(ZoneId.systemDefault())
                    .toLocalDate().getMonthValue()),
                Collectors.collectingAndThen(
                    Collectors.toList(),
                    orders -> {
                        boolean allZero = orders.stream().allMatch(o -> o.getStatus().equals("0"));
                        if (allZero) {
                            return MAINT_0; // 待保养
                        }
                        boolean allGtOne = orders.stream().allMatch(o -> Integer.parseInt(o.getStatus()) > 1);
                        if (allGtOne) {
                            return MAINT_2; // 待验证
                        }
                        boolean allGtTwo = orders.stream().allMatch(o -> Integer.parseInt(o.getStatus()) > 2);
                        if (allGtTwo) {
                            return MAINT_3; // 已完成
                        }
                        return "保养中";
                    }
                )
            ));
        Map<String, EimsMaintPlan> planMap = equMaintPlanList.stream()
            .collect(Collectors.toMap(
                maintPlan -> String.valueOf(maintPlan.getCreateTime().toInstant()
                    .atZone(ZoneId.systemDefault())
                    .toLocalDate().getMonthValue()),
                maintPlan -> maintPlan,
                (existing, replacement) -> existing
            ));

        int monthInYear = 12;
        for (int month = 1; month <= monthInYear; month++) {
            String monthKey = "month_" + month;
            if (planMap.containsKey(String.valueOf(month))) {
                item.put(monthKey, MAINT_0);
            } else if (orderMap.containsKey(String.valueOf(month))) {
                String result  = orderMap.get(String.valueOf(month));
                item.put(monthKey, result);

            } else {
                item.put(monthKey, NOT_APPLICABLE);
            }
        }

        return item;
    }

    @Override
    public TableDataInfo<Map<String, Object>> queryEquEfficiencyList(Map<String, Object> queryParams, PageQuery pageQuery) {
        Integer selectYear = getYearFromParams(queryParams);
        String start = Year.of(selectYear).atDay(1).toString(); // yyyy-MM-dd
        String end = Year.of(selectYear).atDay(Year.of(selectYear).length()).toString();

        List<Map<String, Object>> statList = inspectStMapper.statEquEfficiency(start, end);

        // 组装统计结果
        Map<Integer, Integer> runTimes = new HashMap<>();
        Map<Integer, Integer> faultTimes = new HashMap<>();
        Map<Integer, Integer> totalTimes = new HashMap<>();
        int runTotal = 0, faultTotal = 0, totalTotal = 0;

        for (Map<String, Object> row : statList) {
            int month = Integer.parseInt(row.get("month").toString());
            int run = row.get("runTimes") == null ? 0 : Integer.parseInt(row.get("runTimes").toString());
            int fault = row.get("faultTimes") == null ? 0 : Integer.parseInt(row.get("faultTimes").toString());
            int total = run + fault;
            runTimes.put(month, run);
            faultTimes.put(month, fault);
            totalTimes.put(month, total);
            runTotal += run;
            faultTotal += fault;
            totalTotal += total;
        }

        // 组装返回数据（同前）
        String targetValue = "98.00%";
        List<Map<String, Object>> resultList = new ArrayList<>();
        Map<String, Object> row1 = new LinkedHashMap<>(); // 正常运转时间
        Map<String, Object> row2 = new LinkedHashMap<>(); // 总运转时间
        Map<String, Object> row3 = new LinkedHashMap<>(); // 故障时间
        Map<String, Object> row4 = new LinkedHashMap<>(); // 目标值
        Map<String, Object> row5 = new LinkedHashMap<>(); // 正常运转率（稼动率）

        row1.put("item", "正常运转时间");
        row2.put("item", "总运转时间");
        row3.put("item", "故障时间");
        row4.put("item", "目标值");
        row5.put("item", "正常运转率（稼动率）");

        for (int m = 1; m <= 12; m++) {
            row1.put(m + "月", runTimes.getOrDefault(m, 0));
            row2.put(m + "月", totalTimes.getOrDefault(m, 0));
            row3.put(m + "月", faultTimes.getOrDefault(m, 0));
            row4.put(m + "月", targetValue);
            int run = runTimes.getOrDefault(m, 0);
            int total = totalTimes.getOrDefault(m, 0);
            String eff = total > 0 ? String.format("%.2f%%", run * 100.0 / total) : "-";
            row5.put(m + "月", eff);
        }
        row1.put("total", runTotal);
        row2.put("total", totalTotal);
        row3.put("total", faultTotal);
        row4.put("total", targetValue);
        row5.put("total", totalTotal > 0 ? String.format("%.2f%%", runTotal * 100.0 / totalTotal) : "-");

        resultList.add(row1);
        resultList.add(row2);
        resultList.add(row3);
        resultList.add(row4);
        resultList.add(row5);

        return TableDataInfo.build(resultList);
    }
}