GroupSyncServiceimpl.java

package com.tianyi.sync.service.impl;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.dynamic.datasource.annotation.DSTransactional;
import com.tianyi.sync.mapper.master.QueryMasterMapper;
import com.tianyi.sync.mapper.slave.GroupSlaveMapper;
import com.tianyi.sync.mapper.slave2.FallGroupSlaveMapper;
import com.tianyi.sync.model.*;
import com.tianyi.sync.service.GroupSyncService;
import com.tianyi.sync.utils.DateUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StopWatch;


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


@Service
public class GroupSyncServiceimpl implements GroupSyncService {

    private final static Logger logger = LoggerFactory.getLogger(GroupSyncServiceimpl.class);

    private final FallGroupSlaveMapper fallGroupSlaveMapper;

    private final QueryMasterMapper queryMasterMapper;

    private final GroupSlaveMapper groupSlaveMapper;

    public GroupSyncServiceimpl(QueryMasterMapper queryMasterMapper, FallGroupSlaveMapper fallGroupSlaveMapper ,GroupSlaveMapper groupSlaveMapper) {
        this.queryMasterMapper = queryMasterMapper;
        this.fallGroupSlaveMapper = fallGroupSlaveMapper;
        this.groupSlaveMapper = groupSlaveMapper;
    }

    @Override
    @DSTransactional
    public Object groupSync() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        JSONObject jsonObject = new JSONObject();
        //String lastMonth = DateUtils.getYearAndMonthLast();
        String lastMonth = "2024-09";
        ParmDataModel parmDataModel = new ParmDataModel();
        parmDataModel.setPeriod(lastMonth);
        String period = parmDataModel.getPeriod();
        parmDataModel.setYear(period.substring(0, 4));
        parmDataModel.setMonth(StringUtils.startsWith(period.substring(5, 7), "0") ? StringUtils.substringAfterLast(period.substring(5, 7), "0") : period.substring(5, 7));
        logger.info("参数:{}", JSON.toJSONString(parmDataModel));
        //先清除表内数据
        fallGroupSlaveMapper.delete(parmDataModel);

        // 执行查询
        List<PlugModel> singlePlugs = groupSlaveMapper.queryPlugAccount("1");
        List<PlugModel> smallPlugs = groupSlaveMapper.queryPlugAccount("3");
        List<PlugModel> doublePlugs = groupSlaveMapper.queryPlugAccount("2");

        // 创建一个Map来存储所有的单边抵映射关系
        Map<String, Map<String, List<String>>> singleMapping = new HashMap<>();
        Map<String, Map<String, List<String>>> smallMapping = new HashMap<>();
        Map<String, Map<String, List<String>>> doubleMapping = new HashMap<>();

        // 处理查询结果
        processPlugList(singlePlugs, singleMapping);
        processPlugList(smallPlugs, smallMapping);
        processPlugList(doublePlugs, doubleMapping);

        // 对 singleMapping 中的每个 accountList 按照 pluggroup 排序
        for (Map<String, List<String>> sideMapping : singleMapping.values()) {
            for (List<String> accountList : sideMapping.values()) {
                // 这里是对 accountList 进行排序，假设每个 PlugModel 的 account 对应的 pluggroup
                accountList.sort(new Comparator<String>() {
                    @Override
                    public int compare(String account1, String account2) {
                        // 获取对应 account 的 pluggroup
                        String pluggroup1 = getPlugGroupForAccount(account1, singlePlugs); // 获取 account1 对应的 pluggroup
                        String pluggroup2 = getPlugGroupForAccount(account2, singlePlugs); // 获取 account2 对应的 pluggroup
                        return pluggroup1.compareTo(pluggroup2); // 按 pluggroup 排序
                    }
                });
            }
        }

        // 单边抵消c3特殊处理
        Map<String, String> C3_02_value = new HashMap<>();
        C3_02_value.put("Inc99", "Dec99");
        C3_02_value.put("PInc02", "PDec0201");
        C3_02_value.put("Inc02", "Dec0201");
        C3_02_value.put("[None]", "[None]");
        C3_02_value.put("MovBeg", "[None]");


        List<GroupDataSyncModel> dataSyncList = new ArrayList<>();
        //单边抵
        // 遍历singleMapping
        for (Map.Entry<String, Map<String, List<String>>> singlMap : singleMapping.entrySet()) {
            Map<String, List<String>> plugData = singlMap.getValue();
            List<String> singlePlug01 = plugData.get("01");
            List<String> singlePlug02 = plugData.get("02");
            List<GroupDataSyncModel> groupSingle01List = queryMasterMapper.queryGroupSingle(lastMonth,singlePlug01);
            for (GroupDataSyncModel model : groupSingle01List) {
                String c1 = model.getC1();
                String c3 = model.getC3();
                String entity = model.getEntity();
                String icp = model.getICP();
                // 根据 key 和 c3、c1 的组合条件，选择合适的处理
                if ("plug18".equals(singlMap.getKey()) && ("Inc99".equals(c3) || "PInc02".equals(c3)|| "Inc02".equals(c3))) {
                    List<GroupDataSyncModel> modelList = processSyncModel(model, singlePlug01, singlePlug02, C3_02_value.get(model.getC3()), null, null);
                    dataSyncList.addAll(modelList);
                } else if ("plug16".equals(singlMap.getKey()) && ("[None]".equals(c3) || "Movbeg".equals(c3))) {
                    List<GroupDataSyncModel> modelList = processSyncModel(model, singlePlug01, singlePlug02, C3_02_value.get(model.getC3()), null, null);
                    dataSyncList.addAll(modelList);
                } else if ("plug29".equals(singlMap.getKey()) && "[None]".equals(c3) && "A01".equals(entity) && "[ICP_None]".equals(icp)) {
                    List<GroupDataSyncModel> modelList = processSyncModel(model, singlePlug01, singlePlug02, C3_02_value.get(model.getC3()), null, null);
                    dataSyncList.addAll(modelList);
                } else if ("plug25".equals(singlMap.getKey()) && "[None]".equals(c3) && !"FM9903".equals(c1) && !"FM9906".equals(c1)) {
                    List<GroupDataSyncModel> modelList = processSyncModel(model, singlePlug01, singlePlug02, C3_02_value.get(model.getC3()), model.getICP(), model.getIcpname());
                    dataSyncList.addAll(modelList);
                }  else if ("[None]".equals(c3)) {
                    List<GroupDataSyncModel> modelList = processSyncModel(model, singlePlug01, singlePlug02, C3_02_value.get(model.getC3()), model.getICP(), model.getIcpname());
                    dataSyncList.addAll(modelList);
                }
            }
        }

        List<GroupDataSyncModel> dataSyncModelList = queryMasterMapper.queryGroupCurrentMonth(parmDataModel);
        //存储以 entity-icp为键的元素列表
        Map<String, List<GroupDataSyncModel>> entityIcpCodeMap = new HashMap<>();
        for (GroupDataSyncModel item : dataSyncModelList) {
            String entityIcpKey = item.getEntity() + "-" + item.getICP();
            entityIcpCodeMap.computeIfAbsent(entityIcpKey, k -> new ArrayList<>()).add(item);
        }
        //以小抵消
        for (Map.Entry<String, Map<String, List<String>>> smallMap : smallMapping.entrySet()) {
            String plugAccount = smallMap.getKey();
            //获取plug两侧科目
            Map<String, List<String>> plugDataMap = smallMap.getValue();
            List<String> plugSide01 = plugDataMap.get("01");
            List<String> plugSinde02 = plugDataMap.get("02");
            //按主体客商执行
            for (Map.Entry<String, List<GroupDataSyncModel>> entry : entityIcpCodeMap.entrySet()) {
                String entityIcpKey = entry.getKey();
                List<GroupDataSyncModel> entityIcpList = entry.getValue();
                // 筛选符合条件的集合
                List<GroupDataSyncModel> filteredList01 = filterEntityList(entityIcpList, plugSide01, plugAccount);
                // 分析键的形式：entityCode-icpCode
                String[] parts = entityIcpKey.split("-");
                String entityCode = parts[0];
                String icpCode = parts[1];
                List<GroupDataSyncModel> icpEntityList = entityIcpCodeMap.get(icpCode + "-" + entityCode);
                // 过滤普通和反转后的客商02侧列表
                List<GroupDataSyncModel> filteredList02 = filterEntityList(icpEntityList, plugSinde02, plugAccount);
                // 计算 money01 和 money02
                Double money01 = calculateTotalMoney(filteredList01);
                Double money02 = calculateTotalMoney(filteredList02);
                if (money01 == 0 || money02 == 0) {
                    continue;
                }
                if (Double.compare(money01, money02) > 0) {
                    // 如果 money01 > money02
                    smallGroupDataSyncList(filteredList01,filteredList02, dataSyncList, money02);
                    dataSyncList.addAll(filteredList02);
                } else if (Double.compare(money01, money02) < 0) {
                    // 如果 money01 < money02
                    dataSyncList.addAll(filteredList01);
                    smallGroupDataSyncList(filteredList02,filteredList01, dataSyncList, money01);
                } else {
                    // 如果 money01 == money02
                    dataSyncList.addAll(filteredList01);
                    dataSyncList.addAll(filteredList02);
                }
            }
        }

        //双边抵消
        //查询164库内数据
        for (Map.Entry<String, Map<String, List<String>>> stringMapEntry : doubleMapping.entrySet()) {
            String plugAccount = stringMapEntry.getKey();
            //plug参数
            boolean isReverse = (plugAccount != null) && (plugAccount.equals("plug11") || plugAccount.equals("plug12") || plugAccount.equals("plug13"));
            String destC1 = (plugAccount != null && plugAccount.equals("plug12")) ? "FC01" : "[None]";
            String destC2 = (plugAccount != null && (plugAccount.equals("plug12") || plugAccount.equals("plug17")
                    || plugAccount.equals("plug21") || plugAccount.equals("plug22") )) ? "SL02" : "[None]";
            destC2 = (plugAccount != null && plugAccount.equals("plug25")) ? "SL01" : destC2;
            //获取plug两侧科目
            Map<String, List<String>> plugDataMap = stringMapEntry.getValue();
            List<String> plugSide01 = plugDataMap.get("01");
            List<String> plugSinde02 = plugDataMap.get("02");
            //按主体客商执行
            for (Map.Entry<String, List<GroupDataSyncModel>> entry : entityIcpCodeMap.entrySet()) {
                String entityIcpKey = entry.getKey();
                List<GroupDataSyncModel> entityIcpList = entry.getValue();
                // 筛选符合条件的集合
                List<GroupDataSyncModel> filteredList01 = filterEntityList(entityIcpList, plugSide01,plugAccount);
                // 分析键的形式：entityCode-icpCode
                String[] parts = entityIcpKey.split("-");
                String entityCode = parts[0];
                String icpCode = parts[1];
                List<GroupDataSyncModel> icpEntityList = entityIcpCodeMap.get(icpCode + "-" + entityCode);
                // 过滤普通和反转后的客商02侧列表
                List<GroupDataSyncModel> filteredList02 = filterEntityList(icpEntityList, plugSinde02,plugAccount);
                // 如果两个集合都为空，跳出循环
                if (filteredList01.isEmpty() && filteredList02.isEmpty()) {
                    continue; // 退出当前循环
                }
                if (plugAccount.equals("plug26")){
                    // 根据 c1 对 filteredList01 和 filteredList02 进行分组
                    Map<String, List<GroupDataSyncModel>> groupedByC1List01 = filteredList01.stream()
                            .collect(Collectors.groupingBy(GroupDataSyncModel::getC1));

                    Map<String, List<GroupDataSyncModel>> groupedByC1List02 = filteredList02.stream()
                            .collect(Collectors.groupingBy(GroupDataSyncModel::getC1));
                    // 计算并打印每个 c1 的 total money
                    Set<String> allC1Keys = new HashSet<>();
                    allC1Keys.addAll(groupedByC1List01.keySet());
                    allC1Keys.addAll(groupedByC1List02.keySet());
                    for (String c1 : allC1Keys) {
                        // 计算 money01 和 money02
                        List<GroupDataSyncModel> list01 = groupedByC1List01.get(c1);
                        List<GroupDataSyncModel> list02 = groupedByC1List02.get(c1);
                        Double money01 = calculateTotalMoney(list01);
                        Double money02 = calculateTotalMoney(list02);
                        dataSyncList.addAll(list01);
                        dataSyncList.addAll(list02);
                        if (isReverse) {
                            // 反向处理：money = money01 - money02
                            addSyncModel(dataSyncList, plugAccount, c1, destC2, entityCode, icpCode, money01 - money02);
                            // 如果 money01 == 0，添加第二个模型
                            if (money01 == 0) {
                                addSyncModel(dataSyncList, plugAccount, c1, destC2, icpCode, entityCode, money01 - money02);
                            }
                        } else {
                            // 正向处理：money = money02 - money01
                            addSyncModel(dataSyncList, plugAccount, c1, destC2, entityCode, icpCode, money02 - money01);
                            // 如果 money01 == 0，添加第二个模型
                            if (money01 == 0) {
                                addSyncModel(dataSyncList, plugAccount, c1, destC2, icpCode, entityCode, money02 - money01);
                            }
                        }
                    }
                }else {
                    // 计算 money01 和 money02
                    Double money01 = calculateTotalMoney(filteredList01);
                    Double money02 = calculateTotalMoney(filteredList02);
                    dataSyncList.addAll(filteredList01);
                    dataSyncList.addAll(filteredList02);
                    if (isReverse) {
                        // 反向处理：money = money01 - money02
                        addSyncModel(dataSyncList, plugAccount, destC1, destC2, entityCode, icpCode, money01 - money02);
                        // 如果 money01 == 0，添加第二个模型
                        if (money01 == 0) {
                            addSyncModel(dataSyncList, plugAccount, destC1, destC2, icpCode, entityCode, money01 - money02);
                        }
                    } else {
                        // 正向处理：money = money02 - money01
                        addSyncModel(dataSyncList, plugAccount, destC1, destC2, entityCode, icpCode, money02 - money01);
                        // 如果 money01 == 0，添加第二个模型
                        if (money01 == 0) {
                            addSyncModel(dataSyncList, plugAccount, destC1, destC2, icpCode, entityCode, money02 - money01);
                        }
                    }
                }
            }
        }



        if (CollectionUtils.isEmpty(dataSyncList)) {
            logger.info("unexpected event {}:",  "未查询到数据!");
            jsonObject.put("description", "未查询到数据!");
            return jsonObject;
        }
        List<GroupFallDataModel> groupFallDataModelList = dataSyncList.stream().map(v -> {
            GroupFallDataModel groupFallDataModel = new GroupFallDataModel();
            BeanUtils.copyProperties(v, groupFallDataModel);
            groupFallDataModel.setAccountcode(v.getAccount());
            groupFallDataModel.setEntitycode(v.getEntity());
            groupFallDataModel.setOrivalue(v.getMoney());
            groupFallDataModel.setICPcode(v.getICP());
            groupFallDataModel.setICPname(v.getIcpname());
            groupFallDataModel.setYtenantId("dmrn1j0i");
            return groupFallDataModel;
        }).collect(Collectors.toList());

        //数据落到96数据库内
        fallGroupSlaveMapper.addAll(groupFallDataModelList);
        jsonObject.put("msg", "数据同步成功!");
        jsonObject.put("code", 200);
        stopWatch.stop();
        logger.info("执行时间:{}", stopWatch.getLastTaskTimeMillis());
        return jsonObject;

    }

    // 处理 PlugModel 列表并将数据填充到对应的 Map 中
    private void processPlugList(List<PlugModel> plugList, Map<String, Map<String, List<String>>> mapping) {
        for (PlugModel plug : plugList) {
            String plugAccount = plug.getPlugaccount();
            String plugSide = plug.getPlugside();
            String account = plug.getAccount();

            // 如果 mapping 中没有 plugAccount，创建一个新的 Map
            if (!mapping.containsKey(plugAccount)) {
                mapping.put(plugAccount, new HashMap<>());
            }

            // 获取 plugAccount 对应的 sideMapping
            Map<String, List<String>> sideMapping = mapping.get(plugAccount);

            // 如果 sideMapping 中没有 plugSide，创建一个新的 List
            if (!sideMapping.containsKey(plugSide)) {
                sideMapping.put(plugSide, new ArrayList<>());
            }

            // 获取 plugSide 对应的 accountList
            List<String> accountList = sideMapping.get(plugSide);

            // 将 account 添加到 accountList 中
            accountList.add(account);
        }
    }

    //单边抵消科目排序
    private String getPlugGroupForAccount(String account, List<PlugModel> plugs) {
        for (PlugModel plug : plugs) {
            if (plug.getAccount().equals(account)) {
                return plug.getPluggroup(); // 返回对应的 pluggroup
            }
        }
        return "";  // 默认返回空字符串
    }

    // 单边抵消方法处理同步数据
    private List<GroupDataSyncModel> processSyncModel(GroupDataSyncModel model, List<String> singlePlug01, List<String> singlePlug02,
                                                      String c3Value, String entity, String entityName) {
        List<GroupDataSyncModel> dataSyncList = new ArrayList<>();
        // 获取对应的 account02
        int index = singlePlug01.indexOf(model.getAccount());
        String account02Value = singlePlug02.get(index);
        //
        GroupDataSyncModel syncModel = new GroupDataSyncModel();
        BeanUtils.copyProperties(model, syncModel);
        syncModel.setAccount(account02Value);
        syncModel.setAccountname(null);
        // 如果 c3 有值，进行设置
        if (c3Value != null) {
            syncModel.setC3(c3Value);
        }
        // 如果 entity 和 entityName 有值，进行设置
        if (entity != null) {
            syncModel.setEntity(entity);
            syncModel.setEntityname(entityName);
            syncModel.setICP(model.getEntity());
            syncModel.setIcpname(model.getEntityname());
        }
        // 设置 C4 的值
        syncModel.setC4("interadj");
        // 将原始数据和同步数据都加入到列表中
        dataSyncList.add(model);  // 添加原始数据
        dataSyncList.add(syncModel);  // 添加同步数据
        return dataSyncList;
    }

    // 过滤实体列表
    private List<GroupDataSyncModel> filterEntityList(List<GroupDataSyncModel> entityIcpList, List<String> plug,String plugAccount) {
        // 如果 entityIcpList 或 plug 为 null，返回空列表或抛出异常
        if (entityIcpList == null || plug == null) {
            return Collections.emptyList();  // 返回空列表
        }

        return entityIcpList.stream()
                .filter(item -> plug.contains(item.getAccount())
                        && "[None]".equals(item.getC3())
                        && ( "plug25".equals(plugAccount) ?
                        ( "FM9903".equals(item.getC1()) || "FM9906".equals(item.getC1()) ) :
                        true )
                        && ( "plug26".equals(plugAccount) ?
                        ( "SM01".equals(item.getC1()) || "SM02".equals(item.getC1()) ) :
                        true ) )
                .collect(Collectors.toList());
    }

    // 通用的求和方法
    private Double calculateTotalMoney(List<GroupDataSyncModel> groupDataList) {
        // 如果集合为空，直接返回 0.0
        if (groupDataList == null || groupDataList.isEmpty()) {
            return 0.0;
        }
        return groupDataList.stream().mapToDouble(data -> {
            try {
                return Double.parseDouble(data.getMoney());
            } catch (NumberFormatException e) {
                return 0.0; // 如果无法转换为 double，返回 0.0
            }
        }).sum();
    }



    private void smallGroupDataSyncList(List<GroupDataSyncModel> filteredList1,List<GroupDataSyncModel> filteredList2, List<GroupDataSyncModel> dataSyncList, double money) {

        // 排序操作只需做一次
        filteredList1.sort((g1, g2) -> g1.getAccount().compareTo(g2.getAccount()));
        filteredList2.sort((g1, g2) -> g1.getAccount().compareTo(g2.getAccount()));
        // 遍历filteredList1，并在filteredList2中查找匹配的元素
        for (int i = filteredList1.size() - 1; i >= 0; i--) {
            GroupDataSyncModel groupData1 = filteredList1.get(i);
            for (int j = filteredList2.size() - 1; j >= 0; j--) {
                GroupDataSyncModel groupData2 = filteredList2.get(j);
                if (groupData1.getMoney() == groupData2.getMoney()) {
                    // 将匹配的值添加到dataSyncList中
                    dataSyncList.add(groupData1);

                    // 从filteredList1和filteredList2中移除已匹配的元素
                    filteredList1.remove(i);
                    filteredList2.remove(j);

                    // 更新money值
                    money -= Double.parseDouble(groupData1.getMoney());

                    // 跳出内层循环，继续处理filteredList2中的下一个元素
                    break;
                }
            }
        }
        if (money >= 0) {
            for (GroupDataSyncModel model : filteredList1) {
                double accountMoney = Double.parseDouble(model.getMoney());

                if (accountMoney <= money) {
                    dataSyncList.add(model);
                    money -= accountMoney;
                    if (money == 0) {
                        break;
                    }
                } else {
                    GroupDataSyncModel syncModel = new GroupDataSyncModel();
                    BeanUtils.copyProperties(model, syncModel);
                    syncModel.setC4("interadj");
                    syncModel.setMoney(String.valueOf(money));
                    dataSyncList.add(syncModel);
                    money = 0; // 直接设置 money02 为 0，避免不必要的计算
                    break;
                }
            }
        }
    }

    private void addSyncModel(List<GroupDataSyncModel> dataSyncList, String plugAccount,
                              String destC1, String destC2, String entityCode,
                              String icpCode, double money) {
        GroupDataSyncModel syncModel = new GroupDataSyncModel();
        syncModel.setAccount(plugAccount);
        syncModel.setICP("[ICP_None]");
        syncModel.setC1(destC1);
        syncModel.setC2(destC2);
        syncModel.setC3("[None]");
        syncModel.setC4("Interadj");
        syncModel.setEntity(entityCode);
        syncModel.setICP(icpCode);
        syncModel.setMoney(String.valueOf(money));
        dataSyncList.add(syncModel);
    }
}