package com.ruoyi.performance.service.impl;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy;
import com.alibaba.fastjson2.JSONArray;
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.core.toolkit.*;
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.performance.dto.AuxiliaryOutputWorkingHoursDto;
import com.ruoyi.performance.dto.AuxiliaryWorkingHoursDayDto;
import com.ruoyi.performance.mapper.AuxiliaryOutputWorkingHoursMapper;
import com.ruoyi.performance.mapper.AuxiliaryWorkingHoursDayMapper;
import com.ruoyi.performance.pojo.AuxiliaryOutputWorkingHours;
import com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay;
import com.ruoyi.performance.service.AuxiliaryOutputWorkingHoursService;
import com.ruoyi.system.mapper.UserMapper;
import org.apache.commons.math3.analysis.function.Power;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 日工时管理的产量工时 服务实现类
 * </p>
 *
 * @author 江苏鵷雏网络科技有限公司
 * @since 2024-05-28 03:48:48
 */
@Service
public class AuxiliaryOutputWorkingHoursServiceImpl extends ServiceImpl<AuxiliaryOutputWorkingHoursMapper, AuxiliaryOutputWorkingHours> implements AuxiliaryOutputWorkingHoursService {

    @Resource
    AuxiliaryOutputWorkingHoursMapper auxiliaryOutputWorkingHoursMapper;

    @Resource
    AuxiliaryWorkingHoursDayMapper auxiliaryWorkingHoursDayMapper;

    @Resource
    UserMapper userMapper;


    @Override
    public IPage<AuxiliaryOutputWorkingHoursDto> selectAuxiliaryOutputWorkingHours(Page page, AuxiliaryOutputWorkingHoursDto auxiliaryOutputWorkingHoursDto) {
        auxiliaryOutputWorkingHoursDto.setWeekDay(weekConvert(StringUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getWeekDay()) ? auxiliaryOutputWorkingHoursDto.getWeekDay() : ""));
        String dateTime1 = auxiliaryOutputWorkingHoursDto.getDateTime1();
        String dateTime2 = auxiliaryOutputWorkingHoursDto.getDateTime2();
        AuxiliaryOutputWorkingHours auxiliaryOutputWorkingHours = new AuxiliaryOutputWorkingHours();
        BeanUtils.copyProperties(auxiliaryOutputWorkingHoursDto, auxiliaryOutputWorkingHours);
        String week = auxiliaryOutputWorkingHoursDto.getWeek();
        auxiliaryOutputWorkingHoursDto.setDateTime(null);
        auxiliaryOutputWorkingHoursDto.setWeek(null);
        Map<String, Object> map = new HashMap<>();
        List<Integer> ids = new ArrayList<>();
        //判断组长,组员,管理员权限
        User user = userMapper.selectById(Integer.parseInt(SecurityUtils.getLoginUser().getUser().getUserId().toString()));

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


        IPage<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtoIPage = null;
        if (StringUtils.isNotEmpty(dateTime1) && ObjectUtils.isNotEmpty(week)) {
            String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");
             auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page,
                    QueryWrappers.queryWrappers(auxiliaryOutputWorkingHours)
                            .ge("date_time", dateTime1).le("date_time", dateTime2 + " 23:59:59")
                            .ge("week", weeks[0]).le("week", weeks[1]), ids);
            for (AuxiliaryOutputWorkingHoursDto record : auxiliaryOutputWorkingHoursDtoIPage.getRecords()) {
                record.setDateTime(record.getDateTime().substring(0,10));
            }
            map.put("body",auxiliaryOutputWorkingHoursDtoIPage );
        } else if (StringUtils.isNotEmpty(dateTime1) && ObjectUtils.isEmpty(week)) {
            auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page,
                    QueryWrappers.queryWrappers(auxiliaryOutputWorkingHours)
                            .ge("date_time", dateTime1).le("date_time", dateTime2 + " 23:59:59"), ids);
            for (AuxiliaryOutputWorkingHoursDto record : auxiliaryOutputWorkingHoursDtoIPage.getRecords()) {
                record.setDateTime(record.getDateTime().substring(0,10));
            }
            map.put("body",auxiliaryOutputWorkingHoursDtoIPage );
        } else if (StringUtils.isEmpty(dateTime1) && ObjectUtils.isNotEmpty(week)) {
            String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");
             auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page,
                    QueryWrappers.queryWrappers(auxiliaryOutputWorkingHours)
                            .ge("week", weeks[0]).le("week", weeks[1]), ids);
            for (AuxiliaryOutputWorkingHoursDto record : auxiliaryOutputWorkingHoursDtoIPage.getRecords()) {
                record.setDateTime(record.getDateTime().substring(0,10));
            }
            map.put("body", auxiliaryOutputWorkingHoursDtoIPage);
        } else {
            auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page, QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto), ids);
            for (AuxiliaryOutputWorkingHoursDto record : auxiliaryOutputWorkingHoursDtoIPage.getRecords()) {
                record.setDateTime(record.getDateTime().substring(0,10));
            }
        }
        return auxiliaryOutputWorkingHoursDtoIPage;
    }


    @Override
    public Map<String, Object> collectWorkingHours(AuxiliaryOutputWorkingHoursDto auxiliaryOutputWorkingHoursDto){
        // 返回的结果
        Map<String, Object> map = new HashMap<>();

        // 判断当前人的权限 是否可查看多人
        List<Integer> ids = getCurrentGroupUserIds(StringUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getName()) ? auxiliaryOutputWorkingHoursDto.getName() : "");

        String dateTime = auxiliaryOutputWorkingHoursDto.getDateTime();
        String startTime = "";
        String endTime = "";
        if(StringUtils.isNotEmpty(dateTime)) {
            List<String> list = JSONArray.parseArray(dateTime, String.class);
            if(list.size() == 1) {
                list = JSONArray.parseArray(list.get(0), String.class);
            }
            startTime = list.get(0)+ " 00:00:00";
            endTime = list.get(1)+ " 23:59:59";
        }
        String weekConvert = weekConvert(StringUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getWeekDay()) ? auxiliaryOutputWorkingHoursDto.getWeekDay()  : ""  ); // 周次转换
        // 根据条件获取数据
        List<AuxiliaryOutputWorkingHours> auxiliaryOutputWorkingHours = auxiliaryOutputWorkingHoursMapper.selectList(new QueryWrapper<AuxiliaryOutputWorkingHours>()
                .in(CollectionUtils.isNotEmpty(ids), "check_id", ids)
                .like(StringUtils.isNotBlank(auxiliaryOutputWorkingHoursDto.getWeekDay()), "week_day", weekConvert)
                .between(StringUtils.isNotEmpty(dateTime),"date_time", startTime, endTime));

        // 1.产量工时汇总
        // 根据委托编号、样品编号、工时分组 来进行分组统计
        // 加班的工时汇总
        BigDecimal overTime = BigDecimal.ZERO;
        // 过滤出加班的工时
        List<AuxiliaryOutputWorkingHours> overFilter = auxiliaryOutputWorkingHours.stream()
                .filter(item -> Objects.nonNull(item.getOvertimeOrderNo()) && StringUtils.isNotEmpty(item.getOvertimeOrderNo()))
                .collect(Collectors.toList());
        Map<String, List<AuxiliaryOutputWorkingHours>> collect = overFilter.stream()
                .collect(Collectors.groupingBy(item -> item.getOvertimeOrderNo() + "@" + item.getSample() + "@" + item.getManHourGroup()));
        Iterator<Map.Entry<String, List<AuxiliaryOutputWorkingHours>>> iterator = collect.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, List<AuxiliaryOutputWorkingHours>> entry = iterator.next();
            // 同一分组下的只需要算一次
            overTime = add(overTime, BigDecimal.valueOf(entry.getValue().get(0).getOvertimeWorkTime()));
        }
        // 非加班的工时汇总
        BigDecimal workTime = BigDecimal.ZERO;
        List<AuxiliaryOutputWorkingHours> workFilter = auxiliaryOutputWorkingHours.stream()
                .filter(item -> Objects.nonNull(item.getOrderNo()) && StringUtils.isNotEmpty(item.getOrderNo()))
                .collect(Collectors.toList());
        Map<String, List<AuxiliaryOutputWorkingHours>> collect1 = workFilter.stream()
                .collect(Collectors.groupingBy(item -> item.getOrderNo() + "@" + item.getSample() + "@" + item.getManHourGroup()));
        Iterator<Map.Entry<String, List<AuxiliaryOutputWorkingHours>>> iterator1 = collect1.entrySet().iterator();
        while (iterator1.hasNext()) {
            Map.Entry<String, List<AuxiliaryOutputWorkingHours>> entry = iterator1.next();
            workTime = add(workTime, BigDecimal.valueOf(entry.getValue().get(0).getOutputWorkTime()));
        }
        BigDecimal outPutWorkTime = add(overTime, workTime);
        // 2.辅助工时汇总
        BigDecimal dayWorkTime = BigDecimal.ZERO;
        List<AuxiliaryWorkingHoursDay> dayList = auxiliaryWorkingHoursDayMapper.selectList(new QueryWrapper<AuxiliaryWorkingHoursDay>()
                .in(CollectionUtils.isNotEmpty(ids), "name_user", ids)
                .like(StringUtils.isNotBlank(auxiliaryOutputWorkingHoursDto.getWeekDay()), "week_day", auxiliaryOutputWorkingHoursDto.getWeekDay())
                .eq(StringUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getState()), "state", auxiliaryOutputWorkingHoursDto.getState())
                .between(StringUtils.isNotEmpty(dateTime),"date_time", startTime, endTime));

        for (AuxiliaryWorkingHoursDay a  : dayList) {
            if(ObjectUtils.isNull(a.getReviewerNonproductiveTime())) {
                dayWorkTime = add(dayWorkTime, BigDecimal.ZERO);
            }else {
                dayWorkTime = add(dayWorkTime, BigDecimal.valueOf(a.getReviewerNonproductiveTime()));
            }
        }
        map.put("产量工时汇总", outPutWorkTime);
        map.put("辅助工时汇总", dayWorkTime);
        return  map;
    }


    public  BigDecimal add(BigDecimal a, BigDecimal b){
        return a.add(b);
    }

    // 周次转换
    public String weekConvert(String week){
        String weekDay = "";
        switch (week) {
            case "1":
                weekDay = "周一";
                break;
            case "2":
                weekDay = "周二";
                break;
            case "3":
                weekDay = "周三";
                break;
            case "4":
                weekDay = "周四";
                break;
            case "5":
                weekDay = "周五";
                break;
            case "6":
                weekDay = "周六";
                break;
            case "0":
                weekDay = "周日";
                break;
        }
        return weekDay;
    }


    /**
     * 获取当前用户组织的用户id
     * @return
     */
    private List<Integer> getCurrentGroupUserIds(){
        return getCurrentGroupUserIds("");
    }

    private List<Integer> getCurrentGroupUserIds(String name){
        List<Integer> ids = new ArrayList<>();
        //判断是组长还是组员还是管理员，根据roleId(7:检验员，8:检验组长)
        Integer userId = Integer.parseInt(SecurityUtils.getLoginUser().getUser().getUserId().toString());
        User user = userMapper.selectById(userId);

        //管理员(不添加限制条件所有人都可以看)
        //不是组长

        return ids;
    }

    //导出
    @Override
    public void exportWorkingHours(HttpServletResponse response) throws IOException {
        List<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtos = new ArrayList<>();
        List<AuxiliaryWorkingHoursDayDto> auxiliaryWorkingHoursDayDtos = new ArrayList<>();
        List<Integer> ids = getCurrentGroupUserIds();
        //查询辅助工时
        auxiliaryWorkingHoursDayDtos = auxiliaryWorkingHoursDayMapper.selectDataByUser(ids);
        //查询统计工时
        auxiliaryOutputWorkingHoursDtos = auxiliaryOutputWorkingHoursMapper.selectDataByUser(ids).stream().map(item -> {
            if(Objects.isNull(item.getOvertimeWorkTime())) {
                item.setOvertimeWorkTime((double)0);
            }
            if(Objects.isNull(item.getOvertimeAmount())) {
                item.setOvertimeAmount(0);
            }
            if(Objects.isNull(item.getWorkTime())) {
                item.setWorkTime((double)0);
            }
            if(Objects.isNull(item.getAmount())) {
                item.setAmount(0);
            }
            return item;
        }).collect(Collectors.toList());
        response.setContentType("application/vnd.ms-excel");
        response.setCharacterEncoding("UTF-8");
        // 这里URLEncoder.encode可以防止中文乱码 当然和easyexcel没有关系
        String fileName = URLEncoder.encode("日工时管理导出", "UTF-8");
        response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx");
        try {
            // 新建ExcelWriter
            ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream()).registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).build();
            WriteSheet mainSheet = EasyExcel.writerSheet(0, "辅助工时导出").head(AuxiliaryWorkingHoursDayDto.class).build();
            excelWriter.write(auxiliaryWorkingHoursDayDtos, mainSheet);
            WriteSheet mainSheet1 = EasyExcel.writerSheet(1, "产量工时导出").head(AuxiliaryOutputWorkingHoursDto.class).build();
            excelWriter.write(auxiliaryOutputWorkingHoursDtos, mainSheet1);
            // 关闭流
            excelWriter.finish();
        } catch (IOException e) {
            throw new RuntimeException("导出失败");
        }
    }
}