package com.engine.newwaymask.service.impl;

import com.engine.core.impl.Service;
import com.engine.newwaymask.entity.JobRecord;
import com.engine.newwaymask.entity.Key;
import com.engine.newwaymask.entity.StaffDutyResult;
import com.engine.newwaymask.entity.StaffPlan;
import com.engine.newwaymask.service.StaffDutyService;
import com.weaver.general.BaseBean;
import com.weaver.general.Util;
import weaver.conn.RecordSet;
import weaver.conn.RecordSetTrans;
import weaver.general.StringUtil;
import weaver.general.TimeUtil;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @Author liang.cheng
 * @Date 2025/4/21 15:31
 * @Description: TODO
 * @Version 1.0
 */
public class StaffDutyServiceImpl extends Service implements StaffDutyService {


    @Override
    public List<JobRecord> selectJobRecords(String requestId) {

        List<JobRecord> jobRecords = new ArrayList<>();
        RecordSet rs = new RecordSet();

        String sql = "select a.id,a.rzry,a.rzlx,a.gwzt,a.sydrzid,a.gw,a.ksrq,a.jsrq,b.gwszbz from uf_rzxxb a\n" +
                "left join uf_gwgl b on a.gw = b.id \n" +
                "left join uf_zt c on a.gwzt = c.id \n" +
                "where c.on_job = 0 and a.ksrq <= ? and a.jsrq >= ?";
        if (!StringUtil.isEmpty(requestId)) {
            sql += " and a.lcqqid = "+requestId;
        }

        String currentDate = TimeUtil.getCurrentDateString();
        rs.executeQuery(sql,currentDate,currentDate);


        while (rs.next()) {
            jobRecords.add(JobRecord.builder()
                    .id(Util.getIntValue(rs.getString("id")))
                    .resourceId(Util.getIntValue(rs.getString("rzry")))
                    .lastId(Util.getIntValue(rs.getString("sydrzid")))
                    .jobId(Util.getIntValue(rs.getString("gw")))
                    .staffBelong(Util.getIntValue(rs.getString("gwszbz")))
                    .jobType(Util.getIntValue(rs.getString("rzlx")))
                    .build());
        }

        //同一人员如果出现多条生效数据 根据建模id取最大那条
        return jobRecords.stream()
                // 过滤无效数据：resourceId和id均非空
                .filter(record -> record.getResourceId() != null && record.getId() != null)
                // 分组并取每组id最大的记录
                .collect(Collectors.groupingBy(
                        JobRecord::getResourceId,
                        LinkedHashMap::new,
                        Collectors.collectingAndThen(
                                Collectors.maxBy(Comparator.comparing(
                                        JobRecord::getId,
                                        Comparator.nullsLast(Integer::compare)
                                )),
                                Optional::get
                        )
                ))
                .values()
                .stream()
                .collect(Collectors.toList());

    }

    @Override
    public List<StaffPlan> selectStaffPlans(JobRecord jobRecord,boolean isAll) {
        List<StaffPlan> staffPlans = new ArrayList<>();
        RecordSet rs = new RecordSet();
        String sql = "select id,gw,bzgz,rzlx,zbzjhs,djbzs,zbrs,syrs from uf_bzjh where sfzxbb = 0";

        //全部计算功能
        if (isAll) {
            rs.executeQuery(sql);
            while (rs.next()) {
                staffPlans.add(StaffPlan.builder()
                        .id(Util.getIntValue(rs.getString("id")))
                        .jobId(Util.getIntValue(rs.getString("gw")))
                        .jobType(Util.getIntValue(rs.getString("rzlx")))
                        .staffBelong(Util.getIntValue(rs.getString("bzgz")))
                        .staffPlanNums(Util.getIntValue(rs.getString("zbzjhs"),0))
                        .frozenNums(Util.getIntValue(rs.getString("djbzs"),0))
                        .onJobNums(Util.getIntValue(rs.getString("zbrs"),0))
                        .restNums(Util.getIntValue(rs.getString("syrs")))
                        .build());
            }
        }else {
            sql += " and gw = ? and bzgz = ? and rzlx = ?";
            rs.executeQuery(sql,jobRecord.getJobId(),jobRecord.getStaffBelong(),jobRecord.getJobType());
            while (rs.next()) {
                staffPlans.add(StaffPlan.builder()
                        .id(Util.getIntValue(rs.getString("id")))
                        .jobId(Util.getIntValue(rs.getString("gw")))
                        .staffPlanNums(Util.getIntValue(rs.getString("zbzjhs"),0))
                        .frozenNums(Util.getIntValue(rs.getString("djbzs"),0))
                        .onJobNums(Util.getIntValue(rs.getString("zbrs"),0))
                        .restNums(Util.getIntValue(rs.getString("syrs")))
                        .build());
            }
        }
        return staffPlans;
    }

    @Override
    public StaffDutyResult entryWorkflow(String requestId,String operateType) {

        StaffDutyResult result = buildStaffPlan(requestId);
        if (!result.getStatus()) {
            return result;
        }

        StaffPlan staffPlan = result.getStaffPlan();
        BaseBean bb = new BaseBean();
        bb.writeLog(String.format("entryWorkflow requestid:%s 更新前编制方案信息: %s",requestId,staffPlan.toString()));

        //4.增加在编数 更新剩余数(业务上说明无脑加减)
        Integer onJob = staffPlan.getOnJobNums() + 1;
        LinkedList<Integer> numbers = new LinkedList<>(Arrays.asList(staffPlan.getStaffPlanNums(), staffPlan.getFrozenNums(), onJob));
        int rest = numbers.stream()
                .findFirst()
                .map(first -> first - numbers.stream().skip(1).mapToInt(Integer::intValue).sum())
                .orElse(0);

        //5.编制计划表更新
        Boolean flag = updateStaffPlan(onJob, rest, staffPlan.getId());
        if (flag) {
            result.setStatus(true);
            result.setMessage(String.format("编制信息id:%s所对应数据更新成功",staffPlan.getId()));
        }

//        //4.流程提交
//        if ("submit".equals(operateType)) {
//            //1.增加冻结数，更新剩余数
//        }
//        //5.流程退回
//        if ("reject".equals(operateType)) {
//            //1.减少冻结数，更新剩余数
//        }
//        //6.流程归档
//        if ("".equals(operateType)) {
//            //1.减少冻结数，增加在编数 更新剩余数
//        }

        return result;
    }

    @Override
    public StaffDutyResult leaveWorkflow(String requestId, String operateType) {
        StaffDutyResult result = buildStaffPlan(requestId);
        if (!result.getStatus()) {
            return result;
        }

        StaffPlan staffPlan = result.getStaffPlan();
        BaseBean bb = new BaseBean();
        bb.writeLog(String.format("leaveWorkflow requestid:%s 更新前编制方案信息: %s",requestId,staffPlan.toString()));

        //4.减少在编数 更新剩余数
        Integer onJob = staffPlan.getOnJobNums() - 1;
        LinkedList<Integer> numbers = new LinkedList<>(Arrays.asList(staffPlan.getStaffPlanNums(), staffPlan.getFrozenNums(), onJob));
        int rest = numbers.stream()
                .findFirst()
                .map(first -> first - numbers.stream().skip(1).mapToInt(Integer::intValue).sum())
                .orElse(0);

        //5.编制计划表更新
        Boolean flag = updateStaffPlan(onJob, rest, staffPlan.getId());
        if (flag) {
            result.setStatus(true);
            result.setMessage(String.format("编制信息id:%s所对应数据更新成功",staffPlan.getId()));
        }
        return result;
    }

    @Override
    public StaffDutyResult transferWorkflow(String requestId, String operateType) {

        StaffDutyResult result = new StaffDutyResult();
        //1.获取任职数据信息
        List<JobRecord> jobRecords = selectJobRecords(requestId);
        if (jobRecords.size() == 0) {
            result.setMessage(String.format("未查询到requestId:%s所对应的调入后任职记录数据,请检查流程转建模配置",requestId));
            result.setStatus(false);
            return result;
        }

        //2.获取需要更新的编制执行情况数据
        JobRecord jobRecord = jobRecords.get(0);
        List<StaffPlan> staffPlans = selectStaffPlans(jobRecord, false);
        if (staffPlans.size() == 0) {
            result.setMessage(String.format("requestId:%s所对应的调入后任职记录数据在当前编制计划中未匹配到,请检查参数",requestId));
            result.setStatus(false);
            return result;
        }

        //3.若匹配多条数据 获取id 较大的那条数据作为最新数据
        StaffPlan staffPlanTo = staffPlans.stream()
                .filter(Objects::nonNull)
                .max(Comparator.comparing(StaffPlan::getId))
                .orElse(null);

        BaseBean bb = new BaseBean();
        bb.writeLog(String.format("transferWorkflow requestid:%s 调入后岗位对应编制方案信息: %s",requestId,staffPlanTo.toString()));

        //调出前岗位信息所对应编制信息
        JobRecord jobRecordFrom = selectJobRecordById(staffPlanTo.getId());
        if (Objects.isNull(jobRecordFrom)) {
            result.setMessage(String.format("未查询到requestId:%s所对应的调出前岗位对应任职记录数据,请检查任职记录表",requestId));
            result.setStatus(false);
            return result;
        }

        List<StaffPlan> staffPlansFrom = selectStaffPlans(jobRecordFrom, false);
        if (staffPlansFrom.size() == 0) {
            result.setMessage(String.format("requestId:%s所对应的调出前岗位任职记录数据在当前编制计划中未匹配到,请检查参数",requestId));
            result.setStatus(false);
            return result;
        }

        StaffPlan staffPlanFrom = staffPlans.stream()
                .filter(Objects::nonNull)
                .max(Comparator.comparing(StaffPlan::getId))
                .orElse(null);
        bb.writeLog(String.format("transferWorkflow requestid:%s 调出前岗位对应编制方案信息: %s",requestId,staffPlanFrom.toString()));


        //调出前岗位对应编制方案增加在编数 更新剩余数
        //4.(业务上说明无脑加减)
        Integer onJobFrom = staffPlanFrom.getOnJobNums() + 1;
        LinkedList<Integer> numberFrom = new LinkedList<>(Arrays.asList(staffPlanFrom.getStaffPlanNums(), staffPlanFrom.getFrozenNums(), onJobFrom));
        int restFrom = numberFrom.stream()
                .findFirst()
                .map(first -> first - numberFrom.stream().skip(1).mapToInt(Integer::intValue).sum())
                .orElse(0);

        //4.调入后岗位对应编制方案减少在编数 更新剩余数
        Integer onJobTo = staffPlanTo.getOnJobNums() - 1;
        LinkedList<Integer> numberTo = new LinkedList<>(Arrays.asList(staffPlanTo.getStaffPlanNums(), staffPlanTo.getFrozenNums(), onJobTo));
        int restTo = numberTo.stream()
                .findFirst()
                .map(first -> first - numberTo.stream().skip(1).mapToInt(Integer::intValue).sum())
                .orElse(0);

        RecordSetTrans trans = new RecordSetTrans();
        try {
            trans.setAutoCommit(false);

            trans.executeUpdate("update uf_bzjh set zbrs = ?,syrs = ? where id = ?", onJobFrom, restFrom, staffPlanFrom.getId());
            trans.executeUpdate("update uf_bzjh set zbrs = ?,syrs = ? where id = ?", onJobTo, restTo, staffPlanTo.getId());
            trans.commit();

        }catch (Exception e) {
            trans.rollback();
            result.setMessage("编制信息更新失败,请联系管理员");
            result.setStatus(false);
        }

        return null;
    }

    @Override
    public Map<String, Object> calculateAll() {

        List<JobRecord> jobRecords = selectJobRecords("");
        List<StaffPlan> staffPlans = selectStaffPlans(null, true);
        Map<String, Object> map = new HashMap<>();

        Map<Key, Integer> countMap = new HashMap<>();
        for (JobRecord record : jobRecords) {
            Key key = new Key(record.getJobId(), record.getStaffBelong(), record.getJobType());
            countMap.put(key, countMap.getOrDefault(key, 0) + 1);
        }

        for (StaffPlan plan : staffPlans) {
            Key key = new Key(plan.getJobId(), plan.getStaffBelong(), plan.getJobType());
            Integer onJob = countMap.getOrDefault(key, 0);
            LinkedList<Integer> numbers = new LinkedList<>(Arrays.asList(plan.getStaffPlanNums(), plan.getFrozenNums(), onJob));
            int rest = numbers.stream()
                    .findFirst()
                    .map(first -> first - numbers.stream().skip(1).mapToInt(Integer::intValue).sum())
                    .orElse(0);
            updateStaffPlan(onJob, rest, plan.getId());
        }

        map.put("size",staffPlans.size());

        return map;
    }


    private StaffDutyResult buildStaffPlan(String requestId) {

        StaffDutyResult result = new StaffDutyResult();
        //1.获取任职数据信息
        List<JobRecord> jobRecords = selectJobRecords(requestId);
        if (jobRecords.size() == 0) {
            result.setMessage(String.format("未查询到requestId:%s所对应的任职记录数据,请检查流程转建模配置",requestId));
            result.setStatus(false);
            return result;
        }

        //2.获取需要更新的编制执行情况数据
        List<StaffPlan> staffPlans = selectStaffPlans(jobRecords.get(0), false);
        if (staffPlans.size() == 0) {
            result.setMessage(String.format("requestId:%s所对应的任职记录数据在当前编制计划中未匹配到,请检查参数",requestId));
            result.setStatus(false);
            return result;
        }

        //3.若匹配多条数据 获取id 较大的那条数据作为最新数据
        StaffPlan staffPlan = staffPlans.stream()
                .filter(Objects::nonNull)
                .max(Comparator.comparing(StaffPlan::getId))
                .orElse(null);

        result.setStatus(true);
        result.setStaffPlan(staffPlan);

        return result;
    }


    private Boolean updateStaffPlan(Integer onJob,Integer rest,Integer id) {
        //5.编制计划表更新
        RecordSet rs = new RecordSet();
        return rs.executeUpdate("update uf_bzjh set zbrs = ?,syrs = ? where id = ?", onJob, rest, id);
    }


    private JobRecord selectJobRecordById(Integer id) {
        RecordSet rs = new RecordSet();
        JobRecord jobRecord = null;
        rs.executeQuery("select a.id,a.rzlx,a.gw,b.gwszbz from uf_rzxxb a left join uf_gwgl b on a.gw = b.id where a.id = ?",id);
        if (rs.next()) {
            return JobRecord.builder()
                    .id(Util.getIntValue(rs.getString("id")))
                    .resourceId(Util.getIntValue(rs.getString("rzry")))
                    .lastId(Util.getIntValue(rs.getString("sydrzid")))
                    .jobId(Util.getIntValue(rs.getString("gw")))
                    .staffBelong(Util.getIntValue(rs.getString("gwszbz")))
                    .jobType(Util.getIntValue(rs.getString("rzlx")))
                    .build();
        }
        return jobRecord;
    }
}