package org.dromara.eims.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.dromara.common.core.constant.DictConstants;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.utils.DateUtils;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.eims.domain.*;
import org.dromara.eims.domain.bo.EimsEquBo;
import org.dromara.eims.domain.vo.EimsInspectStVo;
import org.dromara.eims.domain.vo.EimsMaintOrderVo;
import org.dromara.eims.domain.vo.EimsRepairReqVo;
import org.dromara.eims.mapper.*;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.stream.Collectors;

@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/eims/board")
public class BoardController {
    private final EimsRepairReqMapper reqMapper;
    private final EimsRepairResMapper resMapper;
    private final EimsInspectStMapper inspStMapper;
    private final EimsInspectRecordMapper inspRecordMapper;
    private final EimsMaintStMapper maintStMapper;
    private final EimsEquStatuMapper equStatuMapper;
    private final EimsSpareMapper spareMapper;
    private final EimsEquMapper equMapper;
    private final EimsMaintOrderMapper maintOrderMapper;

    @GetMapping("/todoList")
    public  R<List<Map<String,Object>>>  todoList() {
        List<Map<String,Object>> result = new ArrayList<>();

        // 报修单-待接单
        LambdaQueryWrapper<EimsRepairReq> reqWrapper = new LambdaQueryWrapper<>();
        // 待接单
        reqWrapper.eq(EimsRepairReq::getStatus, DictConstants.REPAIR_REQ_STATUS_DETAIL.DAIJIEDAN);
        Long reqCount = reqMapper.selectCount(reqWrapper);
        Map<String,Object> reqMap = new HashMap<>();
        reqMap.put("menu","故障报修");
        reqMap.put("count",reqCount);
        result.add(reqMap);


        //维修工单-未完成
        LambdaQueryWrapper<EimsRepairRes> resWrapper = new LambdaQueryWrapper<>();
        // 未完成
        resWrapper.ne(EimsRepairRes::getStatus, DictConstants.REPAIR_RES_STATUS_DETAIL.WANCHENG);
        Long resCount = resMapper.selectCount(resWrapper);
        Map<String,Object> resMap = new HashMap<>();
        resMap.put("menu","维修任务");
        resMap.put("count",resCount);
        result.add(resMap);

        //维修工单-评价
        LambdaQueryWrapper<EimsRepairRes> evWrapper = new LambdaQueryWrapper<>();
        evWrapper.isNull(EimsRepairRes::getFbId);
        Long evCount = resMapper.selectCount(evWrapper);
        Map<String,Object> evMap = new HashMap<>();
        evMap.put("menu","维修评价");
        evMap.put("count",evCount);
        result.add(evMap);

        //点检汇总任务
        LambdaQueryWrapper<EimsInspectSt> inspStWrapper = new LambdaQueryWrapper<>();
        //未点检
        inspStWrapper.eq(EimsInspectSt::getStatus, DictConstants.EIMS_INSPECT_STATUS_DETAIL.N);
        Long inspStCount = inspStMapper.selectCount(inspStWrapper);
        Map<String,Object> inspStMap = new HashMap<>();
        inspStMap.put("menu","点检任务");
        inspStMap.put("count",inspStCount);
        result.add(inspStMap);

        //保养汇总任务
        LambdaQueryWrapper<EimsMaintSt> maintStWrapper = new LambdaQueryWrapper<>();
        //未完成工单汇总
        maintStWrapper.eq(EimsMaintSt::getStatus,DictConstants.MAINT_ORDER_ST_STATUS_DETAIL.N);
        Long maintStCount = maintStMapper.selectCount(maintStWrapper);
        Map<String,Object> maintStMap = new HashMap<>();
        maintStMap.put("menu","保养任务");
        maintStMap.put("count",maintStCount);
        result.add(maintStMap);

        //设备状态变更
        LambdaQueryWrapper<EimsEquStatu>  equStatuWrapper = new LambdaQueryWrapper<>();
        equStatuWrapper.isNotNull(EimsEquStatu::getChangeDate);
        // 获取当前日期
        LocalDate today = LocalDate.now();
        // 构造当天的 00:00:00
        LocalDateTime startOfDay = today.atStartOfDay();
        // 构造当天的 23:59:59
        LocalDateTime endOfDay = today.atTime(23, 59, 59);
        // 定义格式化模板
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 格式化输出
        String startStr = startOfDay.format(formatter);
        String endStr = endOfDay.format(formatter);
        equStatuWrapper.between(EimsEquStatu::getChangeDate,startStr,endStr);
        Long equStatuCount = equStatuMapper.selectCount(equStatuWrapper);
        Map<String,Object> equStatuMap = new HashMap<>();
        equStatuMap.put("menu","状态变更");
        equStatuMap.put("count",equStatuCount);
        result.add(equStatuMap);

        return R.ok(result);

    }


    @GetMapping("/spareWarn")
    public  R<Map<String,Object>>  spareWarn() {
        Map<String,Object> result = new HashMap<>();

        LambdaQueryWrapper<EimsSpare> spareUpWrapper = new LambdaQueryWrapper<>();
        spareUpWrapper.isNotNull(EimsSpare::getUpperStock)
            .isNotNull(EimsSpare::getActualStock)
            .gt(EimsSpare::getActualStock, 0)
            .gt(EimsSpare::getUpperStock, 0)
            .apply("actual_stock > upper_stock");
        Long upper = spareMapper.selectCount(spareUpWrapper);

        result.put("upper",upper);

        LambdaQueryWrapper<EimsSpare> spareLowWrapper = new LambdaQueryWrapper<>();
        spareLowWrapper.isNotNull(EimsSpare::getLowerStock)
            .isNotNull(EimsSpare::getActualStock)
            .gt(EimsSpare::getActualStock, 0)
            .gt(EimsSpare::getLowerStock, 0)
            .apply("actual_stock < lower_stock");
        Long lower = spareMapper.selectCount(spareLowWrapper);
        result.put("lower",lower);

        return R.ok(result);
    }

    /**
     * 查询设备在用状态
     * @return
     */
    @GetMapping("/equStatu")
    public  R<Map<String,Integer>>  queryEquStatu() {
        List<EimsEqu> eimsEqus = equMapper.selectList();
        Map<String, Integer> result = countStatus(eimsEqus);
        return R.ok(result);
    }

    /**
     * 查询今天点检数据
     * @return
     */
    @GetMapping("/todayInsp")
    public  R<Map<String,Object>>  todayInsp() {
        Map<String, Object> result = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList<>();
        List<Map<String, Object>> sub = new ArrayList<>();

        // 初始化主数据统计项
        data.add(createDataItem("已完成", 0));
        data.add(createDataItem("未完成", 0));

        // 初始化子项统计
        sub.add(createSubItem("正常", 0));
        sub.add(createSubItem("异常", 0));
        sub.add(createSubItem("未检", 0));

        result.put("data", data);
        result.put("sub", sub);

        // 查询今日计划巡检任务
        LambdaQueryWrapper<EimsInspectSt> inspStWrapper = new LambdaQueryWrapper<>();
        inspStWrapper.eq(EimsInspectSt::getType, "Day");
        inspStWrapper.eq(EimsInspectSt::getPlanTime, DateUtils.dateTimeNow(DateUtils.YYYY_MM_DD));
        List<EimsInspectStVo> inspectStList = inspStMapper.selectVoList(inspStWrapper);

        if (inspectStList == null || inspectStList.isEmpty()) {
            return R.ok(result);
        }

        long completedCount = 0;
        List<String> stIdList = new ArrayList<>();

        for (EimsInspectStVo item : inspectStList) {
            if (DictConstants.EIMS_INSPECT_STATUS_DETAIL.Y.equals(item.getStatus())) {
                completedCount++;
            }
            stIdList.add(item.getStId());
        }

        int total = inspectStList.size();
        data.get(0).put("value", completedCount);
        data.get(1).put("value", total - completedCount);

        // 查询巡检记录
        List<EimsInspectRecord> recordList = Collections.emptyList();
        if (!stIdList.isEmpty()) {
            QueryWrapper<EimsInspectRecord> recordWrapper = new QueryWrapper<>();
            recordWrapper.in("st_id", stIdList);
            recordList = inspRecordMapper.selectList(recordWrapper);
        }

        if (recordList == null || recordList.isEmpty()) {
            return R.ok(result);
        }

        long normalCount = 0;
        long abnormalCount = 0;

        for (EimsInspectRecord record : recordList) {
            String status = record.getStatus();
            if (DictConstants.EIMS_INSPECT_RESULT_DETAIL.Y.equals(status)) {
                normalCount++;
            } else if (DictConstants.EIMS_INSPECT_RESULT_DETAIL.N.equals(status)) {
                abnormalCount++;
            }
        }

        int unCheckedCount = recordList.size() - (int) (normalCount + abnormalCount);

        sub.get(0).put("value", normalCount);
        sub.get(1).put("value", abnormalCount);
        sub.get(2).put("value", unCheckedCount);

        return R.ok(result);

    }


    @GetMapping("/monthReq")
    public  R<Map<String,Object>>  monthReq() {
        Map<String,Object> result = new HashMap<>();
        List<Map<String, Object>> statusList = new ArrayList<>();
        LocalDate today = LocalDate.now();
        LambdaQueryWrapper<EimsRepairReq> queryWrapper = new LambdaQueryWrapper<EimsRepairReq>()
            .between(EimsRepairReq::getOccTime,
                today.with(TemporalAdjusters.firstDayOfMonth()),
                today.with(TemporalAdjusters.lastDayOfMonth()));
        List<EimsRepairReqVo> reqList = reqMapper.selectVoList(queryWrapper);
        long todayCount = reqList.stream()
            .filter(r -> r.getReqTime() != null &&
                r.getReqTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate().isEqual(LocalDate.now()))
            .count();
        if (reqList != null && !reqList.isEmpty()) {
            // 假设 reqList 已经从数据库查询出来，并且不为空
            Map<String, Long> statusCountMap = reqList.stream()
                .collect(Collectors.groupingBy(
                    item -> {
                        switch (item.getStatus()) {
                            case "0": return "待接单";
                            case "1": return "已接单";
                            case "2": return "维修中";
                            case "3": return "已完成";
                            default: return "未知状态";
                        }
                    },
                    Collectors.counting()
                ));

            // 按固定顺序排序生成 List<Map<String, Object>>

            statusList.add(Map.of("name", "待接单",  "value", statusCountMap.getOrDefault("待接单", 0L)));
            statusList.add(Map.of("name", "已接单",  "value", statusCountMap.getOrDefault("已接单", 0L)));
            statusList.add(Map.of("name", "维修中",  "value", statusCountMap.getOrDefault("维修中", 0L)));
            statusList.add(Map.of("name", "已完成",  "value", statusCountMap.getOrDefault("已完成", 0L)));
        }
        result.put("data",statusList);
        result.put("today",todayCount);
      return  R.ok(result);

    }

    @GetMapping("/monthMainit")
    public  R<Map<String,Object>>  monthMainit() {
        Map<String,Object> result = new HashMap<>();
        List<Map<String, Object>> statusList = new ArrayList<>();
        LocalDate today = LocalDate.now();
        LambdaQueryWrapper<EimsMaintOrder> queryWrapper = new LambdaQueryWrapper<EimsMaintOrder>()
            .between(EimsMaintOrder::getPlanTime,
                today.with(TemporalAdjusters.firstDayOfMonth()),
                today.with(TemporalAdjusters.lastDayOfMonth()));
        List<EimsMaintOrderVo> orderList = maintOrderMapper.selectVoList(queryWrapper);
        long todayCount = orderList.stream()
            .filter(r -> r.getPlanTime() != null &&
                r.getPlanTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate().isEqual(LocalDate.now()))
            .count();
        if (orderList != null && !orderList.isEmpty()) {

            Map<String, Long> statusCountMap = orderList.stream()
                .collect(Collectors.groupingBy(
                    item -> {
                        switch (item.getStatus()) {
                            case "0": return "待保养";
                            case "1": return "保养中";
                            case "2": return "待验证";
                            case "3": return "已完成";
                            default: return "未知状态";
                        }
                    },
                    Collectors.counting()
                ));

            // 按固定顺序排序生成 List<Map<String, Object>>

            statusList.add(Map.of("name", "待保养",  "value", statusCountMap.getOrDefault("待保养", 0L)));
            statusList.add(Map.of("name", "保养中",  "value", statusCountMap.getOrDefault("保养中", 0L)));
            statusList.add(Map.of("name", "待验证",  "value", statusCountMap.getOrDefault("待验证", 0L)));
            statusList.add(Map.of("name", "已完成",  "value", statusCountMap.getOrDefault("已完成", 0L)));
        }
        result.put("data",statusList);
        result.put("today",todayCount);
        return  R.ok(result);

    }

    // 辅助方法：创建主数据项
    private Map<String, Object> createDataItem(String name, long value) {
        Map<String, Object> item = new HashMap<>();
        item.put("name", name);
        item.put("value", value);
        return item;
    }

    // 辅助方法：创建子数据项
    private Map<String, Object> createSubItem(String name, long value) {
        Map<String, Object> item = new HashMap<>();
        item.put("name", name);
        item.put("value", value);
        return item;
    }


    /**
     * 统计各状态设备数量
      * @param eimsEqus
     * @return
     */
    public static Map<String, Integer> countStatus(List<EimsEqu> eimsEqus) {
        Map<String, Integer> statusCount = new HashMap<>();
        Map<String, String> statusMap = new HashMap<String, String>() {{
            put("0", "试用");
            put("1", "使用");
            put("2", "停用");
            put("3", "报废");
            put("4", "闲置");
            put("5", "新增");
            put("其他", "其他");
        }};

        for (EimsEqu equ : eimsEqus) {
            String status = equ.getStatus();
            status = (status == null || status.trim().isEmpty()) ? "其他" : status;
            if(statusMap.containsKey(status)){
                statusCount.put(statusMap.get(status), statusCount.getOrDefault(statusMap.get(status), 0) + 1);
            }

        }


        return statusCount;
    }

}