package cn.iocoder.yudao.module.mes.controller.admin.deviceledger.utils;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.mes.controller.admin.deviceledger.vo.DeviceLedgerRespVO;
import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 用户名称解析工具类
 *
 * @author 你的名字
 */
@Slf4j
@Component
public  class ResumeNameUtils {

    private static AdminUserApi adminUserApi = null;

    public ResumeNameUtils(AdminUserApi adminUserApi) {
        ResumeNameUtils.adminUserApi = adminUserApi;
    }


    /**
     * 为分页结果填充用户名称信息
     *
     * @param pageResult 分页结果
     * @return 填充后的分页结果
     */
    public  static PageResult<?> buildPageCreatorName(PageResult<?> pageResult) {
        if (pageResult == null || pageResult.getList() == null || pageResult.getList().isEmpty()) {
            return pageResult;
        }

        // 假设你的VO类有特定的方法，这里需要根据实际VO类调整
        // 这里使用泛型，你需要根据实际情况调整
        List<?> voList = pageResult.getList();

        // 如果是DeviceLedgerRespVO类型
        if (!voList.isEmpty() && voList.get(0) instanceof DeviceLedgerRespVO) {
            List<DeviceLedgerRespVO> convertedList = voList.stream()
                    .map(vo -> (DeviceLedgerRespVO) vo)
                    .collect(Collectors.toList());

            fillUserInfo(convertedList);

            // 返回新的PageResult
            return new PageResult<>(convertedList, pageResult.getTotal());
        }

        // 可以添加其他类型的处理
        return pageResult;
    }

    /**
     * 为导出方法填充用户信息
     *
     * @param voList 设备台账VO列表
     */
    public static void fillUserInfoForExport(List<DeviceLedgerRespVO> voList) {
        fillUserInfo(voList);
    }

    /**
     * 通用方法：填充用户信息
     *
     * @param voList 设备台账VO列表
     */
    public static void fillUserInfo(List<DeviceLedgerRespVO> voList) {
        if (voList == null || voList.isEmpty()) {
            return;
        }

        // 1. 收集所有需要查询的用户ID
        Set<Long> userIds = collectUserIds(voList);

        if (userIds.isEmpty()) {
            return;
        }

        // 2. 批量查询用户信息
        Map<Long, AdminUserRespDTO> userMap = batchGetUsers(userIds);

        // 3. 填充用户名称
        fillUserNames(voList, userMap);
    }

    /**
     * 收集所有用户ID
     */
    private  static Set<Long> collectUserIds(List<DeviceLedgerRespVO> voList) {
        Set<Long> userIds = new HashSet<>();

        for (DeviceLedgerRespVO vo : voList) {
            // 收集创建者ID
            if (StringUtils.isNotBlank(vo.getCreator())) {
                try {
                    userIds.add(Long.valueOf(vo.getCreator()));
                } catch (NumberFormatException e) {
                    log.warn("创建者ID格式错误: {}", vo.getCreator());
                }
            }

            // 收集设备管理员ID
            if (StringUtils.isNotBlank(vo.getDeviceManager())) {
                collectManagerIds(vo.getDeviceManager(), userIds);
            }

            // 如果需要，可以收集其他用户ID字段
            // collectOtherUserIds(vo, userIds);
        }

        return userIds;
    }

    /**
     * 收集设备管理员ID
     */
    private  static void collectManagerIds(String deviceManager, Set<Long> userIds) {
        if (StringUtils.isBlank(deviceManager)) {
            return;
        }

        try {
            Arrays.stream(deviceManager.split(","))
                    .map(String::trim)
                    .filter(StringUtils::isNotBlank)
                    .map(Long::valueOf)
                    .forEach(userIds::add);
        } catch (NumberFormatException e) {
            log.warn("设备管理员ID格式错误: {}", deviceManager);
        }
    }

    /**
     * 批量查询用户信息
     */
    private static Map<Long, AdminUserRespDTO> batchGetUsers(Set<Long> userIds) {
        if (userIds.isEmpty()) {
            return Collections.emptyMap();
        }

        try {
            // 如果adminUserApi支持批量查询
            // return adminUserApi.getUserList(userIds).stream()
            //         .collect(Collectors.toMap(AdminUserRespDTO::getId, Function.identity()));

            // 如果不支持批量查询，则逐个查询
            Map<Long, AdminUserRespDTO> userMap = new HashMap<>();
            for (Long userId : userIds) {
                try {
                    AdminUserRespDTO user = adminUserApi.getUser(userId);
                    if (user != null) {
                        userMap.put(userId, user);
                    }
                } catch (Exception e) {
                    log.error("查询用户信息失败，用户ID: {}", userId, e);
                }
            }
            return userMap;
        } catch (Exception e) {
            log.error("批量查询用户信息失败", e);
            return Collections.emptyMap();
        }
    }

    /**
     * 填充用户名称
     */
    private static void fillUserNames(List<DeviceLedgerRespVO> voList, Map<Long, AdminUserRespDTO> userMap) {
        for (DeviceLedgerRespVO vo : voList) {
            // 填充创建者名称
            fillCreatorName(vo, userMap);

            // 填充设备管理员名称
            fillDeviceManagerName(vo, userMap);

            // 填充其他用户名称
            // fillOtherUserNames(vo, userMap);
        }
    }

    /**
     * 填充创建者名称
     */
    private static void fillCreatorName(DeviceLedgerRespVO vo, Map<Long, AdminUserRespDTO> userMap) {
        if (StringUtils.isBlank(vo.getCreator())) {
            return;
        }

        try {
            Long creatorId = Long.valueOf(vo.getCreator());
            AdminUserRespDTO creator = userMap.get(creatorId);
            if (creator != null) {
                vo.setCreatorName(formatUserName(creator));
            } else {
                vo.setCreatorName("未知(" + creatorId + ")");
            }
        } catch (NumberFormatException e) {
            vo.setCreatorName("ID格式错误");
        }
    }

    /**
     * 填充设备管理员名称
     */
    private static void fillDeviceManagerName(DeviceLedgerRespVO vo, Map<Long, AdminUserRespDTO> userMap) {
        if (StringUtils.isBlank(vo.getDeviceManager())) {
            return;
        }

        try {
            String[] managerIdStrs = vo.getDeviceManager().split(",");
            List<String> managerNames = new ArrayList<>();

            for (String managerIdStr : managerIdStrs) {
                managerIdStr = managerIdStr.trim();
                if (StringUtils.isBlank(managerIdStr)) {
                    continue;
                }

                try {
                    Long managerId = Long.valueOf(managerIdStr);
                    AdminUserRespDTO manager = userMap.get(managerId);
                    if (manager != null) {
                        managerNames.add(formatUserName(manager));
                    } else {
                        managerNames.add("未知(" + managerId + ")");
                    }
                } catch (NumberFormatException e) {
                    managerNames.add("格式错误");
                }
            }

            vo.setDeviceManagerName(String.join(",", managerNames));
        } catch (Exception e) {
            log.warn("填充设备管理员名称失败: {}", vo.getDeviceManager(), e);
            vo.setDeviceManagerName("解析错误");
        }
    }

    /**
     * 格式化用户显示名称
     */
    public  static String formatUserName(AdminUserRespDTO user) {
        if (user == null) {
            return "";
        }

        String username = user.getUsername() != null ? user.getUsername() : "";
        String nickname = user.getNickname() != null ? user.getNickname() : "";

        return "(" + username + ")" + nickname;
    }

    /**
     * 简易版格式化用户名称
     */
    public String formatUserNameSimple(AdminUserRespDTO user) {
        if (user == null) {
            return "";
        }
        return user.getNickname() != null ? user.getNickname() : user.getUsername();
    }

    /**
     * 静态工具方法：解析逗号分隔的ID字符串
     */
    public static List<Long> parseIds(String ids) {
        if (StringUtils.isBlank(ids)) {
            return Collections.emptyList();
        }

        try {
            return Arrays.stream(ids.split(","))
                    .map(String::trim)
                    .filter(StringUtils::isNotBlank)
                    .map(Long::valueOf)
                    .distinct()
                    .collect(Collectors.toList());
        } catch (NumberFormatException e) {
            log.warn("解析ID字符串失败: {}", ids, e);
            return Collections.emptyList();
        }
    }


}