package com.ruoyi.personnel.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.deepoove.poi.XWPFTemplate;
import com.deepoove.poi.config.Configure;
import com.ruoyi.common.core.domain.entity.User;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.framework.exception.ErrorException;
import com.ruoyi.framework.util.HackLoopTableRenderPolicy;
import com.ruoyi.performance.mapper.AuxiliaryWorkingHoursDayMapper;
import com.ruoyi.performance.mapper.PerformanceShiftMapper;
import com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay;
import com.ruoyi.performance.pojo.PerformanceShift;
import com.ruoyi.performance.service.AuxiliaryWorkingHoursDayService;
import com.ruoyi.personnel.dto.PersonTrainingRecordDto;
import com.ruoyi.personnel.dto.PersonTrainingRecordListDto;
import com.ruoyi.personnel.dto.TrainingRecordPersonDetailedDto;
import com.ruoyi.personnel.mapper.*;
import com.ruoyi.personnel.pojo.*;
import com.ruoyi.personnel.service.PersonTrainingDetailedService;
import com.ruoyi.personnel.service.PersonTrainingRecordService;
import com.ruoyi.system.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.temporal.TemporalField;
import java.time.temporal.WeekFields;
import java.util.*;

/**
 * <p>
 * 培训记录 服务实现类
 * </p>
 *
 * @author 芯导软件（江苏）有限公司
 * @since 2024-10-12 04:50:48
 */
@Transactional(rollbackFor = Exception.class)
@Service
public class PersonTrainingRecordServiceImpl extends ServiceImpl<PersonTrainingRecordMapper, PersonTrainingRecord> implements PersonTrainingRecordService {

    @Resource
    private UserMapper userMapper;

    @Resource
    private PersonTrainingDetailedService personTrainingDetailedService;

    @Resource
    private PersonTrainingDetailedMapper personTrainingDetailedMapper;

    @Resource
    private AuxiliaryWorkingHoursDayMapper auxiliaryWorkingHoursDayMapper;

    @Resource
    private PerformanceShiftMapper shiftMapper;

    @Autowired
    private AuxiliaryWorkingHoursDayService auxiliaryWorkingHoursDayService;


    @Override
    public List<PersonTrainingRecordDto> trainingAndAssessmentRecordsPage(Integer trainingDetailedId, String userName) {
        return baseMapper.trainingAndAssessmentRecordsPage(trainingDetailedId, userName);
    }

    @Override
    public void deleteTrainingAndAssessmentRecords(String ids) {
        String[] split = ids.split(",");
        if (split.length > 0) {
            for (String s : split) {
                baseMapper.deleteById(s);
            }
        }
    }

    @Override
    public IPage<PersonTrainingRecordListDto> personnelTrainingPersonnel(Page page, String userName, Integer userId, Integer departLimsId) {
        return baseMapper.personnelTrainingPersonnel(page, userName, userId, departLimsId);
    }

    @Override
    public IPage<TrainingRecordPersonDetailedDto> queryPersonnelDetails(Page page, Integer userId) {
        return baseMapper.queryPersonnelDetails(page, userId);
    }

    @Override
    public void claimOfTrainingAndAssessmentRecords(Boolean claimAndClaim, Integer courseId) {
        int userId = SecurityUtils.getUserId().intValue();
        // 1、查询培训课程，取培训日期与开始日期，与当前时间比较，判断是否超出，如果超出不允许认领
        Boolean doesItExceedState = doesItExceed(courseId);
        if (!doesItExceedState) {
            throw new ErrorException("当前课程状态无法认领！");
        }
        // 2、判断是否重复
        PersonTrainingRecord personTrainingRecord1 = baseMapper.selectOne(Wrappers.<PersonTrainingRecord>lambdaQuery()
                .eq(PersonTrainingRecord::getCourseId, courseId)
                .eq(PersonTrainingRecord::getUserId, userId));
        if (ObjectUtils.isNotEmpty(personTrainingRecord1)) {
            throw new ErrorException("请勿重复认领！");
        }
        // 3、如果未重复新增培训记录
        // true 认领
        if (claimAndClaim) {
            PersonTrainingRecord personTrainingRecord = new PersonTrainingRecord();
            personTrainingRecord.setUserId(userId);
            personTrainingRecord.setCourseId(courseId);
            baseMapper.insert(personTrainingRecord);
        // 取消认领
        } else {
            baseMapper.delete(Wrappers.<PersonTrainingRecord>lambdaQuery()
                    .eq(PersonTrainingRecord::getUserId, userId)
                    .eq(PersonTrainingRecord::getCourseId, courseId));
        }
    }

    /**
     * 导出人员培训记录
     * @param userId
     * @param response
     */
    @Override
    public void exportTrainingRecord(Integer userId, HttpServletResponse response) {
        // 查询人员人信息
        PersonTrainingRecordListDto trainingRecordListDto = baseMapper.selectUserTraining(userId);

        // 查询培训记录
        List<TrainingRecordPersonDetailedDto> personDetailedDtos = baseMapper.selectPersonDetailedDtos(userId);


        // 获取路径
        InputStream inputStream = this.getClass().getResourceAsStream("/static/training-record.docx");
        Configure configure = Configure.builder()
                .bind("personnelDetailsLisat", new HackLoopTableRenderPolicy())
                .build();
        XWPFTemplate template = XWPFTemplate.compile(inputStream, configure).render(
                new HashMap<String, Object>() {{
                    put("traning", trainingRecordListDto);
                    put("personnelDetailsLisat", personDetailedDtos);
                }});
        try {
            response.setContentType("application/msword");
            String fileName = URLEncoder.encode(
                    "人员培训记录导出", "UTF-8");
            response.setHeader("Content-disposition",
                    "attachment;filename=" + fileName + ".docx");
            OutputStream os = response.getOutputStream();
            template.write(os);
            os.flush();
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("导出失败");
        }


    }

    @Override
    public IPage<TrainingRecordPersonDetailedDto> queryPersonnelDetailsOfUserIdAndYear(Page page, Integer userId, Integer year) {
        return baseMapper.queryPersonnelDetailsOfUserIdAndYear(page, userId, year);
    }

    @Override
    public void exportTrainingRecordAddTrainingDate(Integer userId, Integer trainingDate, HttpServletResponse response) {
        // 查询人员人信息
        PersonTrainingRecordListDto trainingRecordListDto = baseMapper.selectUserTraining(userId);

        // 查询培训记录
        List<TrainingRecordPersonDetailedDto> personDetailedDtos = baseMapper.selectPersonDetailedDtosByTrainingDate(userId, trainingDate);


        // 获取路径
        InputStream inputStream = this.getClass().getResourceAsStream("/static/training-record.docx");
        Configure configure = Configure.builder()
                .bind("personnelDetailsLisat", new HackLoopTableRenderPolicy())
                .build();
        XWPFTemplate template = XWPFTemplate.compile(inputStream, configure).render(
                new HashMap<String, Object>() {{
                    put("traning", trainingRecordListDto);
                    put("personnelDetailsLisat", personDetailedDtos);
                }});
        try {
            response.setContentType("application/msword");
            String fileName = URLEncoder.encode(
                    "人员培训记录导出", "UTF-8");
            response.setHeader("Content-disposition",
                    "attachment;filename=" + fileName + ".docx");
            OutputStream os = response.getOutputStream();
            template.write(os);
            os.flush();
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("导出失败");
        }
    }

    @Override
    public void outOfFocusPreservation(PersonTrainingRecord personTrainingRecord) {
        int userId = SecurityUtils.getUserId().intValue();
        // 培训通过了，培训课时计入到当天的辅助工时 (辅助工时 以及 核准工时都添加)
        baseMapper.updateById(personTrainingRecord);
        PersonTrainingDetailed personTrainingDetailed = personTrainingDetailedMapper.selectById(personTrainingRecord.getCourseId());
        if(Objects.nonNull(personTrainingDetailed)) {
            Double classHour = personTrainingDetailed.getClassHour(); // 课时
            String trainingDateTwo = personTrainingDetailed.getTrainingDateTwo(); // 培训日期
            if(StringUtils.isEmpty(trainingDateTwo)) {
                throw new ErrorException("没有设置培训日期无法添加辅助工时");
            }
            // 是否以及添加过了
            List<AuxiliaryWorkingHoursDay> auxiliaryWorkingHoursDays = auxiliaryWorkingHoursDayMapper.selectList(new LambdaQueryWrapper<AuxiliaryWorkingHoursDay>()
                    .eq(AuxiliaryWorkingHoursDay::getNameUser, personTrainingRecord.getUserId())
                    .eq(AuxiliaryWorkingHoursDay::getAuxiliaryProject, personTrainingDetailed.getTrainingContent())
                    .eq(AuxiliaryWorkingHoursDay::getCreateUser, userId)
                    .eq(AuxiliaryWorkingHoursDay::getDateTime, trainingDateTwo + " 00:00:00"));
            // 如果有数据 合格就不做处理   不合格就删除
            if(CollectionUtils.isNotEmpty(auxiliaryWorkingHoursDays)) {
                if(personTrainingRecord.getExaminationResults().equals("不合格")) {
                    auxiliaryWorkingHoursDayMapper.delete(new LambdaQueryWrapper<AuxiliaryWorkingHoursDay>()
                            .eq(AuxiliaryWorkingHoursDay::getNameUser, personTrainingRecord.getUserId())
                            .eq(AuxiliaryWorkingHoursDay::getAuxiliaryProject, personTrainingDetailed.getTrainingContent())
                            .eq(AuxiliaryWorkingHoursDay::getCreateUser, userId)
                            .eq(AuxiliaryWorkingHoursDay::getDateTime, trainingDateTwo + " 00:00:00"));
                }
            }
            // 是否通过
            if(personTrainingRecord.getExaminationResults().equals("合格") && CollectionUtils.isEmpty(auxiliaryWorkingHoursDays)) {
                // 如果是检测办的人就不用加
                User user = userMapper.selectById(personTrainingRecord.getUserId());
                if(user.getDepartLimsId().contains("22")) {
                    return;
                }
                // 一节课45分钟 工时60分钟
                BigDecimal minute = BigDecimal.valueOf(classHour).multiply(new BigDecimal("45")); // 具体分钟
                BigDecimal divide = minute.divide(new BigDecimal("60"),4, RoundingMode.HALF_UP); // 工时
                // 添加数据
                AuxiliaryWorkingHoursDay a = new AuxiliaryWorkingHoursDay();
                a.setNameUser(personTrainingRecord.getUserId()); // 姓名id
                // 项目名称
                a.setRemarks(personTrainingDetailed.getTrainingContent()); //  辅助说明
                a.setNumber("401"); // 编号
                AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay = auxiliaryWorkingHoursDayService.selectAuxiliaryWorkingHoursByNumber("401");
                a.setAuxiliaryProject(auxiliaryWorkingHoursDay.getAuxiliaryProject()); // 辅助项目名称
                a.setNonproductiveTime(Double.parseDouble(divide.toString())); // 辅助工时
                a.setApprovedWorkingHour(auxiliaryWorkingHoursDay.getApprovedWorkingHour()); // 核准工时
                a.setAmount(Double.parseDouble(divide.toString())); // 数量
                String year = trainingDateTwo.split("-")[0];
                a.setYear(year); // 年
                a.setCreateTime(LocalDateTime.now());
                a.setUpdateTime(LocalDateTime.now());
                a.setCreateUser(userId); // 创建人id
                a.setUpdateUser(userId); // 修改人id
                a.setState("已提交"); // 状态
                a.setDateTime(trainingDateTwo + " 00:00:00"); // 日期
                // 获取当前日期
                LocalDate today = LocalDate.now();
                // 获取当前日期的周次（一年中的第几周）
                TemporalField weekOfYear = WeekFields.of(Locale.getDefault()).weekOfYear();
                int weekNumber = today.get(weekOfYear);
                // 获取当前日期的星期（一周中的第几天）
                DayOfWeek dayOfWeek = today.getDayOfWeek();
                int dayOfWeekNumber = dayOfWeek.getValue();
                LocalDate now = LocalDate.now();
                LocalTime parse = LocalTime.parse("00:00:00");
                LocalDateTime of = LocalDateTime.of(now, parse);
                PerformanceShift performanceShift = shiftMapper.selectOne(new LambdaQueryWrapper<PerformanceShift>().eq(PerformanceShift::getWorkTime, of)
                        .eq(PerformanceShift::getUserId, personTrainingRecord.getUserId()));
                if(Objects.nonNull(performanceShift)) {
                    a.setShift(performanceShift.getShift()); // 班次
                }
                a.setWeek(weekNumber+""); // 周次
                a.setWeekDay(dayOfWeekNumber == 7 ? 0+"" : dayOfWeekNumber+""); // 星期
                auxiliaryWorkingHoursDayMapper.insert(a);
            }
        }

    }

    /**
     * 检验该培训课程是否允许认领
     * @param courseId 该课程的id
     * @return
     */
    public Boolean doesItExceed(Integer courseId) {
        PersonTrainingDetailed personTrainingDetailed = personTrainingDetailedService.getById(courseId);
        // 只有状态为3可以认领
        if (!personTrainingDetailed.getState().equals(3)) {
            return false;
        }
        SimpleDateFormat sdfWithoutTime = new SimpleDateFormat("yyyy-MM-dd");
        if(Objects.isNull(personTrainingDetailed.getTrainingDateTwo()) || StringUtils.isEmpty(personTrainingDetailed.getTrainingDateTwo())) {
            throw  new ErrorException("未配置培训日期,无法报名");
        }
        LocalDate parse = LocalDate.parse(personTrainingDetailed.getTrainingDateTwo());
        Date from = Date.from(parse.atStartOfDay(ZoneId.systemDefault()).toInstant());
        String originalDateStr = sdfWithoutTime.format(from);
        SimpleDateFormat sdfWithTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            if(Objects.isNull(personTrainingDetailed.getOpeningTime()) || StringUtils.isEmpty(personTrainingDetailed.getOpeningTime())) {
                throw  new ErrorException("未配置具体时间,无法报名");
            }
            // 添加时分秒后的日期
            Date addedDate = sdfWithTime.parse(originalDateStr + " " + personTrainingDetailed.getOpeningTime());
            // 获取当前时间
            Date currentDate = new Date();
            // 日期未超出当前时间。
            if (addedDate.after(currentDate) || addedDate.equals(currentDate)) {
                return true;
            // 日期已超出当前时间
            } else {
                // 如果日期超出 更新课程状态为已结束
                personTrainingDetailedService.update(Wrappers.<PersonTrainingDetailed>lambdaUpdate()
                        .eq(PersonTrainingDetailed::getId, courseId)
                        .set(PersonTrainingDetailed::getState, 2));
                return false;
            }
        } catch (Exception e) {
            throw new ErrorException("时间格式错误！");
        }
    }
}