package com.cloudroam.service.impl;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.cloudroam.bo.meeting.MeetingDateUserDaily;
import com.cloudroam.bo.meeting.MeetingUserDaily;
import com.cloudroam.bo.ProjectDailyBO;
import com.cloudroam.bo.ProjectStatisticsBO;
import com.cloudroam.bo.businessDaily.BusinessDailyBO;
import com.cloudroam.common.LocalUser;
import com.cloudroam.common.enumeration.*;
import com.cloudroam.dto.businessDaily.BusinessDailyPageDTO;
import com.cloudroam.dto.meeting.MeetingPageDTO;
import com.cloudroam.dto.projectDaily.*;
import com.cloudroam.dto.projectDailyMain.QueryProjectDailyMainDTO;
import com.cloudroam.dto.projectTask.QueryProjectTaskHoursDTO;
import com.cloudroam.dto.projectTask.QueryTaskDailyDTO;
import com.cloudroam.mapper.ProjectDailyMapperCustom;
import com.cloudroam.model.*;
import com.cloudroam.mapper.ProjectDailyMapper;
import com.cloudroam.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.cloudroam.util.DateUtils;
import com.cloudroam.util.JsonUtil;
import com.cloudroam.vo.projectDaily.ProjectDailyBoardVO;
import com.cloudroam.vo.projectDaily.ProjectDailyHourVO;
import com.cloudroam.vo.projectDaily.ProjectDailyStatisticsVO;
import io.github.talelin.autoconfigure.exception.ForbiddenException;
import io.github.talelin.autoconfigure.exception.NotFoundException;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import javax.validation.Validator;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author generator@TaoJie
 * @since 2023-08-09
 */
@Service
public class ProjectDailyServiceImpl extends ServiceImpl<ProjectDailyMapper, ProjectDailyDO> implements ProjectDailyService {

    @Autowired
    private ProjectDailyMapper projectDailyMapper;

    @Autowired
    private ProjectDailyMapperCustom projectDailyMapperCustom;

    @Autowired
    private UserService userService;

    @Autowired
    private ProjectDailyMainService projectDailyMainService;

    @Autowired
    private ProjectDailyService projectDailyService;

    @Autowired
    private AdminService adminService;

    @Autowired
    private BusinessDailyService businessDailyService;

    @Autowired
    private LinFileReService linFileReService;

    @Autowired
    private Validator validator;  // 注入 Spring 的 Validator

    @Autowired
    private ProjectInfoService projectInfoService;

    @Autowired
    private ProjectModuleService projectModuleService;

    @Autowired
    private ProjectTaskDeveloperService projectTaskDeveloperService;

    @Autowired
    private ProjectTaskService projectTaskService;


    @Override
    @Transactional
    public boolean createProjectDaily(CreateOrUpdateProjectDailyDTO validator) {
        ProjectDailyDO projectDailyDO=new ProjectDailyDO();
        UserDO user = LocalUser.getLocalUser();

        BeanUtils.copyProperties(validator,projectDailyDO);

        projectDailyDO.setId(IdUtil.simpleUUID());

        projectDailyDO.create(String.valueOf(user.getId()),user.getNickname());

        return projectDailyMapper.insert(projectDailyDO)>0;
    }

    @Override
    public IPage<ProjectDailyBO> getProjectDailyPage(QueryProjectDailyDTO dto) {
        // -1 代表所有人
        if(dto.getCreateUserId().equals("-1")){
            dto.setCreateUserId(null);
        }

        Page<ProjectDailyBO> page=new Page<ProjectDailyBO>(dto.getPage(),dto.getCount());
//        return projectDailyMapperCustom.selectProjectDailyPage(page,dto.getKeyword()
//                ,dto.getDailyDate(),dto.getDailyType(),dto.getDailyStatus(),dto.getProjectId()
//                ,dto.getCreateUserId(),dto.getIsCommit(),dto.getIsConfirm());

        if(com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank(dto.getModuleId())){
            // 查看模块下的所有子模块
            List<ProjectModuleDO> moduleIds=projectModuleService.getChildrenModuleIds(dto.getModuleId());

            if(com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isNotEmpty(moduleIds)&&moduleIds.size()>0){
                List<String> moduleIdList=moduleIds.stream().map(ProjectModuleDO::getId).collect(Collectors.toList());
                moduleIdList.add(dto.getModuleId());
                // 查找所有模块下的id
                dto.setModuleIds(moduleIdList);
            }else{
                List<String> moduleIdList=new ArrayList<>();
                moduleIdList.add(dto.getModuleId());
                dto.setModuleIds(moduleIdList);
            }

        }
        return projectDailyMapperCustom.selectProjectDailyTaskPage(page,dto);
    }

    @Override
    @Transactional
    public boolean removeByIdLogic(String id, Date dailyDate) {
        UserDO user = LocalUser.getLocalUser();

        ProjectDailyDO projectDailyDO=new ProjectDailyDO();
        projectDailyDO.setId(id);
        projectDailyDO.setIsDeleted(DeletedEnum.DELETED_YES.getCode());
        projectDailyDO.setDeleteTime(LocalDateTime.now());
        projectDailyDO.setDeleteUserId(String.valueOf(user.getId()));
        projectDailyDO.setDeleteUserName(user.getNickname());

        // 将当天所有的日志列表都设置为未确认
        this.unCommitProjectDaily(dailyDate,String.valueOf(user.getId()));


        // 将projectDailyMain 的日志设置为未提交
        projectDailyMainService.unCommitProjectDailyMain(dailyDate,String.valueOf(user.getId()));


        return projectDailyMapper.updateById(projectDailyDO)>0;
    }

    @Override
    public List<UserDO> getAllUsers(QueryProjectDailyDTO dto) {


        // 过滤掉管理员账户
        return userService.getAllUsers(dto);

    }

    @Override
    public ProjectDailyBoardVO getProjectDailyBoardList(QueryProjectDailyBoardDTO dto) {

        // 1.根据当前登录人所在的分组，根据分组来查看看板
        UserDO userDO=LocalUser.getLocalUser();

        List<GroupDO> groupDOList=userService.getUserGroups(userDO.getId());


        // 2.获取所有分组下的人
        Set<UserDO> userDOSet=new HashSet<>();
        List<UserDO> groupUserList=new ArrayList<>();
        boolean managerFlag=false;
        for (GroupDO groupDO: groupDOList) {
            List<UserDO> groupsUserList = adminService.getGroupsUserList(groupDO.getId());
            userDOSet.addAll(groupsUserList);
            if(!managerFlag && groupDO.getName().equals(GroupLevel2Enum.MANAGER.getName())){
                managerFlag=true;
            }
        }

        List<UserDO> userList =new ArrayList<>();
        Integer rootUserId = userService.getRootUserId();

        if(Objects.equals(rootUserId,userDO.getId())||managerFlag){
            //root系统管理员或者项目经理可以查看所有用户的信息
            // 获取所有人员列表
            groupUserList=this.getAllUsers(new QueryProjectDailyDTO());
        }else{
            // 根据分组获取人员列表
            userList = new ArrayList<>(userDOSet);
            groupUserList=userList;
        }


        String startDate=dto.getStartDate();
        String endDate = dto.getEndDate();

        // 根据条件过滤，过滤掉不在不展示的人员,并且过滤掉离职日期不在查询的开始时间和结束时间之内
        groupUserList = getDutyShowBoardUserDOs(groupUserList,startDate,endDate);


        //获取开始时间和结束时间的时间范围
        List<String> dateRangeDays = DateUtils.getDateRangeDays(startDate, endDate);

        List<Map<String,String>> result=new ArrayList<>();

        Map<String,String> tmpObj=new HashMap<String,String>();

        List<UserDO> queryUserList =new ArrayList<>();
        QueryProjectDailyDTO userDto=new QueryProjectDailyDTO();
        if(StrUtil.isNotBlank(dto.getCreateUserId())){
            userDto.setCreateUserId(dto.getCreateUserId());
            queryUserList= this.getAllUsers(userDto);
        }else{
            queryUserList=groupUserList;
        }

        // 根据条件过滤，过滤掉不在不展示的人员,并且过滤掉离职日期不在查询的开始时间和结束时间之内
        queryUserList = getDutyShowBoardUserDOs(queryUserList, startDate, endDate);



        Set<String> daySet=new HashSet<>();

        for(int i=0;i<queryUserList.size();i++) {
            UserDO tmpUser=queryUserList.get(i);
            String userId=String.valueOf(tmpUser.getId());
            String username=tmpUser.getNickname();
            tmpObj.put("user_id",userId);
            tmpObj.put("user_name",username);
            String dailyContent="";
            for(int j=0;j<dateRangeDays.size();j++){
                String currentDate=dateRangeDays.get(j);
                List<ProjectDailyBO> list = projectDailyMapperCustom.selectProjectDailyList(String.valueOf(tmpUser.getId()), dateRangeDays.get(j), dto.getProjectId(), null, null);
                dailyContent = formatDateDaily(list);
                tmpObj.put(currentDate,dailyContent);
                if(null!=list&& list.size()>0){
                    daySet.add(currentDate);
                }
            }
            result.add(tmpObj);
            tmpObj=new HashMap<String,String>();
        }

        System.out.println(daySet.toString());
        // 过滤掉没有日志日期的日期数据

        List<String> dateRangeDaysNew = new ArrayList<>();
        for(String date:dateRangeDays){
            if(daySet.contains(date)){
                dateRangeDaysNew.add(date);
            }
        }



        ProjectDailyBoardVO projectDailyBoardVO=new ProjectDailyBoardVO();
        // 查询分组下的所有人的信息
        projectDailyBoardVO.setUserList(groupUserList);
        projectDailyBoardVO.setResultList(result);

//        projectDailyBoardVO.setDateList(dateRangeDays);
//        projectDailyBoardVO.setTableColumns(dateRangeDays);
        projectDailyBoardVO.setDateList(dateRangeDaysNew);
        projectDailyBoardVO.setTableColumns(dateRangeDaysNew);

        return projectDailyBoardVO;
    }

    private static List<UserDO> getDutyShowBoardUserDOs(List<UserDO> queryUserList, String startDate, String endDate) {
        List<UserDO> tmpList=new ArrayList<>();
        queryUserList.forEach(queryUser->{
            //查看用户那边是否是在看板中展示
            if(Objects.equals(queryUser.getShowBoardFlag(),UserShowBoardEnum.SHOW.getCode())){

                if(Objects.equals(queryUser.getStaffStatus(),UserStaffStatusEnum.ON_DUTY.getCode())){
                    //查看人员是否在职
                    tmpList.add(queryUser);
                }else if(Objects.equals(queryUser.getStaffStatus(),UserStaffStatusEnum.UN_DUTY.getCode())
                    && null!=queryUser.getUnhiredate()
//                    && DateUtils.isDateInRange(startDate, endDate,queryUser.getUnhiredate())
                        && DateUtils.dateCompare(queryUser.getUnhiredate(),startDate)
                ){
                    // 如果不在职，则离职之前的看板是可以展示的
                    tmpList.add(queryUser);
                }

            }
        });
        return tmpList;
    }

    @Override
    public List<ProjectDailyBO> getYesterdayUncommittedProjectDailys(String userId) {
        return projectDailyMapperCustom.getYesterdayUncommittedProjectDailys(userId);
    }

    @Override
    public List<UserDO> getTodayNoDailyPeoples() {
        return projectDailyMapperCustom.getTodayNoDailyPeoples();
    }

    @Override
    public List<ProjectDailyBO> getYesterdayUnconfirmedProjectDailys(String userId) {
        return projectDailyMapperCustom.getYesterdayUnconfirmedProjectDailys(userId);
    }

    @Override
    public List<UserDO> getYesterdayUncommittedProjectDailysPeoples() {
        return projectDailyMapperCustom.getYesterdayUncommittedProjectDailysPeoples();
    }

    @Override
    public List<UserDO> getYesterdayUncomfirmedProjectDailysPeoples() {
        return projectDailyMapperCustom.getYesterdayUncomfirmedProjectDailysPeoples();
    }

    @Override
    @Transactional
    public boolean createProjectDailyBatch(List<ProjectDailyDO> dailyDOList) {


        final UserDO user = LocalUser.getLocalUser();
        projectDailyMapperCustom.deleteDailysByDateUser(String.valueOf(user.getId()),dailyDOList.get(0).getDailyDate());



        List<ProjectDailyDO> createList=new ArrayList<>();

        for(ProjectDailyDO projectDailyDO:dailyDOList){
            ProjectDailyDO tmpProject=new ProjectDailyDO();
            BeanUtils.copyProperties(projectDailyDO,tmpProject);

            tmpProject.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
            tmpProject.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
            tmpProject.setSupplementaryFlag(SupplementaryEnum.NO.getCode());

            tmpProject.setCreateTime(LocalDateTime.now());
            tmpProject.setCreateUserId(String.valueOf(user.getId()));
            tmpProject.setCreateUserName(user.getNickname());

            tmpProject.setUpdateTime(LocalDateTime.now());
            tmpProject.setUpdateUserId(String.valueOf(user.getId()));
            tmpProject.setUpdateUserName(user.getNickname());
            tmpProject.setIsDeleted(DeletedEnum.DELETED_NO.getCode());
            if(StringUtils.isEmpty(projectDailyDO.getId())){
                tmpProject.setId(IdUtil.simpleUUID());
            }
            createList.add(tmpProject);

        }
        boolean result=false;

        if(!CollectionUtils.isEmpty(createList)){
            result=this.saveBatch(createList);
        }

        return result;

//        return projectDailyMapperCustom.insertBatch(resultList)>0;


    }

    @Override
    public List<ProjectStatisticsBO> getActualHoursStatistic(String projectId) {
        return projectDailyMapperCustom.getActualHoursStatistic(projectId);
    }


    @Override
    @Transactional
    public boolean commitBatch(CommitBatchDTO dto) {

        // 查看当前是否有当天的主要日志，如没有则创建，有则更新，并发送邮件提醒
        UserDO userDO=LocalUser.getLocalUser();

        QueryProjectDailyMainDTO mainDTO=new QueryProjectDailyMainDTO();
        mainDTO.setDailyDate(dto.getDailyDate());
        mainDTO.setUseId(String.valueOf(userDO.getId()));
        List<ProjectDailyMainDO> mainList= projectDailyMainService.getDailyMainList(mainDTO);

        ProjectDailyMainDO projectDailyMainDO=new ProjectDailyMainDO();

        // 先看这条记录是否存在，存在就提交，不存在则需要创建在提交
        if(null!=mainList && !mainList.isEmpty()){
            projectDailyMainDO=mainList.get(0);
        }else {
            projectDailyMainDO=new ProjectDailyMainDO();
            projectDailyMainDO.setDailyDate(DateUtils.stringToLocalDateTime(dto.getDailyDate()));
            projectDailyMainDO.setUseId(String.valueOf(userDO.getId()));
            projectDailyMainDO.setUserName(userDO.getNickname());

            //
            projectDailyMainDO.setCreateTime(new Date());
            projectDailyMainDO.setCreateUserId(String.valueOf(userDO.getId()));
            projectDailyMainDO.setCreateUserName(userDO.getNickname());
            projectDailyMainDO.setIsDeleted(DeletedEnum.DELETED_NO.getCode());

        }

        //提交设置
        projectDailyMainDO.setIsCommit(DailyCommitEnum.COMMITED.getCode());
        projectDailyMainDO.setCommitTime(LocalDateTime.now());
        projectDailyMainDO.setCommitUserId(String.valueOf(userDO.getId()));
        projectDailyMainDO.setCommitUserName(userDO.getNickname());


        projectDailyMainDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
        projectDailyMainDO.setConfirmTime(LocalDateTime.now());
        projectDailyMainDO.setConfirmUserId(String.valueOf(userDO.getId()));
        projectDailyMainDO.setConfirmUserName(userDO.getNickname());
        projectDailyMainDO.setConfirmContent("");



        projectDailyMainDO.setUpdateTime(new Date());
        projectDailyMainDO.setUpdateUserId(String.valueOf(userDO.getId()));
        projectDailyMainDO.setUpdateUserName(userDO.getNickname());


        if(StrUtil.isBlank(projectDailyMainDO.getId())){
            //创建
            projectDailyMainDO.setId(IdUtil.simpleUUID());
            projectDailyMainService.save(projectDailyMainDO);
        }else{
            // 更新
            projectDailyMainService.updateById(projectDailyMainDO);
        }

        // 批量更新单条日志表
        QueryWrapper<ProjectDailyDO> dailyWrapper = new QueryWrapper<>();
        dailyWrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
        dailyWrapper.eq("daily_date",dto.getDailyDate());
        dailyWrapper.eq("create_user_id",String.valueOf(userDO.getId()));

        ProjectDailyDO projectDailyDO=new ProjectDailyDO();
        projectDailyDO.setIsCommit(DailyCommitEnum.COMMITED.getCode());
        projectDailyDO.setCommitTime(new Date());
        projectDailyDO.setCommitUserId(String.valueOf(userDO.getId()));
        projectDailyDO.setCommitUserName(userDO.getNickname());

        // 将确认标志设置为未确认
        projectDailyDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
        projectDailyDO.setConfirmTime(new Date());
        projectDailyDO.setConfirmUserId(String.valueOf(userDO.getId()));
        projectDailyDO.setConfirmUserName(userDO.getNickname());
        projectDailyDO.setConfirmContent("");



        return projectDailyMapperCustom.update(projectDailyDO,dailyWrapper)>0;
    }

    @Override
    public List<ProjectDailyDO> getProjectDailyList(QueryProjectDailyDTO dto) {
        UserDO userDO = LocalUser.getLocalUser();
//        QueryWrapper<ProjectDailyDO> wrapper = new QueryWrapper<>();
//        wrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
//        if(StrUtil.isNotBlank(dto.getCreateUserId())){
//            wrapper.eq("create_user_id",dto.getCreateUserId());
//        }
//        wrapper.eq(StringUtils.isEmpty(dto.getDailyDate())
//
//        wrapper.eq("daily_date",dto.getDailyDate());
//        if(null!=dto.getIsCommit()){
//            wrapper.eq("is_commit",dto.getIsCommit());
//        }
//
//        if(null!=dto.getIsConfirm()){
//            wrapper.eq("is_confirm",dto.getIsConfirm());
//        }

        LambdaQueryWrapper<ProjectDailyDO> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(ProjectDailyDO::getIsDeleted, DeletedEnum.DELETED_NO.getCode())
                .eq(StrUtil.isNotBlank(dto.getCreateUserId()), ProjectDailyDO::getCreateUserId, dto.getCreateUserId())
                .eq(StrUtil.isNotBlank(dto.getDailyDate()), ProjectDailyDO::getDailyDate, dto.getDailyDate())
                .eq(null != dto.getIsCommit(), ProjectDailyDO::getIsCommit, dto.getIsCommit())
                .eq(null != dto.getIsConfirm(), ProjectDailyDO::getIsConfirm, dto.getIsConfirm())
                .eq(StrUtil.isNotBlank(dto.getTaskId()), ProjectDailyDO::getTaskId, dto.getTaskId())
                .orderByAsc(ProjectDailyDO::getDailyDate, ProjectDailyDO::getCreateUserId)
        ;

        return baseMapper.selectList(lambdaQueryWrapper);
    }

    @Override
    public boolean confirmBatch(ConfirmBatchDTO dto) {
        UserDO userDO=LocalUser.getLocalUser();

        QueryProjectDailyDTO queryDailyDO=new QueryProjectDailyDTO();
//        queryDailyDO.setIsCommit(DailyCommitEnum.COMMITED.getCode());
        queryDailyDO.setDailyDate(dto.getDailyDate());
        queryDailyDO.setCreateUserId(dto.getCreateUserId());
        if("-1".equals(queryDailyDO.getCreateUserId())){
            queryDailyDO.setCreateUserId(null);
        }else{
            queryDailyDO.setCreateUserId(dto.getCreateUserId());
        }


        List<ProjectDailyDO> projectDailyList = getProjectDailyList(queryDailyDO);
        if(null!=projectDailyList && !projectDailyList.isEmpty()){
            // 如果当前有记录的话，则批量确认，并且更新queryDailyMain表中的内容

            QueryWrapper<ProjectDailyDO> dailyWrapper = new QueryWrapper<>();
            dailyWrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
            dailyWrapper.eq("daily_date",dto.getDailyDate());
            if(!"-1".equals(dto.getCreateUserId())){
                dailyWrapper.eq("create_user_id",dto.getCreateUserId());
            }



//            dailyWrapper.eq("is_commit",DailyCommitEnum.COMMITED.getCode());


            ProjectDailyDO projectDailyDO=new ProjectDailyDO();
            projectDailyDO.setIsConfirm(dto.getIsConfirm());
            projectDailyDO.setConfirmTime(new Date());
            projectDailyDO.setConfirmUserId(String.valueOf(userDO.getId()));
            projectDailyDO.setConfirmUserName(userDO.getNickname());
            projectDailyDO.setConfirmContent(dto.getConfirmContent());

            //如果是不通过的情况下，设置成提交状态为未提交
            if(Objects.equals(projectDailyDO.getIsConfirm(), DailyConfirmEnum.UNPASS.getCode())){
                projectDailyDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
                projectDailyDO.setCommitTime(new Date());
                projectDailyDO.setCommitUserId(String.valueOf(userDO.getId()));
                projectDailyDO.setCommitUserName(userDO.getNickname());

            }


            baseMapper.update(projectDailyDO,dailyWrapper);

            return projectDailyMainService.confirmProjectDailyMain(dto.getDailyDate(),dto.getCreateUserId(),dto.getIsConfirm(),dto.getConfirmContent());

        }

        return false;

    }

    @Override
    public boolean unConfirmBatch(ConfirmBatchDTO dto) {
        UserDO userDO=LocalUser.getLocalUser();


        QueryProjectDailyDTO projectDailyDTO=new QueryProjectDailyDTO();
        projectDailyDTO.setDailyDate(dto.getDailyDate());
        projectDailyDTO.setIsConfirm(DailyConfirmEnum.CONFIRM.getCode());
        List<ProjectDailyDO> projectDailyList = getProjectDailyList(projectDailyDTO);
        if(null!=projectDailyList && !projectDailyList.isEmpty()){
            // 如果当前有记录的话，则批量确认，并且更新queryDailyMain表中的内容

            QueryWrapper<ProjectDailyDO> dailyWrapper = new QueryWrapper<>();
            dailyWrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
            dailyWrapper.eq("daily_date",dto.getDailyDate());
            if(!"-1".equals(dto.getCreateUserId())){
                dailyWrapper.eq("create_user_id",dto.getCreateUserId());
            }

//            dailyWrapper.eq("is_commit",DailyCommitEnum.COMMITED.getCode());
            dailyWrapper.eq("is_confirm",DailyConfirmEnum.CONFIRM.getCode());


            ProjectDailyDO projectDailyDO=new ProjectDailyDO();
            projectDailyDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
            projectDailyDO.setCommitTime(new Date());
            projectDailyDO.setCommitUserId(String.valueOf(userDO.getId()));
            projectDailyDO.setCommitUserName(userDO.getNickname());

            projectDailyDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
            projectDailyDO.setConfirmTime(new Date());
            projectDailyDO.setConfirmUserId(String.valueOf(userDO.getId()));
            projectDailyDO.setConfirmUserName(userDO.getNickname());




            baseMapper.update(projectDailyDO,dailyWrapper);

            return projectDailyMainService.unConfirmProjectDailyMain(dto.getDailyDate(),dto.getCreateUserId());

        }

        return false;
    }

    @Override
    @Transactional
    public boolean unCommitProjectDaily(Date dailyDate, String createUserId) {

        UserDO userDO = LocalUser.getLocalUser();

        // 将queryMain 的记录设置成已经提交
        ProjectDailyDO projectDailyDO=new ProjectDailyDO();

        QueryWrapper<ProjectDailyDO> dailyMainWrapper = new QueryWrapper<ProjectDailyDO>();
        dailyMainWrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
        dailyMainWrapper.eq("daily_date",dailyDate);
        dailyMainWrapper.eq("create_user_id",createUserId);

        projectDailyDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
        projectDailyDO.setCommitTime(new Date());
        projectDailyDO.setCommitUserId(String.valueOf(userDO.getId()));
        projectDailyDO.setCommitUserName(userDO.getNickname());

        projectDailyDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
        projectDailyDO.setConfirmTime(new Date());
        projectDailyDO.setConfirmUserId(String.valueOf(userDO.getId()));
        projectDailyDO.setConfirmUserName(userDO.getNickname());
        return baseMapper.update(projectDailyDO,dailyMainWrapper)>0;
    }

    @Override
    public List<UserDO> getToadyUncomfirmedActualHoursProjectDailysPeoples(String dailyDate) {


        return projectDailyMapperCustom.getToadyUncomfirmedActualHoursProjectDailysPeoples(dailyDate);
    }

    @Override
    public List<ProjectDailyBO> getTodayUnConfirmedActualHours(String createUserId, String todayString) {

        return projectDailyMapperCustom.getTodayUnConfirmedActualHours(createUserId,todayString);

    }

    @Override
    public boolean supplementaryProjectDailyBatch(List<ProjectDailyDO> list) {
        UserDO user = LocalUser.getLocalUser();

        List<ProjectDailyDO> resultList=new ArrayList<>();

        for(ProjectDailyDO projectDailyDO:list){
            ProjectDailyDO tmpProject=new ProjectDailyDO();
            BeanUtils.copyProperties(projectDailyDO,tmpProject);

            tmpProject.setDailyDate(DateUtils.formatDateToDateYYYYMMDD(projectDailyDO.getDailyDate()));

            tmpProject.setId(IdUtil.simpleUUID());

            tmpProject.setIsCommit(DailyCommitEnum.COMMITED.getCode());
            tmpProject.setIsConfirm(DailyConfirmEnum.CONFIRM.getCode());
            tmpProject.setSupplementaryFlag(SupplementaryEnum.YES.getCode());


            tmpProject.setCreateTime(LocalDateTime.now());
            tmpProject.setCreateUserId(String.valueOf(user.getId()));
            tmpProject.setCreateUserName(user.getNickname());

            tmpProject.setUpdateTime(LocalDateTime.now());
            tmpProject.setUpdateUserId(String.valueOf(user.getId()));
            tmpProject.setUpdateUserName(user.getNickname());
            tmpProject.setIsDeleted(DeletedEnum.DELETED_NO.getCode());
            resultList.add(tmpProject);

        }

        return projectDailyMapperCustom.insertBatch(resultList)>0;
    }

    @Transactional
    @Override
    public boolean createProjectDailyWithInit(CreateOrUpdateProjectDailyDTO validator) {
        UserDO user=LocalUser.getLocalUser();
        // 将当天所有的日志列表都设置为未确认
        projectDailyService.unCommitProjectDaily(validator.getDailyDate(),String.valueOf(user.getId()));

        // 将projectDailyMain 的日志设置为未提交
        projectDailyMainService.unCommitProjectDailyMain(validator.getDailyDate(),String.valueOf(user.getId()));


        return createProjectDaily(validator);
    }

    @Override
    @Transactional
    public boolean updateProjectDailyWithValidator(CreateOrUpdateProjectDailyDTO validator) {
        UserDO user = LocalUser.getLocalUser();

        ProjectDailyDO projectDailyDO=new ProjectDailyDO();
        BeanUtils.copyProperties(validator,projectDailyDO);
        projectDailyDO.setUpdateTime(LocalDateTime.now());
        projectDailyDO.setUpdateUserId(String.valueOf(user.getId()));
        projectDailyDO.setUpdateUserName(user.getNickname());

        //设置提交状态为未提交
        projectDailyDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());

        return projectDailyService.updateById(projectDailyDO);

    }

    @Override
    @Transactional
    public boolean updateProjectDailyWithInit(CreateOrUpdateProjectDailyDTO validator) {

        UserDO user = LocalUser.getLocalUser();


        boolean res = projectDailyService.updateProjectDailyWithValidator(validator);


        // 将当天所有的日志列表都设置为未确认
        projectDailyService.unCommitProjectDaily(validator.getDailyDate(),String.valueOf(user.getId()));

        // 将projectDailyMain 的日志设置为未提交
        projectDailyMainService.unCommitProjectDailyMain(validator.getDailyDate(),String.valueOf(user.getId()));

        return res;

    }

    @Override
    @Transactional
    public boolean createProjectDailyBatchWithInit(CreateBatchDTO dto) {

        UserDO userDO=LocalUser.getLocalUser();

        // 将json串反序列化成数组
        List<ProjectDailyDO> list= JsonUtil.json2List(dto.getDailyList(),ProjectDailyDO.class);

        list.forEach(tmp->{
            Date dailyDate = tmp.getDailyDate();
            tmp.setDailyDate(DateUtils.formatDateToDateYYYYMMDD(dailyDate));

        });

        // 查看当天是否有Main的记录，如果没有的情况下则新建
        QueryProjectDailyMainDTO mainDTO=new QueryProjectDailyMainDTO();
        mainDTO.setDailyDate(DateUtil.format(list.get(0).getDailyDate(), "yyyy-MM-dd"));
        mainDTO.setUseId(String.valueOf(userDO.getId()));
        final List<ProjectDailyMainDO> dailyMainList = projectDailyMainService.getDailyMainList(mainDTO);
        if(CollectionUtils.isEmpty(dailyMainList)){
            projectDailyMainService.createDailyMainDefault(mainDTO);
        }

        boolean res=projectDailyService.createProjectDailyBatch(list);

        ProjectDailyDO projectDailyDO = list.get(0);

        // 将当天所有的日志列表都设置为未确认
        projectDailyService.unCommitProjectDaily(projectDailyDO.getDailyDate(),String.valueOf(userDO.getId()));

        // 将projectDailyMain 的日志设置为未提交
        projectDailyMainService.unCommitProjectDailyMain(projectDailyDO.getDailyDate(),String.valueOf(userDO.getId()));

        return res;
    }


    @Override
    @Transactional
    public boolean updateActualHours(CreateOrUpdateProjectDailyDTO validator) {
        UserDO user = LocalUser.getLocalUser();

        ProjectDailyDO projectDailyDO=new ProjectDailyDO();
        projectDailyDO.setId(validator.getId());
        projectDailyDO.setDailyStatus(validator.getDailyStatus());
        projectDailyDO.setActualHours(validator.getActualHours());
        projectDailyDO.setRemark(validator.getRemark());

        projectDailyDO.setUpdateTime(LocalDateTime.now());
        projectDailyDO.setUpdateUserId(String.valueOf(user.getId()));
        projectDailyDO.setUpdateUserName(user.getNickname());

        //设置提交状态为未提交
//        projectDailyDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());

        return projectDailyService.updateById(projectDailyDO);
    }

    @Override
    public List<UserDO> getUnComfirmedPeoples(String dailyDate) {

        return projectDailyMapperCustom.getUnComfirmedPeoples(dailyDate);
    }

    @Override
    public List<ProjectDailyDO> getUncommitDailyList(ConfirmBatchDTO dto) {
        QueryProjectDailyDTO projectDailyDTO=new QueryProjectDailyDTO();
        BeanUtils.copyProperties(dto,projectDailyDTO);

        QueryWrapper<ProjectDailyDO> wrapper=new QueryWrapper<>();
        wrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
        wrapper.eq("daily_date",dto.getDailyDate());
        wrapper.eq("is_commit",DailyCommitEnum.UNCOMMITED.getCode());

        // 约定，如果create_user_id=-1的情况下，则全部更新
        if(!"-1".equals(dto.getCreateUserId())&&StrUtil.isNotBlank(dto.getCreateUserId())){
            wrapper.eq("create_user_id",dto.getCreateUserId());
        }

        return baseMapper.selectList(wrapper);
    }

    @Override
    public List<ProjectDailyDO> getWaitConfirmDailyList(ConfirmBatchDTO dto) {

        // 已提交，未确认的才需要确认
        QueryWrapper<ProjectDailyDO> wrapper=new QueryWrapper<>();
        wrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
        wrapper.eq("daily_date",dto.getDailyDate());
        wrapper.eq("is_commit",DailyCommitEnum.COMMITED.getCode());

        wrapper.eq("is_confirm",DailyConfirmEnum.UNCONFIRM.getCode());


        // 约定，如果create_user_id=-1的情况下，则全部更新
        if(!"-1".equals(dto.getCreateUserId())&&StrUtil.isNotBlank(dto.getCreateUserId())){
            wrapper.eq("create_user_id",dto.getCreateUserId());
        }

        return baseMapper.selectList(wrapper);
    }

    @Override
    public List<UserDO> getTodayUncommittedProjectDailysPeoples() {
        return projectDailyMapperCustom.getTodayUncommittedProjectDailysPeoples();
    }

    @Override
    public List<ProjectDailyBO> getTodayUncommittedProjectDailys(String createUserId) {
        return projectDailyMapperCustom.getTodayUncommittedProjectDailys(createUserId);
    }

    @Override
    @Transactional
    public boolean commit(String id) {
        UserDO user = LocalUser.getLocalUser();

        ProjectDailyDO projectDailyDO=new ProjectDailyDO();
        projectDailyDO.setId(id);
        projectDailyDO.setIsCommit(DailyCommitEnum.COMMITED.getCode());
        projectDailyDO.setCommitTime(new Date());
        projectDailyDO.setCommitUserId(String.valueOf(user.getId()));
        projectDailyDO.setCommitUserName(user.getNickname());

        // 将确认标志设置为未确认
        projectDailyDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());

        boolean result=this.baseMapper.updateById(projectDailyDO)>0;

        // 查看今日日志是否都已经提交，如果是的话，需要将总的main的日志设置为提交

        ProjectDailyDO projectDailyDO1 = this.baseMapper.selectById(id);

        QueryWrapper<ProjectDailyDO> wrapper=new QueryWrapper<>();
        wrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
        wrapper.eq("daily_date",projectDailyDO1.getDailyDate());
        wrapper.eq("create_user_id",projectDailyDO1.getCreateUserId());
        wrapper.eq("is_commit",DailyCommitEnum.UNCOMMITED.getCode());


        List<ProjectDailyDO> projectDailyDOS = this.baseMapper.selectList(wrapper);
        if(projectDailyDOS==null || projectDailyDOS.size()==0){
            QueryProjectDailyDTO queryProjectDailyDTO=new QueryProjectDailyDTO();
            queryProjectDailyDTO.setDailyDate(DateUtils.dateToStr(projectDailyDO1.getDailyDate()));
            queryProjectDailyDTO.setCreateUserId(projectDailyDO1.getCreateUserId());
            projectDailyMainService.commit(queryProjectDailyDTO);
        }

        return result;
    }

    @Override
    public Double getDailyDatePlanTime(WorkTimeDTO dto) {
        UserDO userDO=LocalUser.getLocalUser();
        if(StrUtil.isBlank(dto.getDailyDate())){
            dto.setDailyDate(DateUtils.getTodayString());
        }
        if(StrUtil.isBlank(dto.getCreateUserId())){
            dto.setCreateUserId(String.valueOf(userDO.getId()));
        }

        return projectDailyMapperCustom.getDailyDatePlanTime(dto.getDailyDate(),dto.getCreateUserId());
    }

    @Override
    public Double getDailyDateActualTime(WorkTimeDTO dto) {
        UserDO userDO=LocalUser.getLocalUser();
        if(StrUtil.isBlank(dto.getDailyDate())){
            dto.setDailyDate(DateUtils.getTodayString());
        }
        if(StrUtil.isBlank(dto.getCreateUserId())){
            dto.setCreateUserId(String.valueOf(userDO.getId()));
        }
        return projectDailyMapperCustom.getDailyDateActualTime(dto.getDailyDate(),dto.getCreateUserId());
    }

    @Override
    public ProjectDailyHourVO existsHours(DailyHourDTO dto) {
        UserDO userDO=LocalUser.getLocalUser();
        List<String> idList=new ArrayList<>();
        if(!StringUtils.isEmpty(dto.getIds())){
            String[] idsArray = dto.getIds().split(",");
            idList = Arrays.asList(idsArray);
        }
        return projectDailyMapperCustom.existsHoursWithoutIds(String.valueOf(userDO.getId()),dto.getDailyDate(),idList);
    }

    @Override
    public List<ProjectDailyDO> getByDailyDate(String dailyDate) {
        UserDO user = LocalUser.getLocalUser();

        QueryWrapper<ProjectDailyDO> wrapper=new QueryWrapper<>();
        wrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
        wrapper.eq("daily_date",dailyDate);
        wrapper.eq("create_user_id",user.getId());

        List<ProjectDailyDO> projectDailyDOS = this.baseMapper.selectList(wrapper);

        return projectDailyDOS;


    }

    @Override
    @Transactional
    public boolean updateActualHoursBatch(List<ActualHourProjectDailyDTO> dtoList) {

        final List<ProjectDailyDO> actualHourList = dtoList.stream().map(actualHourDto -> {
            ProjectDailyDO projectDailyDO = new ProjectDailyDO();
            projectDailyDO.setId(actualHourDto.getId());
            projectDailyDO.setDailyStatus(actualHourDto.getDailyStatus());
            projectDailyDO.setActualHours(actualHourDto.getActualHours());
            projectDailyDO.setRemark(actualHourDto.getRemark());
            return projectDailyDO;
        }).collect(Collectors.toList());
        return this.updateBatchById(actualHourList);
    }

    @Override
    public List<ProjectDailyStatisticsVO> getActualHourStatistics(QueryProjectHourStatisticsDTO dto) {
        return projectDailyMapperCustom.getActualHourStatistics(dto);
    }

    @Override
    public List<ProjectDailyStatisticsVO> getEvaluateiActualHourStatistics(QueryProjectHourStatisticsDTO dto) {

        return projectDailyMapperCustom.getEvaluateiActualHourStatistics(dto);
    }

    @Override
    public List<ProjectDailyStatisticsVO> getUserActualHourStatistics(QueryProjectHourStatisticsDTO dto) {
        return projectDailyMapperCustom.getUserActualHourStatistics(dto);
    }

    @Override
    public List<ProjectDailyStatisticsVO> getRoleHourStatistics(QueryProjectHourStatisticsDTO dto) {
        return projectDailyMapperCustom.getRoleHourStatistics(dto);
    }

    @Override
    public List<MeetingUserDaily> getProjectDailybyUserList(MeetingPageDTO dto) {

        //
//        final List<String> userIds = dto.getUserIds();

        // 提取所有开发的项目日志
        final List<String> userIds = getDeveloperIds();

        final List<MeetingUserDaily> meettingUserDailyList = userIds.stream().map(userId -> {
            // 获取上一周的且昨日进度状态为null的日志，并根据日期排序

            QueryProjectDailyDTO queryProjectDailyDTO = new QueryProjectDailyDTO();
            queryProjectDailyDTO.setDailyDate(dto.getMeetingDate());
            queryProjectDailyDTO.setCreateUserId(userId);
            queryProjectDailyDTO.setMeetingId(dto.getMeetingId());
            List<ProjectDailyBO> projectDailyBOList = projectDailyMapperCustom.selectProjectDailyProcessList(queryProjectDailyDTO);
            MeetingUserDaily meetingUserDaily = new MeetingUserDaily();
            final UserDO user = userService.getUserById(userId);
            meetingUserDaily.setUserId(String.valueOf(user.getId()));
            meetingUserDaily.setName(user.getNickname());
            meetingUserDaily.setProjectDailyBOList(projectDailyBOList);


            return meetingUserDaily;
        }).collect(Collectors.toList());

        return meettingUserDailyList;
    }

    @Override
    public List<BusinessDailyBO> getProjectBusinessDailybyMeetingId(MeetingPageDTO dto) {
        if(StringUtils.isEmpty(dto.getMeetingId())){
            return null;
        }
        BusinessDailyPageDTO businessDailyPageDTO=new BusinessDailyPageDTO();
        businessDailyPageDTO.setPage(0);
        businessDailyPageDTO.setCount(1000);
        businessDailyPageDTO.setMeetingId(dto.getMeetingId());

        List<BusinessDailyBO> result=businessDailyService.getBusinessDailyPage(businessDailyPageDTO).getRecords();

        result.stream().forEach(businessDailyBO -> {

            // 获取甘特图文件
            List<FileDO> fileList=linFileReService.getFileByReIdType(businessDailyBO.getId(),FileReTypeEnum.BUSINESS_GANTT);
            businessDailyBO.setGanteImgList(linFileReService.transFileToFileImageInfo(fileList));
        });

        return result;
    }

    @Override
    public List<MeetingUserDaily> getProjectDailyMeetingbyUserList(MeetingPageDTO dto) {
        // 提取所有开发的项目日志
        final List<String> userIds = getDeveloperIds();

        final List<MeetingUserDaily> meettingUserDailyList = userIds.stream().map(userId -> {
            // 获取上一周的且昨日进度状态为null的日志，并根据日期排序

            QueryProjectDailyDTO queryProjectDailyDTO = new QueryProjectDailyDTO();
            queryProjectDailyDTO.setDailyDate(dto.getMeetingDate());
            queryProjectDailyDTO.setCreateUserId(userId);
            queryProjectDailyDTO.setMeetingId(dto.getMeetingId());
            List<ProjectDailyBO> projectDailyBOList = projectDailyMapperCustom.selectProjectDailyProcessWithMeetingIdList(queryProjectDailyDTO);
            MeetingUserDaily meetingUserDaily = new MeetingUserDaily();
            final UserDO user = userService.getUserById(userId);
            meetingUserDaily.setUserId(String.valueOf(user.getId()));
            meetingUserDaily.setName(user.getNickname());
            meetingUserDaily.setProjectDailyBOList(projectDailyBOList);

            return meetingUserDaily;
        }).collect(Collectors.toList());

        return meettingUserDailyList;
    }

    private List<String> getDeveloperIds() {
        IPage<UserDO> managerUserPage = adminService.getUserPageByGroupId(GroupLevel2Enum.DEVELOPER.getValue(), 1000, 0);

        final List<String> userIds = managerUserPage.getRecords().stream().map(user -> String.valueOf(user.getId())).collect(Collectors.toList());
        return userIds;
    }

    @Override
    public List<MeetingDateUserDaily> getDateDailyList(MeetingPageDTO dto) {
        // 遍历查询日期下的开发人员的日志
        if(!CollectionUtils.isEmpty(dto.getDailyDateList())){
            final List<MeetingDateUserDaily> list = dto.getDailyDateList().stream().map(date -> {
                // 获取所有开发人员信息
                final List<String> userIds = getDeveloperIds();
                final List<MeetingUserDaily> userDailyList = userIds.stream().map(userId -> {
                    QueryProjectDailyDTO queryProjectDailyDTO = new QueryProjectDailyDTO();
                    queryProjectDailyDTO.setDailyDate(date);
                    queryProjectDailyDTO.setCreateUserId(userId);
                    List<ProjectDailyBO> projectDailyBOList = projectDailyMapperCustom.selectProjectDailyProcessWithMeetingIdList(queryProjectDailyDTO);

                    // 组装日期下的用户信息
                    MeetingUserDaily meetingUserDaily = new MeetingUserDaily();
                    final UserDO user = userService.getUserById(userId);
                    meetingUserDaily.setUserId(String.valueOf(user.getId()));
                    meetingUserDaily.setName(user.getNickname());
                    meetingUserDaily.setProjectDailyBOList(projectDailyBOList);

                    return meetingUserDaily;

                }).collect(Collectors.toList());

                MeetingDateUserDaily meetingDateUserDaily = new MeetingDateUserDaily();
                meetingDateUserDaily.setDate(date);
                meetingDateUserDaily.setUsersDailyList(userDailyList);

                return meetingDateUserDaily;

            }).collect(Collectors.toList());
            return list;

        }else{
            return null;
        }

    }

    @Override
    public List<String> getDailyDateByMeetingId(MeetingPageDTO dto) {
        return projectDailyMapperCustom.getDailyDateByMeetingId(dto);
    }

    @Transactional
    @Override
    public void createProjectDailyBatchWithTask(CreateBatchTaskDTO validator) {

        UserDO curUser = LocalUser.getLocalUser();

        validator.getDailyList().stream().forEach(this::validateTask);

        List<ProjectDailyMainDO> mainDOList=new ArrayList<>();
        List<ProjectDailyDO> projectDailyDOSList=new ArrayList<>();
        List<ProjectTaskDeveloperDO> projectTaskDeveloperDOList=new ArrayList<>();



        validator.getDailyList().stream().forEach(createBatchTaskDTO -> {

            // 查找用户信息
            UserDO user = userService.getUserById(createBatchTaskDTO.getUserId());

            // 查找项目信息
            if(!StringUtils.isEmpty(createBatchTaskDTO.getProjectId())){
                ProjectInfoDO projectInfoDO = projectInfoService.getById(createBatchTaskDTO.getProjectId());
                if(null!=projectInfoDO && !StringUtils.isEmpty(projectInfoDO.getProjectName())){
                    createBatchTaskDTO.setProjectName(projectInfoDO.getProjectName());
                }
            }

            // 查找模块信息
            if(!StringUtils.isEmpty(createBatchTaskDTO.getModuleId())){
                ProjectModuleDO projectModuleDO = projectModuleService.getById(createBatchTaskDTO.getModuleId());
                if(null!=projectModuleDO && !StringUtils.isEmpty(projectModuleDO.getModuleName())){
                    createBatchTaskDTO.setModuleName(projectModuleDO.getModuleName());
                }
            }

            // 查看当前日期是否已经存在 main
            ProjectDailyMainDO projectDailyMainByDate = projectDailyMainService.getProjectDailyMainByDate(createBatchTaskDTO);
            if(null!=projectDailyMainByDate && projectDailyMainByDate.getIsCommit()==DailyCommitEnum.COMMITED.getCode()){
                throw new ForbiddenException(20006);
            }

            if(!projectDailyMainService.existsProjectDailyMainByDate(createBatchTaskDTO)){
                // 当前projectDailyMain 不存在，需要创建
                ProjectDailyMainDO projectDailyMainDO=new ProjectDailyMainDO();
                projectDailyMainDO.setId(UUID.randomUUID().toString().replace("-", ""));
                LocalDateTime dailyDateLocalTimeTime = createBatchTaskDTO.getDailyDate().toInstant()
                        .atZone(ZoneId.systemDefault())
                        .toLocalDateTime();
                projectDailyMainDO.setDailyDate(dailyDateLocalTimeTime);
                projectDailyMainDO.setUseId(String.valueOf(user.getId()));
                projectDailyMainDO.setUserName(user.getNickname());

                projectDailyMainDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
                projectDailyMainDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());

                projectDailyMainDO.create(String.valueOf(user.getId()), user.getNickname());

                projectDailyMainService.save(projectDailyMainDO);
//                mainDOList.add(projectDailyMainDO);

            }

            // 日志信息
            ProjectDailyDO projectDailyDO=new ProjectDailyDO();
            BeanUtils.copyProperties(createBatchTaskDTO,projectDailyDO);
            projectDailyDO.create(String.valueOf(user.getId()), user.getNickname());
            projectDailyDO.setId(IdUtil.simpleUUID());
            //  查看当前开发当天是否已经安排过日志
            if(projectDailyService.existsProjectDaily(createBatchTaskDTO.getTaskId(),user.getId(),createBatchTaskDTO.getDailyDate())){
                throw new ForbiddenException(20001);
            }
            System.out.println(projectDailyDO.getId());
            projectDailyService.save(projectDailyDO);

//            projectDailyDOSList.add(projectDailyDO);

            // 开发信息
            if(!projectTaskDeveloperService.existsProjectTaskDeveloperByTaskId(createBatchTaskDTO)) {
                ProjectTaskDeveloperDO projectTaskDeveloperDO = new ProjectTaskDeveloperDO();
                projectTaskDeveloperDO.setId(UUID.randomUUID().toString().replace("-", ""));
                projectTaskDeveloperDO.setTaskId(createBatchTaskDTO.getTaskId());
                projectTaskDeveloperDO.setDeveloperId(createBatchTaskDTO.getUserId());
                projectTaskDeveloperDO.setDeveloperName(user.getNickname());
                // 日志的状态为未完成
                projectTaskDeveloperDO.setDeveloperTaskStatus(ProjectTaskStatusEnum.FN.getCode());
                projectTaskDeveloperDO.create(String.valueOf(curUser.getId()), curUser.getNickname());
                projectTaskDeveloperService.save(projectTaskDeveloperDO);
//                projectTaskDeveloperDOList.add(projectTaskDeveloperDO);
            }

        });

        // 批量入库
        // 日志-主
//        if(!CollectionUtils.isEmpty(mainDOList))
//            projectDailyMainService.saveOrUpdateBatch(mainDOList);
//        // 日志-详
//        if(!CollectionUtils.isEmpty(projectDailyDOSList))
//            projectDailyService.saveOrUpdateBatch(projectDailyDOSList);
////        // 日志-开发
//        if(!CollectionUtils.isEmpty(projectTaskDeveloperDOList))
//            projectTaskDeveloperService.saveOrUpdateBatch(projectTaskDeveloperDOList);

        // 查看当前任务的排配的总体时间是否大于任务的计划时间
        projectDailyService.checkProjectDailyTaskPlanHours(validator.getDailyList().get(0).getTaskId());

        // 更新任务为已排配
        ProjectTaskDO projectTaskDO=new ProjectTaskDO();
        projectTaskDO.setId(validator.getDailyList().get(0).getTaskId());
        projectTaskDO.setAssignStatus(ProjectTaskAssignStatusEnum.AY.getCode());
        projectTaskService.updateById(projectTaskDO);

    }

    @Override
    public QueryTaskDailyDTO getProjectDailyTaskInfo(String taskId, String userId) {

        List<QueryTaskDailyDTO> list = projectDailyMapperCustom.getProjectDailyTaskInfo(taskId,userId);

        if(!CollectionUtils.isEmpty(list)){
            return list.get(0);
        }
        return null;
    }

    @Override
    public int getProjectTaskDailyUnCommited(String taskId, String userId) {

        LambdaQueryWrapper<ProjectDailyDO> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper
                .eq(ProjectDailyDO::getIsDeleted,DeletedEnum.DELETED_NO.getCode())
                .eq(ProjectDailyDO::getTaskId,taskId)
                .eq(ProjectDailyDO::getCreateUserId,userId)
                .eq(ProjectDailyDO::getIsCommit,DailyCommitEnum.UNCOMMITED.getCode());
        return baseMapper.selectCount(queryWrapper);
    }
    @Override
    public boolean existsProjectDaily(String taskId, Integer userId, Date dailyDate) {
        LambdaQueryWrapper<ProjectDailyDO> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper
                .eq(ProjectDailyDO::getIsDeleted,DeletedEnum.DELETED_NO.getCode())
                .eq(ProjectDailyDO::getTaskId,taskId)
                .eq(ProjectDailyDO::getCreateUserId,userId)
                .eq(ProjectDailyDO::getDailyDate,dailyDate);
        return baseMapper.selectCount(queryWrapper)>0;
    }

    @Override
    public void checkProjectDailyTaskPlanHours(String taskId) {

        ProjectTaskDO projectTaskDO = projectTaskService.getById(taskId);
        if(Objects.isNull(projectTaskDO)){
            throw new NotFoundException("任务信息不存在！");
        }

        LambdaQueryWrapper<ProjectDailyDO> queryWrapper=new LambdaQueryWrapper<>();
        queryWrapper
                .eq(ProjectDailyDO::getIsDeleted,DeletedEnum.DELETED_NO.getCode())
                .eq(ProjectDailyDO::getTaskId,taskId);

        List<ProjectDailyDO> projectDailyDOS = baseMapper.selectList(queryWrapper);
        // 遍历projectDailyDOS 相加plan_hour
        BigDecimal totalPlanHour = projectDailyDOS.stream()
                .map(ProjectDailyDO::getEstimatedHours)   // 获取 BigDecimal 类型的 plan_hour
                .reduce(BigDecimal.ZERO, BigDecimal::add);  // 求和

        // 检查排配时间是否大于计划时间
        if(projectTaskDO.getPlanHour().compareTo(totalPlanHour)<0){
            throw new ForbiddenException(20002);
        }

    }

    @Override
    public QueryProjectTaskHoursDTO getCommitedActualHoursStatisticByTaskId(String taskId) {
        List<QueryProjectTaskHoursDTO> statisticByTaskId = projectDailyMapper.getCommitedActualHoursStatisticByTaskId(taskId);
        if(!CollectionUtils.isEmpty(statisticByTaskId)){
            return statisticByTaskId.get(0);
        }
        return null;
    }

    public void validateTask(CreateWithTaskDTO task) {
        // 手动调用验证
        Set<ConstraintViolation<CreateWithTaskDTO>> violations = validator.validate(task);

        // 如果有验证错误
        if (!violations.isEmpty()) {
            StringBuilder errorMessage = new StringBuilder("批量任务保存失败： ");
            for (ConstraintViolation<CreateWithTaskDTO> violation : violations) {
                errorMessage.append(violation.getMessage()).append(", ");
            }
            throw new ConstraintViolationException(errorMessage.toString(),violations);
        }
    }


    private String formatDateDaily(List<ProjectDailyBO> list){

        String dailyTemplate="%d、【%s】 %s ( 计划：%.2f H , 实际：%.2f H , 状态：%s ,备注：%s ) ";
        String dailyTemplate2="<span style='background-color:yellow'> %d、【%s】 %s ( 计划：%.2f H , 实际：%.2f H , 状态：%s ,备注：%s ) </span> ";
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<list.size();i++){
            ProjectDailyBO daily=list.get(i);
            String singleDailyStr ="";

            if(Objects.equals(daily.getSupplementaryFlag(),SupplementaryEnum.YES.getCode())){
                singleDailyStr = String.format(dailyTemplate2,(i+1),
                        Objects.toString(daily.getProjectName2(), ""),
                        daily.getDailyContent(),
                        Objects.isNull(daily.getEstimatedHours())? BigDecimal.ZERO :daily.getEstimatedHours(),
                        Objects.isNull(daily.getActualHours())?BigDecimal.ZERO:daily.getActualHours(),
                        daily.getDailyStatusName(),
                        StringUtils.isEmpty(daily.getRemark())?"":daily.getRemark());
            }else{
                singleDailyStr = String.format(dailyTemplate,(i+1),
                        Objects.toString(daily.getProjectName2(), ""),
                        daily.getDailyContent(),
                        Objects.isNull(daily.getEstimatedHours())?BigDecimal.ZERO:daily.getEstimatedHours(),
                        Objects.isNull(daily.getActualHours())?BigDecimal.ZERO:daily.getActualHours(),
                        daily.getDailyStatusName(),
                        StringUtils.isEmpty(daily.getRemark())?"":daily.getRemark());
            }
            if(Objects.equals(daily.getIsConfirm(),DailyConfirmEnum.CONFIRM.getCode())){
                singleDailyStr +="   √";
            }

            sb.append(singleDailyStr+"\n");
        }
        return sb.toString();
    }


}