package com.ruoyi.performance.service.impl;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;

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.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.domain.entity.User;
import com.ruoyi.common.utils.QueryWrappers;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.framework.exception.ErrorException;
import com.ruoyi.performance.dto.AuxiliaryWorkingHoursDayDto;
import com.ruoyi.performance.dto.HoursDay;
import com.ruoyi.performance.mapper.AuxiliaryWorkingHoursDayMapper;
import com.ruoyi.performance.mapper.AuxiliaryWorkingHoursMapper;
import com.ruoyi.performance.mapper.PerformanceShiftMapper;
import com.ruoyi.performance.mapper.ShiftTimeMapper;
import com.ruoyi.performance.pojo.AuxiliaryWorkingHours;
import com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay;
import com.ruoyi.performance.pojo.PerformanceShift;
import com.ruoyi.performance.pojo.ShiftTime;
import com.ruoyi.performance.service.AuxiliaryWorkingHoursDayService;
import com.ruoyi.system.mapper.SysRoleMapper;
import com.ruoyi.system.mapper.SysUserRoleMapper;
import com.ruoyi.system.mapper.UserMapper;
import com.ruoyi.system.service.ISysDictTypeService;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.math3.analysis.function.Power;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 日工时管理的辅助工时 服务实现类
 * </p>
 *
 * @author 江苏鵷雏网络科技有限公司
 * @since 2024-05-28 02:22:19
 */
@Service
public class AuxiliaryWorkingHoursDayServiceImpl extends ServiceImpl<AuxiliaryWorkingHoursDayMapper, AuxiliaryWorkingHoursDay> implements AuxiliaryWorkingHoursDayService {

    @Resource
    AuxiliaryWorkingHoursDayMapper auxiliaryWorkingHoursDayMapper;

    @Resource
    AuxiliaryWorkingHoursMapper auxiliaryWorkingHoursMapper;


    @Resource
    UserMapper userMapper;

    @Resource
    private SysRoleMapper roleMapper;

    @Resource
    private SysUserRoleMapper userRoleMapper;


    @Resource
    PerformanceShiftMapper performanceShiftMapper;

    @Resource
    private ISysDictTypeService dictTypeService;

    @Resource
    private ShiftTimeMapper shiftTimeMapper;

    @Override
    public IPage<AuxiliaryWorkingHoursDayDto> selectAuxiliaryWorkingHoursDay(Page page, AuxiliaryWorkingHoursDayDto auxiliaryWorkingHoursDayDto) {
        String dateTime1 = auxiliaryWorkingHoursDayDto.getDateTime1();
        String dateTime2 = auxiliaryWorkingHoursDayDto.getDateTime2();
        AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay = new AuxiliaryWorkingHoursDay();
        BeanUtils.copyProperties(auxiliaryWorkingHoursDayDto, auxiliaryWorkingHoursDay);
        String week = auxiliaryWorkingHoursDayDto.getWeek();
        auxiliaryWorkingHoursDayDto.setDateTime(null);
        auxiliaryWorkingHoursDayDto.setWeek(null);
        List<Integer> ids = new ArrayList<>();

        List<User> users = userMapper.selectList(new LambdaQueryWrapper<User>().like(User::getName, auxiliaryWorkingHoursDayDto.getName()));
        if(CollectionUtils.isNotEmpty(users)) {
            ids = users.stream().map(User::getId).distinct().collect(Collectors.toList());
        }


        IPage<AuxiliaryWorkingHoursDayDto> auxiliaryWorkingHoursDayDtoIPage = null;

        if (StringUtils.isNotEmpty(dateTime1) && ObjectUtils.isNotEmpty(week)) {
            String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");
            auxiliaryWorkingHoursDayDtoIPage = auxiliaryWorkingHoursDayMapper.selectAuxiliaryWorkingHoursDay(page,
                    QueryWrappers.queryWrappers(auxiliaryWorkingHoursDay)
                            .ge("date_time", dateTime1).le("date_time", dateTime2 + " 23:59:59")
                            .ge("week", weeks[0]).le("week", weeks[1]), ids);
            for (AuxiliaryWorkingHoursDayDto record : auxiliaryWorkingHoursDayDtoIPage.getRecords()) {
                record.setDateTime(record.getDateTime().substring(0, 10));
            }

        } else if (StringUtils.isNotEmpty(dateTime1) && ObjectUtils.isEmpty(week)) {
            auxiliaryWorkingHoursDayDtoIPage = auxiliaryWorkingHoursDayMapper.selectAuxiliaryWorkingHoursDay(page,
                    QueryWrappers.queryWrappers(auxiliaryWorkingHoursDay)
                            .ge("date_time", dateTime1).le("date_time", dateTime2 + " 23:59:59"), ids);
            for (AuxiliaryWorkingHoursDayDto record : auxiliaryWorkingHoursDayDtoIPage.getRecords()) {
                record.setDateTime(record.getDateTime().substring(0, 10));
            }

        } else if (StringUtils.isEmpty(dateTime1) && ObjectUtils.isNotEmpty(week)) {
            String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");
            auxiliaryWorkingHoursDayDtoIPage = auxiliaryWorkingHoursDayMapper.selectAuxiliaryWorkingHoursDay(page,
                    QueryWrappers.queryWrappers(auxiliaryWorkingHoursDay)
                            .ge("week", weeks[0]).le("week", weeks[1]), ids);
            for (AuxiliaryWorkingHoursDayDto record : auxiliaryWorkingHoursDayDtoIPage.getRecords()) {
                record.setDateTime(record.getDateTime().substring(0, 10));
            }

        } else {
            auxiliaryWorkingHoursDayDtoIPage = auxiliaryWorkingHoursDayMapper.selectAuxiliaryWorkingHoursDay(page, QueryWrappers.queryWrappers(auxiliaryWorkingHoursDay), ids);
            for (AuxiliaryWorkingHoursDayDto record : auxiliaryWorkingHoursDayDtoIPage.getRecords()) {
                record.setDateTime(record.getDateTime().substring(0, 10));
            }
        }
        return auxiliaryWorkingHoursDayDtoIPage;
    }

    //根据编号查询辅助工时配置信息
    @Override
    public AuxiliaryWorkingHoursDay selectAuxiliaryWorkingHoursByNumber(String number) {
        //根据填写的编号查询辅助工时配置
        AuxiliaryWorkingHours auxiliaryWorkingHours = auxiliaryWorkingHoursMapper.selectOne(Wrappers.<AuxiliaryWorkingHours>lambdaQuery().eq(AuxiliaryWorkingHours::getNumber, number));
        if (ObjectUtils.isEmpty(auxiliaryWorkingHours)) {
            throw new ErrorException("该编号没有对应的辅助工时配置");
        }
        AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay = new AuxiliaryWorkingHoursDay();
        BeanUtils.copyProperties(auxiliaryWorkingHours, auxiliaryWorkingHoursDay);
        return auxiliaryWorkingHoursDay;
    }

    //录入数据(新增)
    @Override
    public int insertAuxiliaryWorkingHoursDay(AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay) {
        Integer userId = Integer.parseInt(SecurityUtils.getUserId().toString());
        auxiliaryWorkingHoursDay.setNameUser(userId);//姓名id
        auxiliaryWorkingHoursDay.setState("已提交");
        //查询人员当前的班次
        if(StringUtils.isNotBlank(auxiliaryWorkingHoursDay.getDateTime())){
            //录入时间
            DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
            LocalDateTime saveDate = LocalDateTime.parse(auxiliaryWorkingHoursDay.getDateTime(), pattern);

            LocalDate now1 = LocalDate.now();//当前日期
            LocalDate dateTime = LocalDate.parse(saveDate.format(formatter));// 用户选择日期

            //班次记录
            PerformanceShift performanceShift = performanceShiftMapper.selectOne(Wrappers.<PerformanceShift>lambdaQuery()
                    .eq(PerformanceShift::getUserId, userId)
                    .eq(PerformanceShift::getWorkTime, saveDate).last("limit 1"));
            if(Objects.isNull(performanceShift)) {
                throw new ErrorException("请先录入班次信息");
            }
            auxiliaryWorkingHoursDay.setShift(performanceShift.getShift());
            DateTime parse = DateUtil.parse(saveDate.format(formatter));
            auxiliaryWorkingHoursDay.setWeek(String.valueOf(DateUtil.weekOfYear(DateUtil.offsetDay(parse, 1)))); // 周次
            // 如果是昨天，赋值到上一个班次
            if(now1.isAfter(dateTime)) {
            }else{
                // 如果是今天，并且是跨天的班次，需要将日期改为昨天
                ShiftTime shiftTime = shiftTimeMapper.selectOne(new LambdaQueryWrapper<ShiftTime>()
                        .eq(ShiftTime::getShift, performanceShift.getShift()));
                if(Objects.nonNull(shiftTime)) {
                    String start = shiftTime.getStartTime();
                    String end = shiftTime.getEndTime();
                    LocalTime startTime = LocalTime.parse(start);
                    LocalTime endTime = LocalTime.parse(end);
                    LocalTime now = LocalTime.now();
                    // 跨天班次
                    if(startTime.isAfter(endTime)){
                        // 不在今天的班次时间内
                        if(now.isBefore(startTime)) {
                            auxiliaryWorkingHoursDay = previousShift(userId, auxiliaryWorkingHoursDay);
                        }
                    }else {
                        // 不跨天的情况
                        // 如果当前时间不在今天的班次时间内,且在开始之前 算到上一个班次
                        if(now.isBefore(startTime)){
                            auxiliaryWorkingHoursDay = previousShift(userId, auxiliaryWorkingHoursDay);
                        }

                    }
                }else {
                    // 如果是休息 请假  出差 的情况，需要将日期改为前一个班次
                    // 都算到上一个班次
                    auxiliaryWorkingHoursDay = previousShift(userId, auxiliaryWorkingHoursDay);
                }
            }
        }
        return auxiliaryWorkingHoursDayMapper.insert(auxiliaryWorkingHoursDay);
    }
    // 获取上一个班次的时间
    public AuxiliaryWorkingHoursDay previousShift(Integer userId,AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay) {
        LocalTime time = LocalTime.of(0, 0, 0);
        LocalDateTime yesterdayTime = LocalDateTime.of(LocalDate.now(), time);
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 都算到上一个班次
        List<Integer> list = Arrays.asList(3, 4, 6); // 休息 请假 半天 出差
        List<PerformanceShift> performanceShifts = performanceShiftMapper.selectList(new LambdaQueryWrapper<PerformanceShift>()
                .eq(PerformanceShift::getUserId, userId)
                .lt(PerformanceShift::getWorkTime, yesterdayTime.format(dateTimeFormatter))
                .notIn(PerformanceShift::getShift, list)
                .orderByDesc(PerformanceShift::getWorkTime));
        String dateTime = performanceShifts.get(0).getWorkTime().format(dateTimeFormatter);
        auxiliaryWorkingHoursDay.setDateTime(dateTime);//日期 前一个班次
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        DateTime parse = DateUtil.parse(performanceShifts.get(0).getWorkTime().format(formatter));
        auxiliaryWorkingHoursDay.setWeek(String.valueOf(DateUtil.weekOfYear(DateUtil.offsetDay(parse, 1)))); // 周次
        auxiliaryWorkingHoursDay.setWeekDay(getWeek(dateTime));//星期
        return auxiliaryWorkingHoursDay;
    }
    public static String getWeek(String dayStr) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date date = sdf.parse(dayStr);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
            int day = calendar.get(Calendar.DAY_OF_MONTH);
            return getWeekDay(dayOfWeek);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static String getWeekDay(int dayOfWeek) {
        switch (dayOfWeek) {
            case Calendar.MONDAY:
                return "1";
            case Calendar.TUESDAY:
                return "2";
            case Calendar.WEDNESDAY:
                return "3";
            case Calendar.THURSDAY:
                return "4";
            case Calendar.FRIDAY:
                return "5";
            case Calendar.SATURDAY:
                return "6";
            case Calendar.SUNDAY:
                return "7";
            default:
                return "未知";
        }
    }


    //审核/批准
    @Override
    public boolean checkOrApprove(HoursDay hoursDay) {
        List<AuxiliaryWorkingHoursDay> auxiliaryWorkingHoursDays = hoursDay.getAuxiliaryWorkingHoursDays();
        for (AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay : auxiliaryWorkingHoursDays) {
            if (auxiliaryWorkingHoursDay.getState().equals("已审核")) {
                Integer userId = Integer.parseInt(SecurityUtils.getUserId().toString());
                auxiliaryWorkingHoursDay.setReviewer(userMapper.selectById(userId).getName());
            }
            if (auxiliaryWorkingHoursDay.getReviewerNumber() == null) {
                auxiliaryWorkingHoursDay.setReviewerNumber(auxiliaryWorkingHoursDay.getAmount());//复核数量
                auxiliaryWorkingHoursDay.setReviewerNonproductiveTime(auxiliaryWorkingHoursDay.getNonproductiveTime());//复核工时
            }

        }
        return updateBatchById(auxiliaryWorkingHoursDays);
    }

    //编辑
    @Override
    public int updateAuxiliaryWorkingHoursDay(AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay) {
        Integer userId = Integer.parseInt(SecurityUtils.getUserId().toString());
        auxiliaryWorkingHoursDay.setNameUser(userId);//姓名id
        return auxiliaryWorkingHoursDayMapper.updateById(auxiliaryWorkingHoursDay);
    }

    //删除
    @Override
    public int deleteAuxiliaryWorkingHoursDay(Integer id) {
        return auxiliaryWorkingHoursDayMapper.deleteById(id);
    }

    //根据编号当前用户信息查询所在班次
    @Override
    public String selectshiftByUser(LocalDateTime dateTime) {
        Integer userId = Integer.parseInt(SecurityUtils.getUserId().toString());
        PerformanceShift performanceShift = performanceShiftMapper.selectOne(Wrappers.<PerformanceShift>lambdaQuery().eq(PerformanceShift::getUserId, userId).eq(PerformanceShift::getWorkTime, dateTime));
        if (ObjectUtils.isEmpty(performanceShift)) {
            return null;
        }
        return performanceShift.getShift();
    }


}