package com.rj.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.rj.entity.LbDailyUserTrade;
import com.rj.entity.LbDailyUserTradeReport;
import com.rj.entity.LbDepartmentUser;
import com.rj.mapper.LbDailyUserTradeMapper;
import com.rj.mapper.LbDailyUserTradeReportMapper;
import com.rj.service.ILbDailyUserTradeReportService;
import com.rj.service.ILbDepartmentUserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

/**
 * <p>
 * 当天用户交易报表 服务实现类
 * </p>
 */
@Service
public class LbDailyUserTradeReportServiceImpl extends ServiceImpl<LbDailyUserTradeReportMapper, LbDailyUserTradeReport>
        implements ILbDailyUserTradeReportService {

    private static final Logger log = LoggerFactory.getLogger(LbDailyUserTradeReportServiceImpl.class);
    private static final String DATA_TYPE_REPORT_SUM = "report_sum";
    private static final String DATA_TYPE_REPORT_DETAIL = "report_detail";
    private static final BigDecimal CROSS_DAY_DIFF_TOLERANCE = new BigDecimal("3");

    @Autowired
    private ILbDepartmentUserService lbDepartmentUserService;
    @Autowired
    private LbDailyUserTradeMapper lbDailyUserTradeMapper;

    @Override
    public Page<LbDailyUserTrade> pageDailyUserTradeByUserIdAndDateRange(
            LocalDate startDate, LocalDate endDate, String userId, Integer current, Integer size) {
        LambdaQueryWrapper<LbDailyUserTrade> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(LbDailyUserTrade::getUserId, userId.trim())
                .ge(LbDailyUserTrade::getReportDate, startDate)
                .le(LbDailyUserTrade::getReportDate, endDate)
                .orderByDesc(LbDailyUserTrade::getReportDate)
                .orderByDesc(LbDailyUserTrade::getCreatedAt);
        return lbDailyUserTradeMapper.selectPage(new Page<>(current, size), queryWrapper);
    }

    @Override
    public Page<LbDailyUserTrade> pageDailyUserTradeByParentIdOfUserAndDateRange(
            LocalDate startDate, LocalDate endDate, String userId, Integer current, Integer size) {
        LambdaQueryWrapper<LbDepartmentUser> departmentUserQueryWrapper = new LambdaQueryWrapper<>();
        departmentUserQueryWrapper.eq(LbDepartmentUser::getUserId, userId.trim())
                .orderByDesc(LbDepartmentUser::getUpdateTime)
                .orderByDesc(LbDepartmentUser::getCreateTime)
                .last("limit 1");
        LbDepartmentUser departmentUser = lbDepartmentUserService.getOne(departmentUserQueryWrapper, false);
        if (departmentUser == null || departmentUser.getParentId() == null || departmentUser.getParentId().trim().isEmpty()) {
            throw new IllegalArgumentException("未查询到该用户对应的parentId");
        }

        String parentId = departmentUser.getParentId().trim();
        LambdaQueryWrapper<LbDailyUserTrade> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(LbDailyUserTrade::getUserId, parentId)
                .ge(LbDailyUserTrade::getReportDate, startDate)
                .le(LbDailyUserTrade::getReportDate, endDate)
                .orderByDesc(LbDailyUserTrade::getReportDate)
                .orderByDesc(LbDailyUserTrade::getCreatedAt);
        return lbDailyUserTradeMapper.selectPage(new Page<>(current, size), queryWrapper);
    }

    @Override
    public Map<String, Object> calculateReportSumByDateAndTenant(LocalDate reportDate, String tenantId) {
        Map<String, Object> result = new HashMap<>();
        LocalDateTime start = reportDate.atStartOfDay();
        LocalDateTime end = reportDate.plusDays(1).atStartOfDay();

        LambdaQueryWrapper<LbDailyUserTradeReport> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(LbDailyUserTradeReport::getTenantId, tenantId)
                .ge(LbDailyUserTradeReport::getReportDate, start)
                .lt(LbDailyUserTradeReport::getReportDate, end)
                .eq(LbDailyUserTradeReport::getDataType, DATA_TYPE_REPORT_DETAIL);

        BigDecimal yestodayBuyAmt = BigDecimal.ZERO;
        BigDecimal dailySellAmt = BigDecimal.ZERO;
        BigDecimal dailyBuyAmt = BigDecimal.ZERO;
        BigDecimal serviceAmt = BigDecimal.ZERO;
        BigDecimal diffAmt = BigDecimal.ZERO;
        BigDecimal dikouAmt = BigDecimal.ZERO;

        for (LbDailyUserTradeReport item : list(queryWrapper)) {
            yestodayBuyAmt = yestodayBuyAmt.add(defaultZero(item.getYestodayBuyAmt()));
            dailySellAmt = dailySellAmt.add(defaultZero(item.getDailySellAmt()));
            dailyBuyAmt = dailyBuyAmt.add(defaultZero(item.getDailyBuyAmt()));
            serviceAmt = serviceAmt.add(defaultZero(item.getServiceAmt()));
            diffAmt = diffAmt.add(defaultZero(item.getDiffAmt()));
            dikouAmt = dikouAmt.add(defaultZero(item.getDikouAmt()));
        }

        LbDailyUserTradeReport summary = new LbDailyUserTradeReport();
        summary.setId(UUID.randomUUID().toString());

        summary.setTenantId(tenantId);
        summary.setDataType(DATA_TYPE_REPORT_SUM);
        summary.setReportDate(start);
        summary.setYestodayBuyAmt(yestodayBuyAmt);
        summary.setDailySellAmt(dailySellAmt);
        summary.setDailyBuyAmt(dailyBuyAmt);
        summary.setServiceAmt(serviceAmt);
        summary.setDiffAmt(diffAmt);
        summary.setDikouAmt(dikouAmt);
        summary.setActualReceiptsPayments(diffAmt.subtract(serviceAmt));
        summary.setDescContent("系统汇总记录");
        summary.setCreatedAt(LocalDateTime.now());
        summary.setUpdatedAt(LocalDateTime.now());

        // 同日重复汇总时先清理历史汇总，避免 report_sum 产生多条导致读取口径不稳定。
        LambdaQueryWrapper<LbDailyUserTradeReport> sumDeleteWrapper = new LambdaQueryWrapper<>();
        sumDeleteWrapper.eq(LbDailyUserTradeReport::getTenantId, tenantId)
                .ge(LbDailyUserTradeReport::getReportDate, start)
                .lt(LbDailyUserTradeReport::getReportDate, end)
                .eq(LbDailyUserTradeReport::getDataType, DATA_TYPE_REPORT_SUM);
        remove(sumDeleteWrapper);

        boolean success = save(summary);
        Map<String, Object> checkInfo = buildCrossDayCheckInfo(reportDate, tenantId, start, end, yestodayBuyAmt);
        if (success && refreshSummaryFromDetail(summary, tenantId, start, end)) {
            checkInfo.put("summaryRefreshed", true);
        }

        result.put("success", success);
        if (success) {
            result.put("message", "汇总成功");
            result.put("data", summary);
            result.put("checkInfo", checkInfo);
            return result;
        }
        result.put("message", "汇总失败");
        return result;
    }

    private Map<String, Object> buildCrossDayCheckInfo(
            LocalDate reportDate,
            String tenantId,
            LocalDateTime todayStart,
            LocalDateTime todayEnd,
            BigDecimal todayYestodayBuyAmt) {
        Map<String, Object> checkInfo = new LinkedHashMap<>();
        LocalDate yesterdayDate = reportDate.minusDays(1);
        LocalDateTime yesterdayStart = yesterdayDate.atStartOfDay();
        LocalDateTime yesterdayEnd = reportDate.atStartOfDay();
        BigDecimal tolerance = CROSS_DAY_DIFF_TOLERANCE;
        log.info("cross-day check started, tenantId={}, reportDate={}, yesterdayRange=[{},{}), todayRange=[{},{})",
                tenantId, reportDate, yesterdayStart, yesterdayEnd, todayStart, todayEnd);

        LbDailyUserTradeReport yesterdaySum = queryYesterdaySummary(tenantId, yesterdayStart, yesterdayEnd);
        if (yesterdaySum == null) {
            log.warn("cross-day check skipped: yesterday summary not found, tenantId={}, reportDate={}", tenantId, reportDate);
            checkInfo.put("yesterdaySumFound", false);
            checkInfo.put("needDetailCheck", false);
            checkInfo.put("detailCheckPassed", false);
            return checkInfo;
        }

        BigDecimal yesterdaySumBuyTotal = defaultZero(yesterdaySum.getDailyBuyAmt());
        BigDecimal sumDiff = yesterdaySumBuyTotal.subtract(defaultZero(todayYestodayBuyAmt)).abs();
        checkInfo.put("yesterdaySumFound", true);
        checkInfo.put("yesterdaySumBuyTotal", yesterdaySumBuyTotal);
        checkInfo.put("todayYestodayBuyAmt", todayYestodayBuyAmt);
        checkInfo.put("sumDiff", sumDiff);
        checkInfo.put("threshold", tolerance);
        log.info("cross-day summary compared, tenantId={}, reportDate={}, yesterdaySumBuyTotal={}, todayYestodayBuyAmt={}, diff={}, threshold={}",
                tenantId, reportDate, yesterdaySumBuyTotal, todayYestodayBuyAmt, sumDiff, tolerance);

        if (sumDiff.compareTo(tolerance) <= 0) {
            log.info("cross-day summary within threshold, skip detail check, tenantId={}, reportDate={}", tenantId, reportDate);
            checkInfo.put("needDetailCheck", false);
            checkInfo.put("detailCheckPassed", true);
            return checkInfo;
        }

        log.warn("cross-day summary exceeded threshold, start detail repair/check, tenantId={}, reportDate={}, diff={}",
                tenantId, reportDate, sumDiff);
        List<LbDailyUserTradeReport> yesterdayDetailList = queryDetailRows(tenantId, yesterdayStart, yesterdayEnd);
        List<LbDailyUserTradeReport> todayDetailList = queryDetailRows(tenantId, todayStart, todayEnd);
        log.info("detail rows loaded, tenantId={}, yesterdayCount={}, todayCount={}",
                tenantId, yesterdayDetailList.size(), todayDetailList.size());

        Map<String, BigDecimal> yesterdayAmtByUserId = buildAmountByUserId(yesterdayDetailList, true);
        DetailRepairStat repairStat = repairTodayDetailByYesterday(yesterdayDetailList, todayDetailList, tenantId, todayStart);
        checkInfo.put("autoRepaired", repairStat.repaired);
        checkInfo.put("updatedTodayRows", repairStat.updatedCount);
        checkInfo.put("insertedTodayRows", repairStat.insertedCount);
        log.info("detail repair finished, tenantId={}, repaired={}, updatedRows={}, insertedRows={}",
                tenantId, repairStat.repaired, repairStat.updatedCount, repairStat.insertedCount);

        // 修正后重新读取今天明细并复核结果。
        List<LbDailyUserTradeReport> repairedTodayDetailList = queryDetailRows(tenantId, todayStart, todayEnd);
        Map<String, BigDecimal> repairedTodayAmtByUserId = buildAmountByUserId(repairedTodayDetailList, false);
        fillDetailCheckResult(checkInfo, yesterdayAmtByUserId, repairedTodayAmtByUserId, yesterdayDetailList.size(), repairedTodayDetailList.size());

        @SuppressWarnings("unchecked")
        List<Map<String, Object>> mismatchUsers = (List<Map<String, Object>>) checkInfo.get("mismatchUsers");
        @SuppressWarnings("unchecked")
        List<String> missingInTodayUsers = (List<String>) checkInfo.get("missingInTodayUsers");
        @SuppressWarnings("unchecked")
        List<String> extraInTodayUsers = (List<String>) checkInfo.get("extraInTodayUsers");

        if (!mismatchUsers.isEmpty() || !missingInTodayUsers.isEmpty() || !extraInTodayUsers.isEmpty()) {
            log.warn("trade report detail check failed, tenantId={}, reportDate={}, sumDiff={}, mismatchCount={}, missingCount={}, extraCount={}",
                    tenantId, reportDate, sumDiff, mismatchUsers.size(), missingInTodayUsers.size(), extraInTodayUsers.size());
        } else {
            log.info("trade report detail check passed after repair, tenantId={}, reportDate={}, sumDiff={}",
                    tenantId, reportDate, sumDiff);
        }
        return checkInfo;
    }

    private LbDailyUserTradeReport queryYesterdaySummary(String tenantId, LocalDateTime yesterdayStart, LocalDateTime yesterdayEnd) {
        LambdaQueryWrapper<LbDailyUserTradeReport> query = new LambdaQueryWrapper<>();
        query.eq(LbDailyUserTradeReport::getTenantId, tenantId)
                .ge(LbDailyUserTradeReport::getReportDate, yesterdayStart)
                .lt(LbDailyUserTradeReport::getReportDate, yesterdayEnd)
                .eq(LbDailyUserTradeReport::getDataType, DATA_TYPE_REPORT_SUM)
                .orderByDesc(LbDailyUserTradeReport::getUpdatedAt)
                .orderByDesc(LbDailyUserTradeReport::getCreatedAt)
                .last("limit 1");
        List<LbDailyUserTradeReport> rows = list(query);
        return rows.isEmpty() ? null : rows.get(0);
    }

    private boolean refreshSummaryFromDetail(
            LbDailyUserTradeReport summary,
            String tenantId,
            LocalDateTime start,
            LocalDateTime end) {
        TradeSummaryAmount latest = aggregateDetailAmounts(tenantId, start, end);
        boolean changed = isSummaryChanged(summary, latest);
        if (!changed) {
            return false;
        }
        summary.setYestodayBuyAmt(latest.yestodayBuyAmt);
        summary.setDailySellAmt(latest.dailySellAmt);
        summary.setDailyBuyAmt(latest.dailyBuyAmt);
        summary.setServiceAmt(latest.serviceAmt);
        summary.setDiffAmt(latest.diffAmt);
        summary.setDikouAmt(latest.dikouAmt);
        summary.setActualReceiptsPayments(latest.diffAmt.subtract(latest.serviceAmt));
        summary.setUpdatedAt(LocalDateTime.now());
        updateById(summary);
        return true;
    }

    private TradeSummaryAmount aggregateDetailAmounts(String tenantId, LocalDateTime start, LocalDateTime end) {
        LambdaQueryWrapper<LbDailyUserTradeReport> detailQuery = new LambdaQueryWrapper<>();
        detailQuery.eq(LbDailyUserTradeReport::getTenantId, tenantId)
                .ge(LbDailyUserTradeReport::getReportDate, start)
                .lt(LbDailyUserTradeReport::getReportDate, end)
                .eq(LbDailyUserTradeReport::getDataType, DATA_TYPE_REPORT_DETAIL);

        TradeSummaryAmount amount = new TradeSummaryAmount();
        for (LbDailyUserTradeReport row : list(detailQuery)) {
            amount.yestodayBuyAmt = amount.yestodayBuyAmt.add(defaultZero(row.getYestodayBuyAmt()));
            amount.dailySellAmt = amount.dailySellAmt.add(defaultZero(row.getDailySellAmt()));
            amount.dailyBuyAmt = amount.dailyBuyAmt.add(defaultZero(row.getDailyBuyAmt()));
            amount.serviceAmt = amount.serviceAmt.add(defaultZero(row.getServiceAmt()));
            amount.diffAmt = amount.diffAmt.add(defaultZero(row.getDiffAmt()));
            amount.dikouAmt = amount.dikouAmt.add(defaultZero(row.getDikouAmt()));
        }
        return amount;
    }

    private boolean isSummaryChanged(LbDailyUserTradeReport summary, TradeSummaryAmount latest) {
        return defaultZero(summary.getYestodayBuyAmt()).compareTo(latest.yestodayBuyAmt) != 0
                || defaultZero(summary.getDailySellAmt()).compareTo(latest.dailySellAmt) != 0
                || defaultZero(summary.getDailyBuyAmt()).compareTo(latest.dailyBuyAmt) != 0
                || defaultZero(summary.getServiceAmt()).compareTo(latest.serviceAmt) != 0
                || defaultZero(summary.getDiffAmt()).compareTo(latest.diffAmt) != 0
                || defaultZero(summary.getDikouAmt()).compareTo(latest.dikouAmt) != 0;
    }

    private List<LbDailyUserTradeReport> queryDetailRows(String tenantId, LocalDateTime start, LocalDateTime end) {
        LambdaQueryWrapper<LbDailyUserTradeReport> query = new LambdaQueryWrapper<>();
        query.eq(LbDailyUserTradeReport::getTenantId, tenantId)
                .ge(LbDailyUserTradeReport::getReportDate, start)
                .lt(LbDailyUserTradeReport::getReportDate, end)
                .eq(LbDailyUserTradeReport::getDataType, DATA_TYPE_REPORT_DETAIL);
        return list(query);
    }

    private Map<String, BigDecimal> buildAmountByUserId(List<LbDailyUserTradeReport> detailRows, boolean useDailyBuyAmt) {
        Map<String, BigDecimal> amountByUserId = new HashMap<>();
        for (LbDailyUserTradeReport row : detailRows) {
            if (row.getUserId() == null || row.getUserId().trim().isEmpty()) {
                continue;
            }
            String userId = row.getUserId().trim();
            BigDecimal amount = useDailyBuyAmt ? defaultZero(row.getDailyBuyAmt()) : defaultZero(row.getYestodayBuyAmt());
            amountByUserId.merge(userId, amount, BigDecimal::add);
        }
        return amountByUserId;
    }

    private DetailRepairStat repairTodayDetailByYesterday(
            List<LbDailyUserTradeReport> yesterdayDetailList,
            List<LbDailyUserTradeReport> todayDetailList,
            String tenantId,
            LocalDateTime todayStart) {
        // Step1: 先把“昨天每个用户应有金额”聚合好，作为今天修正目标。
        Map<String, BigDecimal> yesterdayAmtByUserId = new HashMap<>();
        Map<String, LbDailyUserTradeReport> yesterdaySampleByUserId = new HashMap<>();
        for (LbDailyUserTradeReport row : yesterdayDetailList) {
            if (row.getUserId() == null || row.getUserId().trim().isEmpty()) {
                continue;
            }
            String userId = row.getUserId().trim();
            yesterdayAmtByUserId.merge(userId, defaultZero(row.getDailyBuyAmt()), BigDecimal::add);
            yesterdaySampleByUserId.putIfAbsent(userId, row);
        }

        // Step2: 对今天明细建立 userId -> rows 映射，便于 O(1) 找到待修正记录。
        Map<String, List<LbDailyUserTradeReport>> todayRowsByUserId = new HashMap<>();
        for (LbDailyUserTradeReport row : todayDetailList) {
            if (row.getUserId() == null || row.getUserId().trim().isEmpty()) {
                continue;
            }
            String userId = row.getUserId().trim();
            todayRowsByUserId.computeIfAbsent(userId, k -> new ArrayList<>()).add(row);
        }

        List<LbDailyUserTradeReport> rowsToUpdate = new ArrayList<>();
        List<LbDailyUserTradeReport> rowsToInsert = new ArrayList<>();
        LocalDateTime now = LocalDateTime.now();
        int duplicateRowZeroedCount = 0;

        // Step3: 以“昨天聚合金额”为唯一标准回写今天数据。
        for (Map.Entry<String, BigDecimal> entry : yesterdayAmtByUserId.entrySet()) {
            String userId = entry.getKey();
            BigDecimal expectedAmt = defaultZero(entry.getValue());
            List<LbDailyUserTradeReport> todayRows = todayRowsByUserId.get(userId);

            if (todayRows == null || todayRows.isEmpty()) {
                LbDailyUserTradeReport source = yesterdaySampleByUserId.get(userId);
                LbDailyUserTradeReport inserted = new LbDailyUserTradeReport();
                inserted.setId(UUID.randomUUID().toString());
                inserted.setTenantId(tenantId);
                inserted.setUserId(userId);
                inserted.setNickname(source == null ? null : source.getNickname());
                inserted.setDataType(DATA_TYPE_REPORT_DETAIL);
                inserted.setReportDate(todayStart);
                inserted.setYestodayBuyAmt(expectedAmt);
                inserted.setDailySellAmt(BigDecimal.ZERO);
                inserted.setDailyBuyAmt(BigDecimal.ZERO);
                inserted.setServiceAmt(BigDecimal.ZERO);
                inserted.setDiffAmt(BigDecimal.ZERO);
                inserted.setDikouAmt(BigDecimal.ZERO);
                inserted.setActualReceiptsPayments(BigDecimal.ZERO);
                inserted.setDescContent("系统按昨日数据自动修正");
                inserted.setCreatedAt(now);
                inserted.setUpdatedAt(now);
                rowsToInsert.add(inserted);
                log.info("detail repair insert row, tenantId={}, userId={}, expectedAmt={}", tenantId, userId, expectedAmt);
                continue;
            }

            LbDailyUserTradeReport first = todayRows.get(0);
            if (defaultZero(first.getYestodayBuyAmt()).compareTo(expectedAmt) != 0) {
                first.setYestodayBuyAmt(expectedAmt);
                first.setUpdatedAt(now);
                rowsToUpdate.add(first);
                log.info("detail repair update row, tenantId={}, userId={}, rowId={}, expectedAmt={}",
                        tenantId, userId, first.getId(), expectedAmt);
            }
            for (int i = 1; i < todayRows.size(); i++) {
                LbDailyUserTradeReport extra = todayRows.get(i);
                if (defaultZero(extra.getYestodayBuyAmt()).compareTo(BigDecimal.ZERO) != 0) {
                    extra.setYestodayBuyAmt(BigDecimal.ZERO);
                    extra.setUpdatedAt(now);
                    rowsToUpdate.add(extra);
                    duplicateRowZeroedCount++;
                }
            }
        }

        boolean repaired = false;
        if (!rowsToUpdate.isEmpty()) {
            saveOrUpdateBatch(rowsToUpdate);
            repaired = true;
        }
        if (!rowsToInsert.isEmpty()) {
            saveBatch(rowsToInsert);
            repaired = true;
        }
        log.info("detail repair summary, tenantId={}, targetUserCount={}, updatedRows={}, insertedRows={}, duplicateRowsZeroed={}",
                tenantId, yesterdayAmtByUserId.size(), rowsToUpdate.size(), rowsToInsert.size(), duplicateRowZeroedCount);
        return new DetailRepairStat(repaired, rowsToUpdate.size(), rowsToInsert.size());
    }

    private void fillDetailCheckResult(
            Map<String, Object> checkInfo,
            Map<String, BigDecimal> yesterdayAmtByUserId,
            Map<String, BigDecimal> todayAmtByUserId,
            int yesterdayDetailCount,
            int todayDetailCount) {
        List<Map<String, Object>> mismatchUsers = new ArrayList<>();
        List<String> missingInTodayUsers = new ArrayList<>();
        List<String> extraInTodayUsers = new ArrayList<>();
        Set<String> allUserIds = new HashSet<>(yesterdayAmtByUserId.keySet());
        allUserIds.addAll(todayAmtByUserId.keySet());

        for (String userId : allUserIds) {
            BigDecimal yesterdayUserAmt = yesterdayAmtByUserId.get(userId);
            BigDecimal todayUserAmt = todayAmtByUserId.get(userId);

            if (yesterdayUserAmt == null && todayUserAmt != null) {
                extraInTodayUsers.add(userId);
                continue;
            }
            if (yesterdayUserAmt != null && todayUserAmt == null) {
                missingInTodayUsers.add(userId);
                continue;
            }
            BigDecimal userDiff = defaultZero(yesterdayUserAmt).subtract(defaultZero(todayUserAmt)).abs();
            if (userDiff.compareTo(BigDecimal.ZERO) > 0) {
                Map<String, Object> mismatch = new LinkedHashMap<>();
                mismatch.put("userId", userId);
                mismatch.put("yesterdayAmt", yesterdayUserAmt);
                mismatch.put("todayAmt", todayUserAmt);
                mismatch.put("diff", userDiff);
                mismatchUsers.add(mismatch);
            }
        }

        checkInfo.put("needDetailCheck", true);
        checkInfo.put("yesterdayDetailCount", yesterdayDetailCount);
        checkInfo.put("todayDetailCount", todayDetailCount);
        checkInfo.put("mismatchUsers", mismatchUsers);
        checkInfo.put("missingInTodayUsers", missingInTodayUsers);
        checkInfo.put("extraInTodayUsers", extraInTodayUsers);
        checkInfo.put("detailCheckPassed", mismatchUsers.isEmpty() && missingInTodayUsers.isEmpty() && extraInTodayUsers.isEmpty());
    }

    private static final class DetailRepairStat {
        final boolean repaired;
        final int updatedCount;
        final int insertedCount;

        DetailRepairStat(boolean repaired, int updatedCount, int insertedCount) {
            this.repaired = repaired;
            this.updatedCount = updatedCount;
            this.insertedCount = insertedCount;
        }
    }

    private static final class TradeSummaryAmount {
        BigDecimal yestodayBuyAmt = BigDecimal.ZERO;
        BigDecimal dailySellAmt = BigDecimal.ZERO;
        BigDecimal dailyBuyAmt = BigDecimal.ZERO;
        BigDecimal serviceAmt = BigDecimal.ZERO;
        BigDecimal diffAmt = BigDecimal.ZERO;
        BigDecimal dikouAmt = BigDecimal.ZERO;
    }

    private static BigDecimal defaultZero(BigDecimal value) {
        return value == null ? BigDecimal.ZERO : value;
    }

    @Override
    /**
     * 按日期范围统计“本人 + 递归团队”的交易金额。
     *
     * 设计说明：
     * 1) 先用交易报表圈定“本次需要返回”的用户集合（scopeUserIds），并聚合每个用户 own 金额；
     * 2) 再用部门关系构建 parentUserId -> childrenUserIds 的树；
     * 3) 对 scope 中每个用户递归汇总 team 金额（不含本人）；
     * 4) 返回 own/team/total 三套字段，便于前端直接展示。
     *
     * 注意：
     * - 交易报表必须带 tenant 过滤，否则会混入其他租户用户导致层级结果异常；
     * - lb_department_user.parent_id 在历史数据中可能是“父user_id”或“父记录id(UUID)”，此处做兼容解析。
     */
    public Map<String, Object> listUserTradeAmountWithTeamByDateRangeAndTenant(
            LocalDate startDate, LocalDate endDate, String tenantId) {
        Map<String, Object> result = new HashMap<>();
        if (tenantId == null || tenantId.trim().isEmpty()) {
            result.put("success", false);
            result.put("message", "tenantId不能为空");
            return result;
        }
        if (startDate == null || endDate == null) {
            result.put("success", false);
            result.put("message", "开始日期和结束日期不能为空");
            return result;
        }
        if (endDate.isBefore(startDate)) {
            result.put("success", false);
            result.put("message", "结束日期不能早于开始日期");
            return result;
        }

        String tenantIdTrim = tenantId.trim();
        LocalDateTime rangeStart = startDate.atStartOfDay();
        LocalDateTime rangeEnd = endDate.atTime(23, 59, 59);

        // 1) 先查 lb_daily_user_trade_report：
        //    - 仅取当前租户 + 指定日期范围 + report_detail；
        //    - 用于圈定返回范围（scopeUserIds）；
        //    - 同时把本人四类金额先聚合好（ownAmtByUserId）。
        LambdaQueryWrapper<LbDailyUserTradeReport> tradeQw = new LambdaQueryWrapper<>();
        tradeQw.ge(LbDailyUserTradeReport::getReportDate, rangeStart)
                .le(LbDailyUserTradeReport::getReportDate, rangeEnd)
                .eq(LbDailyUserTradeReport::getTenantId, tenantIdTrim)
                .eq(LbDailyUserTradeReport::getDataType, DATA_TYPE_REPORT_DETAIL );

        // userId -> 姓名，优先用报表昵称，后续再用部门姓名补齐。
        Map<String, String> userIdToName = new HashMap<>();
        // userId -> 本人金额汇总（own）。
        Map<String, TradeAmtBundle> ownAmtByUserId = new HashMap<>();
        List<LbDailyUserTradeReport> list1 = list(tradeQw);

        for (LbDailyUserTradeReport r : list1) {
            if (r.getUserId() == null || r.getUserId().trim().isEmpty()) {
                continue;
            }
            String uid = r.getUserId().trim();
            ownAmtByUserId
                    .computeIfAbsent(uid, k -> TradeAmtBundle.zeros())
                    .addFromReportRow(r);
            if (r.getNickname() != null && !r.getNickname().trim().isEmpty()) {
                userIdToName.putIfAbsent(uid, r.getNickname().trim());
            }
        }

        if (ownAmtByUserId.isEmpty()) {
            result.put("success", true);
            result.put("message", "查询成功");
            result.put("data", List.of());
            result.put("total", 0);
            result.put("startDate", startDate);
            result.put("endDate", endDate);
            result.put("tenantId", tenantIdTrim);
            return result;
        }

        // 最终只返回这些用户（报表范围内“有交易数据”的用户）。
        Set<String> scopeUserIds = new HashSet<>(ownAmtByUserId.keySet());

        // 2) 再查 lb_department_user，构建上下级关系：
        //    目标结构：childrenByParentUserId[parentUserId] = [childUserId...]
        //    兼容 parent_id 两种格式：
        //    - 直接存父 user_id；
        //    - 存父记录 id(UUID)，需先反查成父 user_id。
        Map<String, List<String>> childrenByParentUserId = new HashMap<>();
        // childUserId -> parentUserId，用于后续把平铺数据组装成树。
        Map<String, String> parentByUserId = new HashMap<>();
        List<LbDepartmentUser> deptUsers = lbDepartmentUserService.list(
                new LambdaQueryWrapper<LbDepartmentUser>()
                        .eq(LbDepartmentUser::getTenantId, tenantIdTrim));
        if (deptUsers != null) {
            // 预处理索引：
            // - userIdByRecordId: 记录id(UUID) -> userId
            // - allUserIds: 全部 userId（用于判断 parent_id 是否已是 userId）
            Map<String, String> userIdByRecordId = new HashMap<>();
            Set<String> allUserIds = new HashSet<>();
            for (LbDepartmentUser row : deptUsers) {
                String rowId = row.getId() == null ? null : row.getId().trim();
                String uid = row.getUserId() == null ? null : row.getUserId().trim();
                if (uid == null || uid.isEmpty()) {
                    continue;
                }
                allUserIds.add(uid);
                if (rowId != null && !rowId.isEmpty()) {
                    userIdByRecordId.put(rowId, uid);
                }
            }
            for (LbDepartmentUser row : deptUsers) {
                if (row.getUserId() == null || row.getUserId().trim().isEmpty()) {
                    continue;
                }
                String uid = row.getUserId().trim();
                if (row.getName() != null && !row.getName().trim().isEmpty()) {
                    userIdToName.putIfAbsent(uid, row.getName().trim());
                }
                // parentRef 可能是“父userId”或“父记录id”，不要直接假设其一定是 userId。
                String parentRef = row.getParentId() == null ? null : row.getParentId().trim();
                if (parentRef != null && !parentRef.isEmpty()) {
                    String parentUserId = null;
                    String resolvedBy = null;
                    // case A：parent_id 本身就是父 userId
                    if (allUserIds.contains(parentRef)) {
                        parentUserId = parentRef;
                        resolvedBy = "parent_user_id";
                    // case B：parent_id 是父记录id(UUID)，反查映射到父 userId
                    } else if (userIdByRecordId.containsKey(parentRef)) {
                        parentUserId = userIdByRecordId.get(parentRef);
                        resolvedBy = "parent_record_id";
                    }
                    // 两种都解析失败：说明关系数据不完整/不一致，记录日志便于排查。
                    if (parentUserId == null || parentUserId.isEmpty()) {
                        log.warn("dept relation parent unresolved, tenantId={}, userId={}, name={}, parentId={}",
                                tenantIdTrim, uid, row.getName(), parentRef);
                        continue;
                    }
                    List<String> ch = childrenByParentUserId.computeIfAbsent(parentUserId, k -> new ArrayList<>());
                    if (!ch.contains(uid)) {
                        ch.add(uid);
                    }
                    // 若同一个子节点出现多次，保留第一次解析到的父节点，避免树结构抖动。
                    parentByUserId.putIfAbsent(uid, parentUserId);
                    // 针对已知问题用户打定位日志，便于验证 parent_id 解析是否正确。
                    if ("98155".equals(uid) || "杨渺渺".equals(row.getName())) {
                        log.info("dept relation resolved for focus user, tenantId={}, userId={}, name={}, parentId={}, parentUserId={}, resolvedBy={}",
                                tenantIdTrim, uid, row.getName(), parentRef, parentUserId, resolvedBy);
                    }
                }
            }
            for (List<String> list : childrenByParentUserId.values()) {
                list.sort(String::compareTo);
            }
        }

        // 3) 对 scope 用户计算递归 team 金额：
        //    - team = 所有下级 own + 下级的 team（不含本人）；
        //    - 使用 memo 缓存避免重复递归。
        Map<String, TradeAmtBundle> teamAmtMemo = new HashMap<>();
        for (String userId : scopeUserIds) {
            teamAmtRecursive(userId, childrenByParentUserId, ownAmtByUserId, teamAmtMemo, new HashSet<>());
        }

        // 4) 先组装平铺结果，保持 own/team/total 三套字段并按 totalDiffAmt 倒序。
        List<Map<String, Object>> rows = new ArrayList<>();
        for (String userId : scopeUserIds) {
            TradeAmtBundle own = ownAmt(userId, ownAmtByUserId);
            TradeAmtBundle team = teamAmt(userId, teamAmtMemo);
            TradeAmtBundle total = own.addCopy(team);
            Map<String, Object> row = new LinkedHashMap<>();
            row.put("userId", userId);
            row.put("name", userIdToName.getOrDefault(userId, ""));
            row.put("ownYestodayBuyAmt", own.yestodayBuyAmt);
            row.put("teamYestodayBuyAmt", team.yestodayBuyAmt);
            row.put("totalYestodayBuyAmt", total.yestodayBuyAmt);
            row.put("ownDailySellAmt", own.dailySellAmt);
            row.put("teamDailySellAmt", team.dailySellAmt);
            row.put("totalDailySellAmt", total.dailySellAmt);
            row.put("ownDailyBuyAmt", own.dailyBuyAmt);
            row.put("teamDailyBuyAmt", team.dailyBuyAmt);
            row.put("totalDailyBuyAmt", total.dailyBuyAmt);
            row.put("ownDiffAmt", own.diffAmt);
            row.put("teamDiffAmt", team.diffAmt);
            row.put("totalDiffAmt", total.diffAmt);
            // children 用于前端树形展示。
            row.put("children", new ArrayList<Map<String, Object>>());
            rows.add(row);
        }
        rows.sort(Comparator.comparing((Map<String, Object> m) -> (BigDecimal) m.get("totalDiffAmt")).reversed());

        // 5) 将平铺数据转为树形结构：
        //    - 仅挂载 scope（报表内有交易数据）节点，避免返回无交易的空节点；
        //    - 若父节点不在 scope，则当前节点作为根节点返回。
        Map<String, Map<String, Object>> rowByUserId = new HashMap<>();
        for (Map<String, Object> row : rows) {
            rowByUserId.put((String) row.get("userId"), row);
        }
        List<Map<String, Object>> treeRows = new ArrayList<>();
        for (Map<String, Object> row : rows) {
            String userId = (String) row.get("userId");
            String parentUserId = parentByUserId.get(userId);
            Map<String, Object> parentRow = parentUserId == null ? null : rowByUserId.get(parentUserId);
            if (parentRow == null) {
                treeRows.add(row);
                continue;
            }
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> children = (List<Map<String, Object>>) parentRow.get("children");
            children.add(row);
        }
        sortTreeByTotalDiffDesc(treeRows);

        result.put("success", true);
        result.put("message", "查询成功");
        // data 改为树形，flatData 保留平铺，便于前端平滑改造。
        result.put("data", treeRows);
        result.put("flatData", rows);
        result.put("total", rows.size());
        result.put("startDate", startDate);
        result.put("endDate", endDate);
        result.put("tenantId", tenantIdTrim);
        return result;
    }

    private static TradeAmtBundle ownAmt(String userId, Map<String, TradeAmtBundle> ownAmtByUserId) {
        TradeAmtBundle b = ownAmtByUserId.get(userId);
        return b != null ? b : TradeAmtBundle.zeros();
    }

    private static TradeAmtBundle teamAmt(String userId, Map<String, TradeAmtBundle> teamAmtMemo) {
        TradeAmtBundle b = teamAmtMemo.get(userId);
        return b != null ? b : TradeAmtBundle.zeros();
    }

    /**
     * 递归按 totalDiffAmt 倒序排序树节点，确保每层展示稳定。
     */
    private static void sortTreeByTotalDiffDesc(List<Map<String, Object>> nodes) {
        nodes.sort(Comparator.comparing((Map<String, Object> m) -> (BigDecimal) m.get("totalDiffAmt")).reversed());
        for (Map<String, Object> node : nodes) {
            @SuppressWarnings("unchecked")
            List<Map<String, Object>> children = (List<Map<String, Object>>) node.get("children");
            if (children != null && !children.isEmpty()) {
                sortTreeByTotalDiffDesc(children);
            }
        }
    }

    /**
     * 递归计算某个用户的 team 金额（不含本人）。
     *
     * 规则：
     * - sum = Σ(每个child的own + child的team)；
     * - memo 命中即直接返回，避免重复计算；
     * - stack 用于防环（脏数据导致 A->B->A 时返回 0，避免死循环）。
     */
    private TradeAmtBundle teamAmtRecursive(
            String parentUserId,
            Map<String, List<String>> childrenByParentUserId,
            Map<String, TradeAmtBundle> ownAmtByUserId,
            Map<String, TradeAmtBundle> memo,
            Set<String> stack) {
        // 动态规划缓存：同一节点只算一次。
        TradeAmtBundle cached = memo.get(parentUserId);
        if (cached != null) {
            return cached;
        }
        // 防止环形关系导致无限递归。
        if (!stack.add(parentUserId)) {
            return TradeAmtBundle.zeros();
        }
        try {
            TradeAmtBundle sum = TradeAmtBundle.zeros();
            List<String> children = childrenByParentUserId.get(parentUserId);
            if (children != null) {
                for (String childUserId : children) {
                    sum.addInPlace(ownAmt(childUserId, ownAmtByUserId));
                    sum.addInPlace(teamAmtRecursive(childUserId, childrenByParentUserId, ownAmtByUserId, memo, stack));
                }
            }
            memo.put(parentUserId, sum);
            return sum;
        } finally {
            stack.remove(parentUserId);
        }
    }

    /**
     * 日期范围内按用户汇总的四类金额（与报表字段对应）。
     * 该对象既可表示 own，也可表示 team 或 total。
     */
    private static final class TradeAmtBundle {
        BigDecimal yestodayBuyAmt = BigDecimal.ZERO;
        BigDecimal dailySellAmt = BigDecimal.ZERO;
        BigDecimal dailyBuyAmt = BigDecimal.ZERO;
        BigDecimal diffAmt = BigDecimal.ZERO;

        static TradeAmtBundle zeros() {
            return new TradeAmtBundle();
        }

        void addFromReportRow(LbDailyUserTradeReport r) {
            yestodayBuyAmt = yestodayBuyAmt.add(defaultZero(r.getYestodayBuyAmt()));
            dailySellAmt = dailySellAmt.add(defaultZero(r.getDailySellAmt()));
            dailyBuyAmt = dailyBuyAmt.add(defaultZero(r.getDailyBuyAmt()));
            diffAmt = diffAmt.add(defaultZero(r.getDiffAmt()));
        }

        void addInPlace(TradeAmtBundle o) {
            if (o == null) {
                return;
            }
            yestodayBuyAmt = yestodayBuyAmt.add(defaultZero(o.yestodayBuyAmt));
            dailySellAmt = dailySellAmt.add(defaultZero(o.dailySellAmt));
            dailyBuyAmt = dailyBuyAmt.add(defaultZero(o.dailyBuyAmt));
            diffAmt = diffAmt.add(defaultZero(o.diffAmt));
        }

        TradeAmtBundle addCopy(TradeAmtBundle o) {
            TradeAmtBundle n = zeros();
            n.addInPlace(this);
            n.addInPlace(o != null ? o : zeros());
            return n;
        }
    }
}