Page--user/src/main/java/com/example/web/service/SupplyPoolCustomerService.java

package com.example.web.service;

import com.example.web.dto.ManagerAuthInfo;
import com.example.web.dto.UserProductCartDTO;
import com.example.web.entity.UsersManagements;
import com.example.web.mapper.SupplyUsersManagementsMapper;
import com.example.web.mapper.SupplyUsersMapper;
import com.example.web.mapper.UsersManagementsMapper;
import com.example.web.mapper.UsersMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

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

@Service
public class SupplyPoolCustomerService {

    @Autowired
    private SupplyUsersMapper supplyusersMapper;
    @Autowired
    private SupplyUsersManagementsMapper supplyUsersManagementsMapper;

    /**
     * 根据手机号查询微信用户信息（采购端权限：只处理seller和both类型）- 支持一对多
     */
    public UserProductCartDTO getWechatCustomerByPhone(String phoneNumber) {
        if (!StringUtils.hasText(phoneNumber)) {
            throw new IllegalArgumentException("手机号不能为空");
        }

        // 1. 根据手机号查询微信用户基本信息
        UserProductCartDTO userInfo = supplyusersMapper.selectByPhone(phoneNumber);
        if (userInfo == null) {
            throw new RuntimeException("未找到手机号对应的微信用户：" + phoneNumber);
        }

        System.out.println("🔍 获取到用户基础信息，用户ID: " + userInfo.getUserId() +
                ", 类型: " + userInfo.getType() +
                ", 公司: " + userInfo.getCompany() +
                ", 需求: " + userInfo.getDemand() +
                ", 规格: " + userInfo.getSpec());

        // 采购端权限校验：只处理seller和both类型
        if (!"seller".equals(userInfo.getType()) && !"both".equals(userInfo.getType())) {
            System.out.println("❌ 权限校验失败: 采购端只能处理供应端和BOTH类型客户");
            throw new IllegalArgumentException("采购端权限只能处理供应端和BOTH类型客户");
        }

        // 2. 获取所有联系人信息（一对多）
        try {
            List<SupplyUsersMapper.ContactInfo> contacts = supplyusersMapper.getUserAllContacts(userInfo.getUserId());
            // 转换为UserProductCartDTO.UsersContacts格式以保持兼容
            if (contacts != null && !contacts.isEmpty()) {
                List<UserProductCartDTO.UsersContacts> userContacts = contacts.stream()
                        .map(contact -> {
                            UserProductCartDTO.UsersContacts userContact = new UserProductCartDTO.UsersContacts(
                                    contact.getWechat(),
                                    contact.getAccount(),
                                    contact.getAccountNumber(),
                                    contact.getBank(),
                                    contact.getAddress()
                            );
                            // 设置contactId
                            userContact.setContactId(contact.getContactId());
                            return userContact;
                        })
                        .collect(Collectors.toList());
                userInfo.setUsersContacts(userContacts);
            } else {
                userInfo.setUsersContacts(Collections.emptyList());
            }
            System.out.println("✅ 获取用户所有联系人信息，数量: " + (userInfo.getUsersContacts() != null ? userInfo.getUsersContacts().size() : 0));
        } catch (Exception e) {
            System.err.println("❌ 获取用户联系人信息失败: " + e.getMessage());
            userInfo.setUsersContacts(Collections.emptyList());
        }

        // 3. 采购端：获取所有产品项信息（一对多）- 公海需求
        if ("seller".equals(userInfo.getType()) || "both".equals(userInfo.getType())) {
            try {
                List<SupplyUsersMapper.ProductInfo> products = supplyusersMapper.getUserAllProducts(userInfo.getUserId());
                // 转换为UserProductCartDTO.ProductInfo格式以保持兼容
                if (products != null && !products.isEmpty()) {
                    List<UserProductCartDTO.ProductInfo> userProducts = products.stream()
                            .map(item -> {
                                UserProductCartDTO.ProductInfo product = new UserProductCartDTO.ProductInfo();
                                product.setProductId(item.getProductId());
                                product.setProductName(item.getProductName());
                                product.setVariety(item.getVariety());
                                product.setSpecification(item.getSpecification());
                                product.setQuantity(item.getQuantity());
                                product.setGrossWeight(item.getGrossWeight());
                                product.setYolk(item.getYolk());
                                return product;
                            })
                            .collect(Collectors.toList());
                    userInfo.setProducts(userProducts);
                } else {
                    userInfo.setProducts(Collections.emptyList());
                }
                System.out.println("✅ 获取用户所有产品项信息，数量: " + (userInfo.getProducts() != null ? userInfo.getProducts().size() : 0));
            } catch (Exception e) {
                System.err.println("❌ 获取产品信息失败: " + e.getMessage());
                userInfo.setProducts(Collections.emptyList());
            }
            userInfo.setCartItems(Collections.emptyList()); // 采购端不使用购物车信息
        }

        return userInfo;
    }

    /**
     * 根据用户ID获取用户信息和相关产品数据（采购端版本）
     */
    public UserProductCartDTO getCustomerInfo(String userId) {
        if (!StringUtils.hasText(userId)) {
            throw new IllegalArgumentException("用户ID不能为空");
        }

        // 1. 获取用户基本信息
        UserProductCartDTO userInfo = supplyusersMapper.getUserBasicInfo(userId);
        if (userInfo == null) {
            throw new RuntimeException("用户不存在: " + userId);
        }

        // 采购端权限校验
        if (!"seller".equals(userInfo.getType()) && !"both".equals(userInfo.getType())) {
            throw new IllegalArgumentException("采购端权限只能查看供应端和BOTH类型客户");
        }

        // 2. 采购端：查询产品信息（公海需求）
        List<UserProductCartDTO.ProductInfo> products = supplyusersMapper.getSellerProducts(userId);
        userInfo.setProducts(products != null ? products : Collections.emptyList());
        userInfo.setCartItems(Collections.emptyList()); // 采购端不使用购物车

        // 3. 获取联系人信息 - 安全处理
        try {
            List<UserProductCartDTO.UsersContacts> contacts = supplyusersMapper.getUserContacts(userId);
            userInfo.setUsersContacts(contacts != null ? contacts : Collections.emptyList());
        } catch (Exception e) {
            System.err.println("❌ 获取用户联系人信息失败: " + e.getMessage());
            userInfo.setUsersContacts(Collections.emptyList());
        }

        return userInfo;
    }

    /**
     * 获取所有客户信息 - 使用数据库层面权限过滤（采购端版本）- 优化版（支持分页）
     */
    public List<UserProductCartDTO> getAllCustomers(ManagerAuthInfo authInfo) {
        try {
            System.out.println("====================================================");
            System.out.println("🚀 开始获取所有微信用户数据（数据库权限过滤，采购端）...");
            System.out.println("🔐 负责人过滤条件: " +
                    "公司=" + authInfo.getManagercompany() +
                    ", 部门=" + authInfo.getManagerdepartment());

            // 移除固定的分页限制，获取所有数据
            int limit = Integer.MAX_VALUE; // 获取所有数据
            int offset = 0; // 从第一条开始

            // 1. 获取授权客户总数
            System.out.println("📊 查询授权客户总数...");
            int totalCount = supplyusersMapper.getAuthorizedCustomersCount(authInfo);
            System.out.println("✅ 授权客户总数: " + totalCount);

            // 2. 使用数据库层面权限过滤并分页
            System.out.println("📋 查询授权客户基础信息（分页查询）...");
            List<UserProductCartDTO> authorizedUsers = supplyusersMapper.getAuthorizedCustomers(authInfo, limit, offset);

            System.out.println("✅ 授权客户数据查询完成");
            System.out.println("📊 当前页获取到授权客户数据条数: " + (authorizedUsers != null ? authorizedUsers.size() : "null"));
            // 统计通知状态为banold的授权客户数量
            if (authorizedUsers != null) {
                long banoldCount = authorizedUsers.stream().filter(user -> "banold".equals(user.getNotice())).count();
                System.out.println("📊 通知状态为banold的授权客户数量: " + banoldCount);
            }

            List<UserProductCartDTO> result = new ArrayList<>();

            if (authorizedUsers != null && !authorizedUsers.isEmpty()) {
                // 🔥 新增：收集所有用户ID用于批量查询
                List<String> userIds = authorizedUsers.stream()
                        .map(UserProductCartDTO::getUserId)
                        .filter(Objects::nonNull)
                        .filter(userId -> !userId.trim().isEmpty())
                        .distinct()
                        .collect(Collectors.toList());

                System.out.println("🔍 需要批量查询的授权用户数量: " + userIds.size());

                // 🔥 新增：批量查询所有相关数据
                Map<String, UsersManagements> managerMap = batchQueryManagers(userIds);
                Map<String, List<UsersMapper.ContactInfo>> contactsMap = batchQueryContacts(userIds);
                Map<String, List<UserProductCartDTO.ProductInfo>> productsMap = batchQueryProducts(userIds);

                // 2. 为每个授权用户构建完整信息（使用批量数据）
                System.out.println("🔄 开始处理 " + authorizedUsers.size() + " 条授权用户数据...");

                for (int i = 0; i < authorizedUsers.size(); i++) {
                    UserProductCartDTO user = authorizedUsers.get(i);
                    try {
                        // 🎯 关键修改：使用批量查询的数据构建完整用户信息
                        UserProductCartDTO fullUserInfo = buildSupplyUserInfoFromBatchData(user, managerMap, contactsMap, productsMap);
                        if (fullUserInfo != null) {
                            // 数据库已经过滤了权限，这里直接添加
                            result.add(fullUserInfo);

                            // 打印前几个客户的详细信息
                            if (i < 3) {
                                System.out.println("📝 授权客户样例 " + (i + 1) + ": " +
                                        "ID=" + fullUserInfo.getUserId() +
                                        ", 手机=" + fullUserInfo.getPhoneNumber() +
                                        ", 公司=" + fullUserInfo.getCompany() +
                                        ", 类型=" + fullUserInfo.getType() +
                                        ", 联系人数量=" + (fullUserInfo.getUsersContacts() != null ? fullUserInfo.getUsersContacts().size() : 0) +
                                        ", 产品数量=" + (fullUserInfo.getProducts() != null ? fullUserInfo.getProducts().size() : 0) +
                                        ", 是否公海池=" + isPublicSeaCustomer(fullUserInfo, authInfo));
                            }
                        }
                    } catch (Exception e) {
                        System.err.println("❌ 构建用户 " + user.getUserId() + " 的详细信息时出错: " + e.getMessage());
                    }
                }
            }

            System.out.println("====================================================");
            System.out.println("🎉 数据获取完成（数据库权限过滤，采购端）");
            System.out.println("📊 返回记录数: " + result.size());
            System.out.println("====================================================");

            return result;
        } catch (Exception e) {
            System.err.println("❌ 获取授权客户信息失败: " + e.getMessage());
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    /**
     * 检查是否有权限查看客户
     */
    private boolean hasPermissionToViewCustomer(UserProductCartDTO userInfo, ManagerAuthInfo authInfo) {
        // 公海池客户使用特殊权限检查
        if (isPublicSeaCustomer(userInfo, authInfo)) {
            return true;
        }

        // 非公海池客户需要检查负责人权限
        return hasUserManagerPermission(userInfo.getUserId(), authInfo);
    }

    /**
     * 判断是否为公海池客户 - 根据不同类型使用不同逻辑
     */
    private boolean isPublicSeaCustomer(UserProductCartDTO userInfo, ManagerAuthInfo authInfo) {
        // 定义公海池等级
        Set<String> publicSeaLevels = Set.of("company-sea-pools", "organization-sea-pools", "department-sea-pools", "公海池");

        // 检查等级是否为公海池
        boolean isPublicSeaLevel = publicSeaLevels.contains(userInfo.getLevel());
        System.out.println("🔍 客户等级检查: " + userInfo.getLevel() + " → 是否公海池等级: " + isPublicSeaLevel);

        if (!isPublicSeaLevel) {
            return false;
        }

        // 根据不同类型的公海池使用不同判断逻辑
        String level = userInfo.getLevel();

        if ("company-sea-pools".equals(level) || "公海池".equals(level)) {
            // 公司公海池：必须没有负责人信息
            boolean result = !hasManagerAuthInfo(userInfo.getUserId());
            System.out.println("🏢 公司公海池检查结果: " + result);
            return result;
        } else if ("organization-sea-pools".equals(level)) {
            // 组织公海池：必须有负责人信息且组织匹配
            boolean hasManager = hasManagerAuthInfo(userInfo.getUserId());
            if (!hasManager) {
                System.out.println("🏢 组织公海池：无负责人信息，不允许查看");
                return false;
            }
            boolean sameOrganization = hasSameOrganization(userInfo.getUserId(), authInfo);
            System.out.println("🏢 组织公海池检查结果 - 有负责人: " + hasManager + ", 组织匹配: " + sameOrganization + " → 结果: " + sameOrganization);
            return sameOrganization;
        } else if ("department-sea-pools".equals(level)) {
            // 部门公海池：必须有负责人信息且部门匹配
            boolean hasManager = hasManagerAuthInfo(userInfo.getUserId());
            if (!hasManager) {
                System.out.println("🏢 部门公海池：无负责人信息，不允许查看");
                return false;
            }
            boolean sameDepartment = hasSameDepartment(userInfo.getUserId(), authInfo);
            System.out.println("🏢 部门公海池检查结果 - 有负责人: " + hasManager + ", 部门匹配: " + sameDepartment + " → 结果: " + sameDepartment);
            return sameDepartment;
        }

        return false;
    }

    /**
     * 公共方法：判断是否为公海池客户（供Controller调用）
     */
    public boolean isPublicSeaCustomerPublic(UserProductCartDTO userInfo, ManagerAuthInfo authInfo) {
        return isPublicSeaCustomer(userInfo, authInfo);
    }

    /**
     * 检查是否有负责人认证信息
     */
    private boolean hasManagerAuthInfo(String userId) {
        try {
            UsersManagements userManager = supplyUsersManagementsMapper.findByUserId(userId);
            if (userManager == null) {
                return false;
            }

            // 检查认证字段是否为空 - 只要有一个认证字段有值，就有负责人信息
            boolean hasAuthInfo = StringUtils.hasText(userManager.getManagerId()) ||
                    StringUtils.hasText(userManager.getManagercompany()) ||
                    StringUtils.hasText(userManager.getManagerdepartment()) ||
                    StringUtils.hasText(userManager.getOrganization()) ||
                    StringUtils.hasText(userManager.getRole()) ||
                    StringUtils.hasText(userManager.getUserName()) ||
                    StringUtils.hasText(userManager.getAssistant());

            System.out.println("📋 负责人认证信息检查结果: " + (hasAuthInfo ? "有认证信息" : "无认证信息"));
            return hasAuthInfo;
        } catch (Exception e) {
            System.err.println("❌ 检查负责人认证信息失败: " + e.getMessage());
            return false;
        }
    }

    /**
     * 检查是否同一组织
     */
    private boolean hasSameOrganization(String userId, ManagerAuthInfo authInfo) {
        try {
            UsersManagements userManager = supplyUsersManagementsMapper.findByUserId(userId);
            if (userManager == null) {
                return false;
            }

            boolean sameOrganization = StringUtils.hasText(userManager.getOrganization()) &&
                    userManager.getOrganization().equals(authInfo.getOrganization());

            System.out.println("🏢 组织匹配检查: " + userManager.getOrganization() + " vs " + authInfo.getOrganization() + " → " + sameOrganization);
            return sameOrganization;
        } catch (Exception e) {
            System.err.println("❌ 检查组织信息失败: " + e.getMessage());
            return false;
        }
    }

    /**
     * 检查是否同一部门
     */
    private boolean hasSameDepartment(String userId, ManagerAuthInfo authInfo) {
        try {
            UsersManagements userManager = supplyUsersManagementsMapper.findByUserId(userId);
            if (userManager == null) {
                return false;
            }

            boolean sameDepartment = StringUtils.hasText(userManager.getManagerdepartment()) &&
                    userManager.getManagerdepartment().equals(authInfo.getManagerdepartment());

            System.out.println("🏢 部门匹配检查: " + userManager.getManagerdepartment() + " vs " + authInfo.getManagerdepartment() + " → " + sameDepartment);
            return sameDepartment;
        } catch (Exception e) {
            System.err.println("❌ 检查部门信息失败: " + e.getMessage());
            return false;
        }
    }

    /**
     * 检查用户负责人权限 - 优化版本，数据库层面直接匹配
     */
    private boolean hasUserManagerPermission(String userId, ManagerAuthInfo authInfo) {
        try {
            System.out.println("🔐 检查用户负责人权限，用户ID: " + userId);

            // 🔥 优化：直接在数据库层面查询匹配的负责人记录，避免内存比较
            UsersManagements userManager = supplyUsersManagementsMapper.findByUserIdAndAuthInfo(userId, authInfo);

            // 🔥 优化：如果没有找到匹配的负责人记录，检查是否为公海池客户
            if (userManager == null) {
                System.out.println("🔍 未找到匹配的负责人记录，检查客户等级...");

                // 获取用户信息检查等级
                UserProductCartDTO userInfo = supplyusersMapper.getUserBasicInfo(userId);
                if (userInfo != null) {
                    // 定义公海池等级
                    Set<String> publicSeaLevels = Set.of("company-sea-pools", "organization-sea-pools", "department-sea-pools", "公海池");
                    boolean isPublicSea = publicSeaLevels.contains(userInfo.getLevel());

                    if (isPublicSea) {
                        System.out.println("✅ 公海池客户，允许查看");
                        return true;
                    }
                }

                System.out.println("❌ 非公海池客户且无匹配负责人，拒绝访问");
                return false;
            }

            // 🔥 优化：数据库已经完成匹配，直接返回true
            System.out.println("✅ 找到匹配的负责人记录，允许查看");
            System.out.println("📝 负责人信息: " +
                    "公司=" + userManager.getManagercompany() +
                    ", 部门=" + userManager.getManagerdepartment() +
                    ", 组织=" + userManager.getOrganization() +
                    ", 负责人=" + userManager.getUserName());

            return true;

        } catch (Exception e) {
            System.err.println("❌ 检查用户负责人权限失败: " + e.getMessage());
            // 发生异常时，出于安全考虑返回false
            return false;
        }
    }

    /**
     * 检查负责人信息是否匹配（UsersManagements）
     */
    private boolean isManagerMatch(UsersManagements userManager, ManagerAuthInfo authInfo) {
        boolean match =
                (authInfo.getManagerId() == null || authInfo.getManagerId().equals(userManager.getManagerId())) &&
                        (authInfo.getManagercompany() == null || authInfo.getManagercompany().equals(userManager.getManagercompany())) &&
                        (authInfo.getManagerdepartment() == null || authInfo.getManagerdepartment().equals(userManager.getManagerdepartment())) &&
                        (authInfo.getOrganization() == null || authInfo.getOrganization().equals(userManager.getOrganization())) &&
                        (authInfo.getRole() == null || authInfo.getRole().equals(userManager.getRole())) &&
                        (authInfo.getUserName() == null || authInfo.getUserName().equals(userManager.getUserName()));

        System.out.println("🔐 用户负责人权限检查: " + (match ? "✅ 匹配" : "❌ 不匹配"));
        return match;
    }

    /**
     * 获取公海池客户完整信息 - 支持一对多（采购端版本）
     */
    public UserProductCartDTO getPublicSeaCustomerInfo(String userId) {
        if (!StringUtils.hasText(userId)) {
            System.out.println("⚠️ 用户ID为空");
            return null;
        }

        // 1. 获取用户基本信息
        UserProductCartDTO userInfo = supplyusersMapper.getUserBasicInfo(userId);
        if (userInfo == null) {
            System.out.println("⚠️ 用户不存在: " + userId);
            return null; // 返回null而不是抛出异常
        }

        // 采购端权限校验
        if (!"seller".equals(userInfo.getType()) && !"both".equals(userInfo.getType())) {
            System.out.println("🚫 过滤掉非供应端客户: " + userId + " (类型: " + userInfo.getType() + ")");
            return null; // 返回null而不是抛出异常
        }
        
        // 如果通知状态为banold，则更新为old
        if ("banold".equals(userInfo.getNotice())) {
            System.out.println("🔄 更新通知状态: " + userId + " 从banold改为old");
            supplyusersMapper.updateNotice(userId, "old");
            userInfo.setNotice("old");
        }
// 🔥 新增：查询负责人信息
        try {
            UsersManagements userManager = supplyUsersManagementsMapper.findByUserId(userId);
            if (userManager != null) {
                System.out.println("✅ 获取到负责人信息: " +
                        "负责人=" + userManager.getUserName() +
                        ", 组织=" + userManager.getOrganization() +
                        ", 部门=" + userManager.getManagerdepartment());

                // 将负责人信息设置到DTO中（需要扩展UserProductCartDTO或使用其他方式）
                // 这里可以创建一个新的字段来存储负责人信息，或者使用现有的扩展机制
                // 暂时记录日志，后续需要DTO支持负责人字段
            } else {
                System.out.println("⚠️ 未找到负责人信息");
            }
        } catch (Exception e) {
            System.err.println("❌ 获取负责人信息失败: " + e.getMessage());
        }
        // 2. 获取联系人信息 - 一对多
        try {
            List<SupplyUsersMapper.ContactInfo> contacts = supplyusersMapper.getUserAllContacts(userId);
            if (contacts != null && !contacts.isEmpty()) {
                List<UserProductCartDTO.UsersContacts> userContacts = contacts.stream()
                        .map(contact -> {
                            UserProductCartDTO.UsersContacts userContact = new UserProductCartDTO.UsersContacts(
                                    contact.getWechat(),
                                    contact.getAccount(),
                                    contact.getAccountNumber(),
                                    contact.getBank(),
                                    contact.getAddress()
                            );
                            userContact.setContactId(contact.getContactId());
                            return userContact;
                        })
                        .collect(Collectors.toList());
                userInfo.setUsersContacts(userContacts);
            } else {
                userInfo.setUsersContacts(Collections.emptyList());
            }
        } catch (Exception e) {
            System.err.println("❌ 获取用户联系人信息失败: " + e.getMessage());
            userInfo.setUsersContacts(Collections.emptyList());
        }

        // 3. 采购端：获取产品信息（公海需求）- 一对多
        try {
            List<SupplyUsersMapper.ProductInfo> products = supplyusersMapper.getUserAllProducts(userId);
            System.out.println("🔍 查询到的产品数据条数: " + (products != null ? products.size() : 0));

            if (products != null && !products.isEmpty()) {
                List<UserProductCartDTO.ProductInfo> userProducts = products.stream()
                        .map(item -> {
                            UserProductCartDTO.ProductInfo product = new UserProductCartDTO.ProductInfo();
                            product.setProductId(item.getProductId());
                            product.setProductName(item.getProductName());
                            product.setVariety(item.getVariety());
                            product.setSpecification(item.getSpecification());
                            product.setQuantity(item.getQuantity());
                            product.setGrossWeight(item.getGrossWeight());
                            product.setYolk(item.getYolk());

                            // 调试日志
                            System.out.println("📦 转换产品项: " +
                                    "ID=" + product.getProductId() +
                                    ", 产品=" + product.getProductName() +
                                    ", 规格=" + product.getSpecification());

                            return product;
                        })
                        .collect(Collectors.toList());
                userInfo.setProducts(userProducts);
                System.out.println("✅ 成功设置产品数据，数量: " + userProducts.size());
            } else {
                userInfo.setProducts(Collections.emptyList());
                System.out.println("⚠️ 产品数据为空");
            }
            userInfo.setCartItems(Collections.emptyList()); // 采购端不使用购物车信息
        } catch (Exception e) {
            System.err.println("❌ 获取产品信息失败: " + e.getMessage());
            e.printStackTrace();
            userInfo.setProducts(Collections.emptyList());
            userInfo.setCartItems(Collections.emptyList());
        }

        // 最终调试信息
        System.out.println("🎯 最终返回的用户数据: " +
                "products数量=" + (userInfo.getProducts() != null ? userInfo.getProducts().size() : "null") +
                ", contacts数量=" + (userInfo.getUsersContacts() != null ? userInfo.getUsersContacts().size() : "null"));

        return userInfo;
    }

    /**
     * 获取所有客户信息 - 不进行负责人过滤，直接返回所有数据（采购端版本 - 优化版）
     */
    public List<UserProductCartDTO> getAllCustomersWithoutFilter() {
        try {
            System.out.println("====================================================");
            System.out.println("🚀 开始获取所有微信用户数据（无过滤，采购端）...");

            // 1. 获取所有用户的基本信息（采购端：只获取seller和both类型）
            System.out.println("📋 查询用户基础信息...");
            List<UserProductCartDTO> allUsers = supplyusersMapper.getAllUserBasicInfo();

            System.out.println("✅ 基础用户数据查询完成");
            System.out.println("📊 获取到基础用户数据条数: " + (allUsers != null ? allUsers.size() : "null"));
            // 统计通知状态为banold的用户数量
            if (allUsers != null) {
                long banoldCount = allUsers.stream().filter(user -> "banold".equals(user.getNotice())).count();
                System.out.println("📊 通知状态为banold的用户数量: " + banoldCount);
            }

            List<UserProductCartDTO> result = new ArrayList<>();

            if (allUsers != null && !allUsers.isEmpty()) {
                // 🔥 修改：收集所有用户ID用于批量查询
                List<String> userIds = allUsers.stream()
                        .map(UserProductCartDTO::getUserId)
                        .filter(Objects::nonNull)
                        .filter(userId -> !userId.trim().isEmpty())
                        .distinct()
                        .collect(Collectors.toList());

                System.out.println("🔍 需要批量查询的用户数量: " + userIds.size());

                // 🔥 修改：批量查询所有相关数据（采购端需要产品信息）
                Map<String, UsersManagements> managerMap = batchQueryManagers(userIds);
                Map<String, List<UsersMapper.ContactInfo>> contactsMap = batchQueryContacts(userIds);
                Map<String, List<UserProductCartDTO.ProductInfo>> productsMap = batchQueryProducts(userIds); // 采购端需要产品信息

                // 2. 为每个用户构建完整信息
                System.out.println("🔄 开始处理 " + allUsers.size() + " 条用户数据...");

                for (int i = 0; i < allUsers.size(); i++) {
                    UserProductCartDTO user = allUsers.get(i);
                    try {
                        // 采购端权限：只处理seller和both类型
                        if (!"seller".equals(user.getType()) && !"both".equals(user.getType())) {
                            System.out.println("🚫 过滤掉非供应端客户: " + user.getUserId() + " (类型: " + user.getType() + ")");
                            continue;
                        }

                        // 🔥 修改：使用批量查询的数据构建完整用户信息（采购端版本）
                        UserProductCartDTO fullUserInfo = buildSupplyUserInfoFromBatchData(user, managerMap, contactsMap, productsMap);
                        if (fullUserInfo != null) {
                            result.add(fullUserInfo);
                            // 打印前几个客户的详细信息
                            if (i < 3) {
                                System.out.println("📝 采购端客户样例 " + (i + 1) + ": " +
                                        "ID=" + fullUserInfo.getUserId() +
                                        ", 手机=" + fullUserInfo.getPhoneNumber() +
                                        ", 公司=" + fullUserInfo.getCompany() +
                                        ", 类型=" + fullUserInfo.getType() +
                                        ", 联系人数量=" + (fullUserInfo.getUsersContacts() != null ? fullUserInfo.getUsersContacts().size() : 0) +
                                        ", 产品数量=" + (fullUserInfo.getProducts() != null ? fullUserInfo.getProducts().size() : 0));
                            }
                        }
                    } catch (Exception e) {
                        System.err.println("❌ 构建用户 " + user.getUserId() + " 的详细信息时出错: " + e.getMessage());
                    }
                }
            }

            System.out.println("====================================================");
            System.out.println("🎉 数据获取完成（无过滤，采购端）");
            System.out.println("📊 返回记录数: " + result.size());
            System.out.println("====================================================");

            return result;
        } catch (Exception e) {
            System.err.println("❌ 获取所有客户信息失败: " + e.getMessage());
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    /**
     * 1.批量查询负责人信息（与销售端复用）
     */
    private Map<String, UsersManagements> batchQueryManagers(List<String> userIds) {
        Map<String, UsersManagements> managerMap = new HashMap<>();
        if (userIds != null && !userIds.isEmpty()) {
            try {
                // 🔥 注意：采购端可能需要使用不同的Mapper
                List<UsersManagements> allManagers = supplyUsersManagementsMapper.findByUserIds(userIds);
                for (UsersManagements manager : allManagers) {
                    if (manager.getUserId() != null) {
                        managerMap.put(manager.getUserId(), manager);
                    }
                }
                System.out.println("✅ 采购端批量查询负责人信息完成，共获取 " + allManagers.size() + " 条记录");
            } catch (Exception e) {
                System.err.println("❌ 采购端批量查询负责人信息失败: " + e.getMessage());
            }
        }
        return managerMap;
    }

    /**
     * 2.批量查询联系人信息（与销售端复用）
     */
    private Map<String, List<UsersMapper.ContactInfo>> batchQueryContacts(List<String> userIds) {
        Map<String, List<UsersMapper.ContactInfo>> contactsMap = new HashMap<>();
        if (userIds != null && !userIds.isEmpty()) {
            try {
                // 🔥 注意：采购端需要使用采购端的Mapper
                List<UsersMapper.ContactInfo> allContacts = supplyusersMapper.getUserContactsByUserIds(userIds);
                for (UsersMapper.ContactInfo contact : allContacts) {
                    String userId = contact.getUserId();
                    if (userId != null) {
                        contactsMap.computeIfAbsent(userId, k -> new ArrayList<>()).add(contact);
                    }
                }
                System.out.println("✅ 采购端批量查询联系人信息完成，共获取 " + allContacts.size() + " 条记录");
            } catch (Exception e) {
                System.err.println("❌ 采购端批量查询联系人信息失败: " + e.getMessage());
            }
        }
        return contactsMap;
    }

    /**
     * 3.批量查询产品信息（采购端专用）
     */
    private Map<String, List<UserProductCartDTO.ProductInfo>> batchQueryProducts(List<String> userIds) {
        Map<String, List<UserProductCartDTO.ProductInfo>> productsMap = new HashMap<>();
        if (userIds != null && !userIds.isEmpty()) {
            try {
                List<UserProductCartDTO.ProductInfo> allProducts = supplyusersMapper.getSellerProductsByUserIds(userIds);
                for (UserProductCartDTO.ProductInfo product : allProducts) {
                    String userId = product.getSellerId();
                    if (userId != null) {
                        productsMap.computeIfAbsent(userId, k -> new ArrayList<>()).add(product);
                    }
                }
                System.out.println("✅ 批量查询产品信息完成，共获取 " + allProducts.size() + " 条记录");
            } catch (Exception e) {
                System.err.println("❌ 批量查询产品信息失败: " + e.getMessage());
            }
        }
        return productsMap;
    }

    /**
     * 4.从批量查询的数据构建采购端用户完整信息（采购端专用）
     */
    private UserProductCartDTO buildSupplyUserInfoFromBatchData(UserProductCartDTO basicUserInfo,
                                                                Map<String, UsersManagements> managerMap,
                                                                Map<String, List<UsersMapper.ContactInfo>> contactsMap,
                                                                Map<String, List<UserProductCartDTO.ProductInfo>> productsMap) {
        String userId = basicUserInfo.getUserId();

        // 采购端权限校验
        if (!"seller".equals(basicUserInfo.getType()) && !"both".equals(basicUserInfo.getType())) {
            System.out.println("🚫 过滤掉非供应端客户: " + userId + " (类型: " + basicUserInfo.getType() + ")");
            return null;
        }

        // 设置负责人信息
        try {
            UsersManagements userManager = managerMap.get(userId);
            if (userManager != null) {
                System.out.println("✅ 从批量Map中获取到负责人信息: " +
                        "负责人=" + userManager.getUserName() +
                        ", 组织=" + userManager.getOrganization() +
                        ", 部门=" + userManager.getManagerdepartment());
            }
        } catch (Exception e) {
            System.err.println("❌ 从Map获取负责人信息失败: " + e.getMessage());
        }

        // 设置联系人信息
        try {
            List<UsersMapper.ContactInfo> contacts = contactsMap.get(userId);
            if (contacts != null && !contacts.isEmpty()) {
                List<UserProductCartDTO.UsersContacts> userContacts = contacts.stream()
                        .map(contact -> {
                            UserProductCartDTO.UsersContacts userContact = new UserProductCartDTO.UsersContacts(
                                    contact.getWechat(),
                                    contact.getAccount(),
                                    contact.getAccountNumber(),
                                    contact.getBank(),
                                    contact.getAddress()
                            );
                            userContact.setContactId(contact.getContactId());
                            return userContact;
                        })
                        .collect(Collectors.toList());
                basicUserInfo.setUsersContacts(userContacts);
            } else {
                basicUserInfo.setUsersContacts(Collections.emptyList());
            }
        } catch (Exception e) {
            System.err.println("❌ 设置联系人信息失败: " + e.getMessage());
            basicUserInfo.setUsersContacts(Collections.emptyList());
        }

        // 设置产品信息（采购端关键）
        try {
            List<UserProductCartDTO.ProductInfo> products = productsMap.get(userId);
            if (products != null && !products.isEmpty()) {
                basicUserInfo.setProducts(products);
            } else {
                basicUserInfo.setProducts(Collections.emptyList());
            }
            basicUserInfo.setCartItems(Collections.emptyList()); // 采购端不使用购物车信息
        } catch (Exception e) {
            System.err.println("❌ 设置产品信息失败: " + e.getMessage());
            basicUserInfo.setProducts(Collections.emptyList());
            basicUserInfo.setCartItems(Collections.emptyList());
        }

        return basicUserInfo;
    }


    /**
     * 只检查等级是否为公海池等级（不检查负责人信息）
     */
    private boolean isPublicSeaLevel(String level) {
        // 定义公海池等级
        Set<String> publicSeaLevels = Set.of("company-sea-pools", "organization-sea-pools", "department-sea-pools", "公海池");

        boolean isPublicSeaLevel = publicSeaLevels.contains(level);
        System.out.println("🔍 等级检查: " + level + " → 是否公海池等级: " + isPublicSeaLevel);

        return isPublicSeaLevel;
    }

    /**
     * 采购端：获取客户的产品信息（公海需求）
     */
    public List<UserProductCartDTO.ProductInfo> getCustomerProducts(String phoneNumber) {
        try {
            UserProductCartDTO user = supplyusersMapper.selectByPhone(phoneNumber);
            if (user != null && ("seller".equals(user.getType()) || "both".equals(user.getType()))) {
                return supplyusersMapper.getSellerProducts(user.getUserId());
            }
            return new ArrayList<>();
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }
}