package com.ruoyi.system.service.impl;


import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.system.mapper.*;
import com.ruoyi.system.model.*;
import com.ruoyi.system.model.Record;
import com.ruoyi.system.query.*;
import com.ruoyi.system.service.ClientParamService;
import com.ruoyi.system.service.DeviceUsageService;
import com.ruoyi.system.service.ProjectCategoryCalculator;
import com.ruoyi.system.vo.*;
import com.ruoyi.system.vo.DeviceCountVo;
import com.ruoyi.system.vo.DeviceListVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.text.ParseException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author administrator
 * @since 2026-01-13
 */
@Slf4j
@Service
public class DeviceUsageServiceImpl extends ServiceImpl<DeviceUsageMapper, DeviceUsage> implements DeviceUsageService {

    @Autowired
    private EvalResultMapper evalResultMapper;
    @Autowired
    private ProjectMapper projectMapper;
    @Autowired
    private ClientParamMapper clientParamMapper;
    @Autowired
    private TaskMapper taskMapper;
    @Autowired
    private RecordMapper recordMapper;
    @Autowired
    private ProjectCategoryCalculator projectCategoryCalculator;

    @Override
    public List<String> getDeviceUsageList(Integer id) {
        return this.baseMapper.getDeviceUsageList(id);
    }

    @Override
    public List<DeviceListVo> getDeviceList(Page<DeviceListVo> page, DeviceListQuery query) {
        List<DeviceListVo> deviceList = this.baseMapper.getDeviceList(page, query);
        for (DeviceListVo deviceListVo : deviceList) {
            LocalDateTime checkTime = deviceListVo.getCheckTime();
            // 判断checkTime是否是本月的时间
            if (checkTime != null && YearMonth.from(checkTime).equals(YearMonth.now())) {
                deviceListVo.setCheckResult("已检查");
            } else {
                deviceListVo.setCheckResult("未检查");
            }
        }
        return deviceList;
    }

    @Override
    public List<DeviceCountVo> getProjectDeviceCount(Integer id) {
        return this.baseMapper.getProjectDeviceCount(id);
    }


    @Override
    public List<EntrustProjectVo> projectList(Page<EntrustProjectVo> page, EntrustListQuery query) {
        String startTime = query.getStartTime();
        String endTime = query.getEndTime();

        // 查询在建工程项目（usage_type 表示项目用途类型，假设 0 表示在建工程）
        LambdaQueryWrapper<Project> projectWrapper = new LambdaQueryWrapper<>();
        if (query.getClientId() != null) {
            projectWrapper.eq(Project::getClientId, query.getClientId());
        }
        if (StringUtils.hasLength(query.getName())) {
            projectWrapper.like(Project::getName, query.getName());
        }
        switch (query.getCategory()) {
            case 1:
                // 查询在建资产项目
                projectWrapper.eq(Project::getDeleted, false)
                        .ne(Project::getType, 2) // 在建工程
                        .and(wrapper -> wrapper
                                .eq(Project::getStatus, 1)  // 在建项目
                                .or(w -> w
                                        .eq(Project::getStatus, 2)  // 已完成项目
                                        .between(Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                )
                        );
                break;
            case 2:
                // 查询固定资产项目
                projectWrapper.eq(Project::getDeleted, false)
                        .eq(Project::getType, 2) // 在建工程
                        .and(wrapper -> wrapper
                                .eq(Project::getStatus, 1)  // 在建项目
                                .or(w -> w
                                        .eq(Project::getStatus, 2)  // 已完成项目
                                        .between(Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                )
                        );
                break;
        }

        List<Project> projects = projectMapper.selectList(projectWrapper);
        List<Integer> projectIds = projects.stream().map(Project::getId).collect(Collectors.toList());
        if (projectIds.isEmpty()) {
            projectIds.add(-1);
        }
        query.setProjectIds(projectIds);

        Map<Integer, String> categoryMap = calculateProjectCategoryMap(projects, query);
        // 查询检查任务
        LambdaQueryWrapper<Task> taskWrapper = new LambdaQueryWrapper<>();
        taskWrapper.in(Task::getProjectId, projectIds)
                .eq(Task::getDeleted, false);
        List<Task> taskList = taskMapper.selectList(taskWrapper);
        List<EntrustProjectVo> deviceList = this.baseMapper.projectList(page, query);
        for (EntrustProjectVo deviceListVo : deviceList) {
            deviceListVo.setRisk(formatProjectCategory(categoryMap.get(deviceListVo.getId())));
            List<Task> tasks = taskList.stream().filter(e -> e.getProjectId().equals(deviceListVo.getId())).toList();
//            List<Task> tasks = taskMap.get(deviceListVo.getId());
            if (tasks != null && !tasks.isEmpty()) {

                Task task1 = tasks.stream().filter(e -> e.getDate().getYear() == LocalDateTime.now().getYear() && e.getDate().getMonth().getValue() == LocalDateTime.now().getMonth().getValue()).findFirst().orElse(null);

//                List<Record> recordList = records.stream().filter(e -> taskIds.contains(e.getCheckTaskId())).toList();
//                Record record = recordList.stream().max(Comparator.comparing(Record::getCreateTime)).orElse(null);
                if (task1 != null && (task1.getState() == 3 || Integer.valueOf(5).equals(task1.getState()) ||
                        Integer.valueOf(6).equals(task1.getState()) || Integer.valueOf(7).equals(task1.getState()))) {
                    deviceListVo.setCheckTime(task1.getDate().atStartOfDay());
                    deviceListVo.setCheckResult("已检查");
                } else {
                    deviceListVo.setCheckTime(null);
                    deviceListVo.setCheckResult("未检查");
                    deviceListVo.setRisk(null);
                }
            } else {
                deviceListVo.setCheckTime(null);
                deviceListVo.setCheckResult("未检查");
                deviceListVo.setRisk(null);
            }
        }
        return deviceList;
    }

    private Map<Integer, String> calculateProjectCategoryMap(List<Project> projects, EntrustListQuery query) {
        if (projects.isEmpty() || query.getClientId() == null || query.getCategory() == null) {
            return Collections.emptyMap();
        }

        Date startDate = resolveProjectCategoryStartDate(query.getStartTime());
        Date endDate = resolveProjectCategoryEndDate(query.getEndTime());
        if (query.getCategory() == 1) {
            return projectCategoryCalculator.calculateOngoingProjectCategories(
                    projects, query.getClientId().longValue(), startDate, endDate
            );
        }
        if (query.getCategory() == 2) {
            return projectCategoryCalculator.calculateFixedAssetCategories(
                    projects, query.getClientId().longValue(), startDate, endDate
            );
        }
        return Collections.emptyMap();
    }

    private Date resolveProjectCategoryStartDate(String startTime) {
        if (!StringUtils.hasLength(startTime)) {
            return DateUtil.beginOfMonth(new Date());
        }
        return DateUtil.beginOfDay(DateUtil.parse(normalizeDateText(startTime)));
    }

    private Date resolveProjectCategoryEndDate(String endTime) {
        if (!StringUtils.hasLength(endTime)) {
            return DateUtil.endOfMonth(new Date());
        }
        return DateUtil.endOfDay(DateUtil.parse(normalizeDateText(endTime)));
    }

    private String normalizeDateText(String dateText) {
        return dateText.replace("年", "-")
                .replace("月", "-")
                .replace("日", "")
                .replace("/", "-")
                .trim();
    }

    private String formatProjectCategory(String category) {
        if (!StringUtils.hasLength(category)) {
            return null;
        }
        if (category.endsWith("类")) {
            return category;
        }
        return category + "类";
    }

    @Override
    public List<EntrustProjectReportVo> projectReport(Page<EntrustProjectReportVo> page, ProjectReportListQuery query) {
        List<EntrustProjectReportVo> entrustProjectReportVoList = this.baseMapper.projectReport(page, query);
        return entrustProjectReportVoList;
    }

    @Override
    public List<EntrustDeviceListVo> deviceList(Page<EntrustDeviceListVo> page, EntrustDeviceListQuery query) {
        String startTime = query.getStartTime().replace("年", "-").replace("月", "-").replace("日", "-");
        String endTime = query.getEndTime();

        // 查询在建工程项目（usage_type 表示项目用途类型，假设 0 表示在建工程）
        LambdaQueryWrapper<Project> projectWrapper = new LambdaQueryWrapper<>();
        if (query.getClientId() != null) {
            projectWrapper.eq(Project::getClientId, query.getClientId());
        }
        switch (query.getCategory()) {
            case 1:
                // 查询在建资产项目
                projectWrapper.eq(Project::getDeleted, false)
                        .ne(Project::getType, 2) // 在建工程
                        .and(wrapper -> wrapper
                                .eq(Project::getStatus, 1)  // 在建项目
                                .or(w -> w
                                        .eq(Project::getStatus, 2)  // 已完成项目
                                        .between(Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                )
                        );
                break;
            case 2:
                // 查询固定资产项目
                projectWrapper.eq(Project::getDeleted, false)
                        .eq(Project::getType, 2) // 在建工程
                        .and(wrapper -> wrapper
                                .eq(Project::getStatus, 1)  // 在建项目
                                .or(w -> w
                                        .eq(Project::getStatus, 2)  // 已完成项目
                                        .between(Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                )
                        );
                break;
        }
        List<Integer> projectIds = projectMapper.selectList(projectWrapper).stream().map(Project::getId).collect(Collectors.toList());
        query.setProjectIds(projectIds);
        List<EntrustDeviceListVo> deviceList = this.baseMapper.deviceList(page, query);
        List<Integer> deviceIds = deviceList.stream().map(EntrustDeviceListVo::getId).collect(Collectors.toList());
        if (deviceIds.isEmpty()) {
            deviceIds.add(-1);
        }
        LambdaQueryWrapper<Record> recordWrapper = new LambdaQueryWrapper<>();
        recordWrapper.eq(Record::getRecordType, "error")
                .isNotNull(Record::getDeviceId)
                .in(Record::getDeviceId, deviceIds)
                .eq(Record::getDeleted, false);
        List<Record> records = recordMapper.selectList(recordWrapper);
        List<Integer> deviceIdsRecord = records.stream().map(Record::getDeviceId).distinct().collect(Collectors.toList());

        for (EntrustDeviceListVo deviceListVo : deviceList) {
            if (deviceIdsRecord.contains(deviceListVo.getId())) {
                Record record = records.stream().filter(e -> e.getDeviceId().equals(deviceListVo.getId())).findFirst()
                        .orElse(null);
                if (record != null) {
                    Task task = taskMapper.selectById(record.getCheckTaskId());
                    if (task != null) {
                        deviceListVo.setCheckTime(task.getCreateTime());
                    }
                    deviceListVo.setCheckResult("已检查");
                }
            } else {
                deviceListVo.setCheckResult("未检查");
                deviceListVo.setCheckTime(null);

            }
//
//            LocalDateTime checkTime = deviceListVo.getCheckTime();
//            // 判断checkTime是否是本月的时间
//            if (checkTime != null && YearMonth.from(checkTime).equals(YearMonth.now())) {
//                deviceListVo.setCheckResult("已检查");
//            }else {
//                deviceListVo.setCheckResult("未检查");
//            }
        }
        return deviceList;
    }

    @Override
    public List<ErrorListVo> errorList(Page<ErrorListVo> page, ErrorListQuery query) throws ParseException {
        String startTime;
        String endTime;
        // 查询在建工程项目（usage_type 表示项目用途类型，假设 0 表示在建工程）
        if (StringUtils.hasLength(query.getStartTime())) {
            startTime = query.getStartTime().replace("年", "-").replace("月", "-").replace("日", "-");
            endTime = query.getEndTime();
        } else {
            endTime = "";
            startTime = "";
        }
        LambdaQueryWrapper<Project> projectWrapper = new LambdaQueryWrapper<>();
        if(query.getCategory()!=null) {
            switch (query.getCategory()) {
                case 1:
                    // 查询在建资产项目
                    projectWrapper.eq(Project::getDeleted, false)
                            .ne(Project::getType, 2) // 在建工程
                            .and(wrapper -> wrapper
                                    .eq(Project::getStatus, 1)  // 在建项目
                                    .or(w -> w
                                            .eq(Project::getStatus, 2)  // 已完成项目

                                            .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                    )
                            );
                    break;
                case 2:
                    // 查询固定资产项目
                    projectWrapper.eq(Project::getDeleted, false)
                            .eq(Project::getType, 2) // 在建工程
                            .and(wrapper -> wrapper
                                    .eq(Project::getStatus, 1)  // 在建项目
                                    .or(w -> w
                                            .eq(Project::getStatus, 2)  // 已完成项目
                                            .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                    )
                            );
                    break;
            }
        }
        if (query.getClientId() != null) {
            projectWrapper.eq(Project::getClientId, query.getClientId());
        }
        List<Project> projects = projectMapper.selectList(projectWrapper);
        List<Integer> projectIds = projects.stream().map(Project::getId).collect(Collectors.toList());
        if (projectIds.isEmpty()) {
            projectIds.add(-1);
        }
        // 查询检查任务
        LambdaQueryWrapper<Task> taskWrapper = new LambdaQueryWrapper<>();
        taskWrapper.in(Task::getProjectId, projectIds)
                .eq(Task::getDeleted, false);
        List<Task> tasks = taskMapper.selectList(taskWrapper);
        List<Integer> checkTaskIds = tasks.stream().map(Task::getId).collect(Collectors.toList());

        // 查询重大隐患记录（level 表示隐患等级，0 表示重大隐患）
        LambdaQueryWrapper<Record> recordWrapper = new LambdaQueryWrapper<>();
        recordWrapper.eq(Record::getDeleted, false)
                .in(Record::getCheckTaskId, checkTaskIds)
                .eq(Record::getLevel, 0); // 重大隐患等级
        List<Integer> recordIds = recordMapper.selectList(recordWrapper).stream().map(Record::getId).toList();
        query.setRecordIds(recordIds);
        List<ErrorListVo> errorList = this.baseMapper.errorList(page, query);
        return errorList;
    }

    @Override
    public List<ErrorListVo> deviceErrorList(Page<ErrorListVo> page, ErrorListQuery query) {
        String startTime;
        String endTime;
        // 查询在建工程项目（usage_type 表示项目用途类型，假设 0 表示在建工程）
        if (StringUtils.hasLength(query.getStartTime())) {
            startTime = query.getStartTime().replace("年", "-").replace("月", "-").replace("日", "-");
            endTime = query.getEndTime();
        } else {
            endTime = "";
            startTime = "";
        }
        LambdaQueryWrapper<Project> projectWrapper = new LambdaQueryWrapper<>();
        if (query.getCategory() != null) {


            switch (query.getCategory()) {
                case 1:
                    // 查询在建资产项目
                    projectWrapper.eq(Project::getDeleted, false)
                            .ne(Project::getType, 2) // 在建工程
                            .and(wrapper -> wrapper
                                    .eq(Project::getStatus, 1)  // 在建项目
                                    .or(w -> w
                                            .eq(Project::getStatus, 2)  // 已完成项目

                                            .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                    )
                            );
                    break;
                case 2:
                    // 查询固定资产项目
                    projectWrapper.eq(Project::getDeleted, false)
                            .eq(Project::getType, 2) // 在建工程
                            .and(wrapper -> wrapper
                                    .eq(Project::getStatus, 1)  // 在建项目
                                    .or(w -> w
                                            .eq(Project::getStatus, 2)  // 已完成项目
                                            .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                    )
                            );
                    break;
            }
        }
        if (query.getClientId() != null) {
            projectWrapper.eq(Project::getClientId, query.getClientId());
        }
        List<Project> projects = projectMapper.selectList(projectWrapper);
        List<Integer> projectIds = projects.stream().map(Project::getId).collect(Collectors.toList());
        if (projectIds.isEmpty()) {
            projectIds.add(-1);
        }
        // 查询检查任务
        LambdaQueryWrapper<Task> taskWrapper = new LambdaQueryWrapper<>();
        taskWrapper.in(Task::getProjectId, projectIds)
                .eq(Task::getDeleted, false);
        List<Task> tasks = taskMapper.selectList(taskWrapper);
        List<Integer> checkTaskIds = tasks.stream().map(Task::getId).collect(Collectors.toList());

        // 查询重大隐患记录（level 表示隐患等级，0 表示重大隐患）
        LambdaQueryWrapper<Record> recordWrapper = new LambdaQueryWrapper<>();
        recordWrapper.eq(Record::getDeleted, false)
                .in(Record::getCheckTaskId, checkTaskIds);
        List<Integer> recordIds = recordMapper.selectList(recordWrapper).stream().map(Record::getId).toList();
        query.setRecordIds(recordIds);
        List<ErrorListVo> errorList = this.baseMapper.deviceErrorList(page, query);
        return errorList;
    }

    @Override
    public List<ErrorListVo> safetyErrorList(Page<ErrorListVo> page, ErrorListQuery query) {
        String startTime;
        String endTime;
        // 查询在建工程项目（usage_type 表示项目用途类型，假设 0 表示在建工程）
        if (StringUtils.hasLength(query.getStartTime())) {
            startTime = query.getStartTime().replace("年", "-").replace("月", "-").replace("日", "-");
            endTime = query.getEndTime();
        } else {
            endTime = "";
            startTime = "";
        }
        LambdaQueryWrapper<Project> projectWrapper = new LambdaQueryWrapper<>();
        if(query.getCategory()!=null) {
            switch (query.getCategory()) {
                case 1:
                    // 查询在建资产项目
                    projectWrapper
//                        .eq(Project::getDeleted, false)
                            .ne(Project::getType, 2) // 在建工程
                            .and(wrapper -> wrapper
                                    .eq(Project::getStatus, 1)  // 在建项目
                                    .or(w -> w
                                            .eq(Project::getStatus, 2)  // 已完成项目
                                            .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                    )
                                    .or(w -> w
                                            .isNull(Project::getStatus)  // 已完成项目
                                            .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                    )
                            );
                    break;
                case 2:
                    // 查询固定资产项目
                    projectWrapper
//                        .eq(Project::getDeleted, false)
                            .eq(Project::getType, 2) // 在建工程
                            .and(wrapper -> wrapper
                                            .eq(Project::getStatus, 1)  // 在建项目
                                            .or(w -> w
                                                    .eq(Project::getStatus, 2)  // 已完成项目
                                                    .between(StringUtils.hasLength(startTime), Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                            )
                                            .or(w -> w
                                                            .isNull(Project::getStatus)  // 已完成项目
//                                        .between(StringUtils.hasLength(startTime),Project::getSuccessTime, startTime, endTime)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期
                                            )
                            );
                    break;
            }
        }
        if (query.getClientId() != null) {
            projectWrapper.eq(Project::getClientId, query.getClientId());
        }
        List<Project> projects = projectMapper.selectList(projectWrapper);
        List<Integer> projectIds = projects.stream().map(Project::getId).collect(Collectors.toList());
        if (projectIds.isEmpty()) {
            projectIds.add(-1);
        }
        // 查询检查任务
        LambdaQueryWrapper<Task> taskWrapper = new LambdaQueryWrapper<>();
        taskWrapper.in(Task::getProjectId, projectIds)
        ;
        List<Task> tasks = taskMapper.selectList(taskWrapper);
        List<Integer> checkTaskIds = tasks.stream().map(Task::getId).collect(Collectors.toList());

        // 查询重大隐患记录（level 表示隐患等级，0 表示重大隐患）
        LambdaQueryWrapper<Record> recordWrapper = new LambdaQueryWrapper<>();
        recordWrapper.eq(Record::getDeleted, false)
                .eq(Record::getRecordType, "error")
                .in(Record::getCheckTaskId, checkTaskIds);
        List<Integer> recordIds = recordMapper.selectList(recordWrapper).stream().map(Record::getId).toList();
        query.setRecordIds(recordIds);
        List<ErrorListVo> errorList = this.baseMapper.safetyErrorList(page, query);
        return errorList;
    }


}