package cn.iocoder.yudao.module.pms.service.iotprojecttask;


import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.LocalDateTimeUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.pms.controller.admin.iotattachment.vo.IotAttachmentSaveReqVO;
import cn.iocoder.yudao.module.pms.controller.admin.iotprojectinfo.vo.IotProjectInfoPageReqVO;
import cn.iocoder.yudao.module.pms.controller.admin.iotprojecttask.vo.IotProjectTaskPageReqVO;
import cn.iocoder.yudao.module.pms.controller.admin.iotprojecttask.vo.IotProjectTaskSaveReqVO;
import cn.iocoder.yudao.module.pms.dal.dataobject.iotattachment.IotAttachmentDO;
import cn.iocoder.yudao.module.pms.dal.dataobject.iotprojectinfo.IotProjectInfoDO;
import cn.iocoder.yudao.module.pms.dal.dataobject.iotprojecttask.IotProjectTaskDO;
import cn.iocoder.yudao.module.pms.dal.dataobject.iotrddailyreport.IotRdDailyReportDO;
import cn.iocoder.yudao.module.pms.dal.mysql.iotattachment.IotAttachmentMapper;
import cn.iocoder.yudao.module.pms.dal.mysql.iotprojectinfo.IotProjectInfoMapper;
import cn.iocoder.yudao.module.pms.dal.mysql.iotprojecttask.IotProjectTaskMapper;
import cn.iocoder.yudao.module.pms.dal.mysql.iotrddailyreport.IotRdDailyReportMapper;
import cn.iocoder.yudao.module.pms.enums.AttachmentCategoryEnum;
import cn.iocoder.yudao.module.pms.enums.AttachmentTypeEnum;
import cn.iocoder.yudao.module.pms.service.iotprojectinfo.IotProjectInfoService;
import cn.iocoder.yudao.module.system.controller.admin.dept.vo.dept.DeptListReqVO;
import cn.iocoder.yudao.module.system.dal.dataobject.dept.DeptDO;
import cn.iocoder.yudao.module.system.dal.mysql.dept.DeptMapper;
import cn.iocoder.yudao.module.system.service.dept.DeptService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertList;
import static cn.iocoder.yudao.module.pms.enums.ErrorCodeConstant.IOT_PROJECT_TASK_NOT_EXISTS;
import static cn.iocoder.yudao.module.pms.enums.ErrorCodeConstant.IOT_RD_DAILY_REPORT_EXISTS;

/**
 * 项目信息任务拆分 Service 实现类
 *
 * @author 超级管理员
 */
@Service
@Validated
public class IotProjectTaskServiceImpl implements IotProjectTaskService {

    @Resource
    private IotProjectTaskMapper iotProjectTaskMapper;
    @Resource
    private IotProjectInfoService iotProjectInfoService;

    @Resource
    private IotRdDailyReportMapper iotRdDailyReportMapper;
    @Resource
    private IotProjectInfoMapper iotProjectInfoMapper;
    @Resource
    private DeptMapper deptMapper;
    @Resource
    private IotAttachmentMapper attachmentMapper;
    @Resource
    private DeptService deptService;

    @Override
    public Long createIotProjectTask(IotProjectTaskSaveReqVO createReqVO) {
        // 插入
        IotProjectTaskDO iotProjectTask = BeanUtils.toBean(createReqVO, IotProjectTaskDO.class);
        iotProjectTaskMapper.insert(iotProjectTask);
        // 返回
        return iotProjectTask.getId();
    }

    @Override
    public Boolean createIotProjectTaskList(List<IotProjectTaskSaveReqVO> list) {
        List<IotProjectTaskDO> taskDOS = new ArrayList<>();
        // 如果是瑞都的平台井，生成uuid关联平台井多个任务
        AtomicBoolean platformWell = new AtomicBoolean(false);
        list.forEach(task -> {
            if (1 == task.getPlatformWell()) {
                platformWell.set(true);
            }
        });
        String platformGroup = StrUtil.EMPTY;
        if (platformWell.get()) {
            platformGroup = StrUtil.uuid();
        }
        for (IotProjectTaskSaveReqVO saveReqVO:list) {
            IotProjectTaskDO iotProjectTask = BeanUtils.toBean(saveReqVO, IotProjectTaskDO.class);
            iotProjectTask.setPlatformGroup(platformGroup);
            // 将项目的 deptId 赋值给 任务的 deptId
            IotProjectInfoDO project = iotProjectInfoMapper.selectById(iotProjectTask.getProjectId());
            if (ObjUtil.isNotEmpty(project)) {
                iotProjectTask.setDeptId(project.getDeptId());
            }
            // 校验任务的 施工区域 等字段的值 是否包含在已有的数据字典集合中 如果不在 则新增数据字典值
            iotProjectInfoService.saveDictData(saveReqVO.getDictType(), iotProjectTask.getLocation());
            taskDOS.add(iotProjectTask);
        }
        return iotProjectTaskMapper.insertBatch(taskDOS);
    }

    @Override
    public void updateIotProjectTask(IotProjectTaskSaveReqVO updateReqVO) {
        // 校验存在
        validateIotProjectTaskExists(updateReqVO.getId());
        // 更新
        IotProjectTaskDO updateObj = BeanUtils.toBean(updateReqVO, IotProjectTaskDO.class);
        iotProjectTaskMapper.updateById(updateObj);
    }

    @Override
    public void updateIotProjectTaskList(List<IotProjectTaskSaveReqVO> list) {
        List<IotProjectTaskDO> taskDOS = new ArrayList<>();
        // 如果是瑞都的平台井，使用已有的 platformGroup 关联平台井多个任务
        AtomicBoolean platformWell = new AtomicBoolean(false);
        AtomicReference<String> platformGroup = new AtomicReference<>(StrUtil.EMPTY);
        String uuid = StrUtil.uuid();
        // 是否是从已有的非平台井 转换成 平台井
        AtomicBoolean transferFlag = new AtomicBoolean(false);
        list.forEach(task -> {
            // 如果 设置为 平台井后 task.getPlatformGroup() 为空 说明是非平台井修改成平台井的情况
            // 此时需要 重新生成 platformGroup
            if (StrUtil.isNotBlank(task.getPlatformGroup())) {
                platformGroup.set(task.getPlatformGroup());
            }
            if (1 == task.getPlatformWell()) {
                platformWell.set(true);
                if (StrUtil.isBlank(task.getPlatformGroup())) {
                    transferFlag.set(true);
                }
            } else {
                // 可能之前设置过平台井 然后又取消 这里需要 删除主井外的关联井
                // 并清空 主井 的 platformGroup
            }
        });
        // 查询系统中已有的关联平台井 保存时入参集合中没有的平台井 需要删除掉
        List<Long> existTaskIds = new ArrayList<>();

        List<IotProjectTaskDO> tobeAddedTasks = new ArrayList<>();
        List<IotProjectTaskDO> tobeDeletedTasks = new ArrayList<>();
        List<Long> deletedTaskIds = new ArrayList<>();
        // 本次保存中包含的任务id集合
        List<Long> currentTaskIds = new ArrayList<>();
        for (IotProjectTaskSaveReqVO saveReqVO : list) {
            IotProjectTaskDO updateObj = BeanUtils.toBean(saveReqVO, IotProjectTaskDO.class);
            // 校验施工区域 下拉列表数据字典 是否包含在 已有的数据字典值集合中
            // 如果不包含 新增数据字典值
            iotProjectInfoService.saveDictData(saveReqVO.getDictType(), updateObj.getLocation());
            if (ObjUtil.isEmpty(updateObj.getId())) {
                // 新增加的任务 瑞都平台井
                if (transferFlag.get()) {
                    updateObj.setPlatformGroup(uuid);
                } else {
                    updateObj.setPlatformGroup(platformGroup.get());
                }
                tobeAddedTasks.add(updateObj);
            } else {
                // 更新现有的井任务
                if (!platformWell.get()) {
                    // 非平台井 设置 platformWell = 0 兼容 之前是平台井然后再取消选中的情况
                    updateObj.setPlatformGroup(StrUtil.EMPTY);
                }
                if (transferFlag.get()) {
                    // 非平台井 设置 platformWell = 0 兼容 之前是平台井然后再取消选中的情况
                    updateObj.setPlatformGroup(uuid);
                }
                // 瑞鹰 上传多种类型的附件
                List<IotAttachmentSaveReqVO> attachmentsSaveReqVOS = saveReqVO.getAttachments();
                List<IotAttachmentDO> attachmentDOS = new ArrayList<>();
                if (CollUtil.isNotEmpty(attachmentsSaveReqVOS)) {
                    attachmentsSaveReqVOS.forEach(att -> {
                        IotAttachmentDO attachment = new IotAttachmentDO();
                        attachment.setBizId(updateObj.getId());
                        attachment.setCategory(AttachmentCategoryEnum.DAILY_REPORT.getCode());
                        // 瑞鹰任务附件 工程设计 地质设计 完井报告
                        attachment.setType(att.getType());
                        attachment.setFilePath(att.getFilePath());
                        attachment.setFileSize(att.getFileSize());
                        attachment.setFilename(att.getFilename());
                        attachment.setFileType(att.getFileType());
                        attachment.setRemark(att.getRemark());
                        attachmentDOS.add(attachment);
                    });
                    // 先删除已有数据再新增
                    if (CollUtil.isNotEmpty(attachmentDOS)) {
                        List<String> types = Arrays.asList(AttachmentTypeEnum.CONSTRUCTION_DESIGN.getCode(),
                                AttachmentTypeEnum.GEOLOGICAL_DESIGN.getCode(), AttachmentTypeEnum.COMPLETION_REPORT.getCode());
                        LambdaQueryWrapper<IotAttachmentDO> wrapper = new LambdaQueryWrapper<>();
                        wrapper.eq(IotAttachmentDO::getCategory, AttachmentCategoryEnum.DAILY_REPORT.getCode())
                                .eq(IotAttachmentDO::getBizId, updateObj.getId())
                                .in(IotAttachmentDO::getType, types);
                        int count = attachmentMapper.delete(wrapper);
                        attachmentMapper.insertBatch(attachmentDOS);
                    }
                }
                taskDOS.add(updateObj);
            }
            if (ObjUtil.isNotEmpty(saveReqVO.getId())) {
                currentTaskIds.add(saveReqVO.getId());
            }
        }
        // 找到需要 删除 的 平台井任务
        if (StrUtil.isNotBlank(platformGroup.get())) {
            IotProjectTaskPageReqVO reqVO = new IotProjectTaskPageReqVO();
            reqVO.setPlatformGroup(platformGroup.get());
            List<IotProjectTaskDO> groupedTasks = iotProjectTaskMapper.selectList(reqVO);
            if (CollUtil.isNotEmpty(groupedTasks)) {
                groupedTasks.forEach(task -> {
                    existTaskIds.add(task.getId());
                    if (!currentTaskIds.contains(task.getId())) {
                        // 本次保存的任务中没有在已有任务集合中的需要删除
                        tobeDeletedTasks.add(task);
                        deletedTaskIds.add(task.getId());
                    }
                    if (2 == task.getPlatformWell() && !platformWell.get()) {
                        // 取消平台井设置时 主井的关联井也需要删除
                        tobeDeletedTasks.add(task);
                        deletedTaskIds.add(task.getId());
                    }
                });
            }
        }
        if (CollUtil.isNotEmpty(taskDOS)) {
            // 需要更新的任务
            iotProjectTaskMapper.updateBatch(taskDOS);
        }
        if (CollUtil.isNotEmpty(tobeAddedTasks)) {
            // 瑞都平台井 需要新增的任务
            iotProjectTaskMapper.insertBatch(tobeAddedTasks);
        }
        if (CollUtil.isNotEmpty(tobeDeletedTasks)) {
            // 本次保存的任务中没有在已有任务集合中的需要删除
            iotProjectTaskMapper.deleteByIds(deletedTaskIds);
        }
    }

    @Override
    public void deleteIotProjectTask(Long id) {
        // 校验存在
        validateIotProjectTaskExists(id);
        // 删除
        iotProjectTaskMapper.deleteById(id);
    }

    private void validateIotProjectTaskExists(Long id) {
        if (iotProjectTaskMapper.selectById(id) == null) {
            throw exception(IOT_PROJECT_TASK_NOT_EXISTS);
        }
    }

    @Override
    public IotProjectTaskDO getIotProjectTask(Long id) {
        return iotProjectTaskMapper.selectById(id);
    }

    @Override
    public PageResult<IotProjectTaskDO> getIotProjectTaskPage(IotProjectTaskPageReqVO pageReqVO) {
        return iotProjectTaskMapper.selectPage(pageReqVO);
    }

    @Override
    public List<IotProjectTaskDO> projectTasks(IotProjectTaskPageReqVO pageReqVO) {
        return iotProjectTaskMapper.selectList(pageReqVO);
    }

    @Override
    public PageResult<IotProjectTaskDO> getIotProjectTaskPage1(IotProjectTaskPageReqVO pageReqVO, Collection<Long> deptIds) {
        PageResult<IotProjectTaskDO> pagedTasks = iotProjectTaskMapper.selectPage1(pageReqVO, deptIds);

        return pagedTasks;
    }

    @Override
    public PageResult<IotProjectTaskDO> taskList(IotProjectTaskPageReqVO vo, Collection<Long> deptIds) {
        // 查询当前登录人所属部门的公司级组织 查询组织下的项目任务
        // List<DeptDO> depts = iotProjectInfoService.companyLevelDepts();
        // 兼容移动端数据权限
        Set<Long> dataPermissionTaskIds = new HashSet<>();
        // 瑞恒 查看 任务列表 设置数据权限
        Set<Long> customDeptIds = iotProjectInfoService.customLevelDepts();
        // 根据任务井号 或 施工地点 模糊搜索
        IotProjectTaskPageReqVO deptIdsReqVO = new IotProjectTaskPageReqVO();
        deptIdsReqVO.setDeptIds(customDeptIds);
        List<IotProjectTaskDO> dataPermissionTasks = iotProjectTaskMapper.selectAppList(deptIdsReqVO);
        if (CollUtil.isNotEmpty(dataPermissionTasks)) {
            dataPermissionTasks.forEach(task -> {
                dataPermissionTaskIds.add(task.getId());
            });
        }
        if (CollUtil.isEmpty(dataPermissionTaskIds)) {
            return new PageResult<>(new ArrayList<>(), 0l);
        }
        Set<Long> departmentIds = new HashSet<>();

        // 客户名称模板搜索
        Set<Long> projectIds = new HashSet<>();
        if (StrUtil.isNotBlank(vo.getManufactureName())) {
            IotProjectInfoPageReqVO reqVO = new IotProjectInfoPageReqVO();
            reqVO.setManufactureName(vo.getManufactureName());
            List<IotProjectInfoDO> matchedProjects = iotProjectInfoMapper.selectList(reqVO);
            if (CollUtil.isNotEmpty(matchedProjects)) {
                matchedProjects.forEach(project -> {
                    projectIds.add(project.getId());
                });
            } else {
                // 返回空数据
                return new PageResult<>(new ArrayList<>(), 0l);
            }
        }

        List<Long> qualifiedDeptIds = new ArrayList<>();
        // 根据部门名称 模糊搜索
        if (StrUtil.isNotBlank(vo.getDeptName())) {
            // 根据名称查询部门id
            DeptListReqVO reqVO = new DeptListReqVO();
            reqVO.setName(vo.getDeptName());
            List<DeptDO> qualifiedDepts = deptMapper.selectList(reqVO);
            qualifiedDeptIds = convertList(qualifiedDepts, DeptDO::getId);
            if (CollUtil.isEmpty(qualifiedDeptIds)) {
                return new PageResult<>(new ArrayList<>(), 0l);
            }
        }
        List<Long> qualifiedTaskIds = new ArrayList<>();
        IPage<IotProjectTaskDO> taskDOIPage = iotProjectTaskMapper.taskList(Page.of(vo.getPageNo(), vo.getPageSize()),
                vo.getCompanyId(),
                vo.getManufactureName(),
                vo.getContractName(),
                vo.getContractCode(),
                vo.getWellName(),
                vo.getCreateTime(),
                departmentIds,
                dataPermissionTaskIds,
                qualifiedDeptIds,
                projectIds,
                qualifiedTaskIds,
                vo.getPlatformFlag());
        return new PageResult<>(taskDOIPage.getRecords(), taskDOIPage.getTotal());
    }

    @Override
    public PageResult<IotProjectTaskDO> appTaskList(IotProjectTaskPageReqVO vo, Collection<Long> deptIds) {
        // 查询当前登录人所属部门的公司级组织 查询组织下的项目任务
        // List<DeptDO> depts = iotProjectInfoService.companyLevelDepts();
        // 区分当前登录人所属 部门 项目部查看项目下所有部门的数据 施工队伍查看 本队伍的任务井
        // 符合当前登录人数据权限的 任务id集合
        Set<Long> dataPermissionTaskIds = new HashSet<>();
        // 瑞恒 查看 任务列表 设置数据权限
        Set<Long> customDeptIds = iotProjectInfoService.customLevelDepts();
        // 根据任务井号 或 施工地点 模糊搜索
        IotProjectTaskPageReqVO deptIdsReqVO = new IotProjectTaskPageReqVO();
        deptIdsReqVO.setDeptIds(customDeptIds);
        List<IotProjectTaskDO> dataPermissionTasks = iotProjectTaskMapper.selectAppList(deptIdsReqVO);
        if (CollUtil.isNotEmpty(dataPermissionTasks)) {
            dataPermissionTasks.forEach(task -> {
                dataPermissionTaskIds.add(task.getId());
            });
        }
        Set<Long> departmentIds = new HashSet<>();

        // 客户名称 模板搜索
        Set<Long> projectIds = new HashSet<>();
        // 施工队伍 模糊搜索
        List<Long> qualifiedDeptIds = new ArrayList<>();
        // 根据井号 施工地点 模糊搜索 任务井数据
        List<Long> qualifiedTaskIds = new ArrayList<>();
        if (StrUtil.isNotBlank(vo.getSearchKey())) {
            IotProjectInfoPageReqVO reqVO = new IotProjectInfoPageReqVO();
            if (StrUtil.isNotBlank(vo.getSearchKey())) {
                reqVO.setManufactureName(vo.getSearchKey());
            }
            List<IotProjectInfoDO> matchedProjects = iotProjectInfoMapper.selectList(reqVO);
            if (CollUtil.isNotEmpty(matchedProjects)) {
                matchedProjects.forEach(project -> {
                    projectIds.add(project.getId());
                });
            }
            // 施工队伍 名称 模糊搜索
            // 根据名称查询部门id
            DeptListReqVO deptReqVO = new DeptListReqVO();
            deptReqVO.setName(vo.getDeptName());
            if (StrUtil.isNotBlank(vo.getDeptName())) {
                deptReqVO.setName(vo.getDeptName());
            }
            if (StrUtil.isNotBlank(vo.getSearchKey())) {
                deptReqVO.setName(vo.getSearchKey());
            }
            List<DeptDO> qualifiedDepts = deptMapper.selectList(deptReqVO);
            qualifiedDeptIds = convertList(qualifiedDepts, DeptDO::getId);

            // 根据任务井号 或 施工地点 模糊搜索
            IotProjectTaskPageReqVO wellReqVO = new IotProjectTaskPageReqVO();
            // app端暂时只查询 瑞恒 的任务列表
            Long companyId = null;
            if (customDeptIds.contains(157l)) {
                companyId = 157l;
            }
            if (customDeptIds.contains(158l)) {
                companyId = 158l;
            }
            if (customDeptIds.contains(163l)) {
                companyId = 163l;
            }
            if (ObjUtil.isNotEmpty(companyId)) {
                wellReqVO.setCompanyId(companyId);
            }
            wellReqVO.setSearchKey(vo.getSearchKey());
            List<IotProjectTaskDO> tasks = iotProjectTaskMapper.selectList(wellReqVO);
            if (CollUtil.isNotEmpty(tasks)) {
                tasks.forEach(task -> {
                    qualifiedTaskIds.add(task.getId());
                });
            }
        }
        if (CollUtil.isEmpty(projectIds) && CollUtil.isEmpty(qualifiedDeptIds) && CollUtil.isEmpty(qualifiedTaskIds)) {
            return new PageResult<>(new ArrayList<>(), 0l);
        }

        IPage<IotProjectTaskDO> taskDOIPage = iotProjectTaskMapper.taskList(Page.of(vo.getPageNo(), vo.getPageSize()),
                vo.getCompanyId(),
                vo.getManufactureName(),
                vo.getContractName(),
                vo.getContractCode(),
                vo.getWellName(),
                vo.getCreateTime(),
                departmentIds,
                dataPermissionTaskIds,
                qualifiedDeptIds,
                projectIds,
                qualifiedTaskIds,
                vo.getPlatformFlag());
        return new PageResult<>(taskDOIPage.getRecords(), taskDOIPage.getTotal());
    }

    @Override
    public List<IotProjectTaskDO> taskWellNames(IotProjectTaskPageReqVO pageReqVO) {
        List<IotProjectTaskDO> tasks = iotProjectTaskMapper.selectList(pageReqVO);
        // 井号有重名的情况 需要去重
        if (CollUtil.isNotEmpty(tasks)) {
            // 1. 以wellName为key去重，保留第一个出现的元素（推荐，符合“只显示1条”的默认需求）
            Map<String, IotProjectTaskDO> wellNameTaskMap = tasks.stream()
                    // 可选：过滤wellName为null/空字符串的元素，避免null作为key导致的异常
                    .filter(task -> task.getWellName() != null && !task.getWellName().trim().isEmpty())
                    .collect(Collectors.toMap(
                            IotProjectTaskDO::getWellName,  // Map的key：井号wellName（去重依据）
                            task -> task,                   // Map的value：任务对象本身
                            (existingTask, newTask) -> existingTask  // 重复key时：保留已存在的元素（即第一个出现的元素）
                    ));

            // 2. 将Map的value转为List，得到去重后的集合
            tasks = wellNameTaskMap.values().stream().collect(Collectors.toList());
        }
        return tasks;
    }

    @Override
    public Long generateReport(IotProjectTaskPageReqVO reqVO) {
        // 根据当前任务井id 生成对应施工队伍 指定日期的日报
        if (ObjUtil.isEmpty(reqVO.getId()) || ObjUtil.isEmpty(reqVO.getReportDate())) {
            throw exception(IOT_PROJECT_TASK_NOT_EXISTS);
        }
        IotProjectTaskDO task = iotProjectTaskMapper.selectById(reqVO.getId());
        if (ObjUtil.isEmpty(task)) {
            throw exception(IOT_PROJECT_TASK_NOT_EXISTS);
        }
        LocalDateTime reportDate = reqVO.getReportDate();
        Set<Long> deptIds = task.getDeptIds();
        if (CollUtil.isEmpty(deptIds)) {
            throw exception(IOT_PROJECT_TASK_NOT_EXISTS);
        }
        List<Long> deptIdList = new ArrayList<>(deptIds);
        Long deptId = deptIdList.get(0);

        // 查询部门信息
        DeptDO dept = deptService.getDept(deptId);
        if (ObjUtil.isEmpty(dept)) {
            throw exception(IOT_PROJECT_TASK_NOT_EXISTS);
        }
        String reportDateStr = LocalDateTimeUtil.format(reportDate, DatePattern.NORM_DATE_PATTERN);
        // 校验：指定日期 相同施工队伍 相同任务井号 只能有1份日报
        IotRdDailyReportDO existReport = iotRdDailyReportMapper.selectExistTaskReport(deptId, task.getId(), reportDateStr);
        if (ObjUtil.isNotEmpty(existReport)) {
            throw exception(IOT_RD_DAILY_REPORT_EXISTS);
        }
        // 生成指定日期、施工队伍、任务井号的日报
        IotRdDailyReportDO tobeGeneratedReport = new IotRdDailyReportDO();
        tobeGeneratedReport.setDeptId(deptId);
        tobeGeneratedReport.setReportName(dept.getName()+"/"+reportDateStr+"手工推送日报");
        tobeGeneratedReport.setProjectId(task.getProjectId());
        tobeGeneratedReport.setTaskId(task.getId());
        Set<Long> techniqueIds = new HashSet<>();
        techniqueIds.add(Long.valueOf(task.getTechnique()));
        tobeGeneratedReport.setTechniqueIds(techniqueIds);
        tobeGeneratedReport.setDeviceIds(task.getDeviceIds());
        tobeGeneratedReport.setStartTime(LocalTime.of(8, 0, 0));
        tobeGeneratedReport.setEndTime(LocalTime.of(8, 0, 0));
        tobeGeneratedReport.setStatus(0);
        tobeGeneratedReport.setAuditStatus(0);
        tobeGeneratedReport.setCreateTime(reportDate);
        Set<Long> userIds = task.getSubmitter();
        if (CollUtil.isNotEmpty(userIds)) {
            List<Long> userIdList = new ArrayList<>(userIds);
            tobeGeneratedReport.setCreator(String.valueOf(userIdList.get(0)));
        }
        LocalDateTime nextDate = reportDate.plusDays(1);
        tobeGeneratedReport.setConstructionStartDate(reportDate);
        tobeGeneratedReport.setConstructionEndDate(nextDate);
        int num = iotRdDailyReportMapper.insert(tobeGeneratedReport);
        return tobeGeneratedReport.getId();
    }

}