package com.vincent.rsf.server.manager.utils;


import com.vincent.rsf.framework.common.Cools;
import com.vincent.rsf.framework.common.SpringUtils;
import com.vincent.rsf.server.common.service.RedisService;
import com.vincent.rsf.server.system.entity.User;
import com.vincent.rsf.server.system.service.UserService;

import java.lang.reflect.Field;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class buildPageRowsUtils {

    private static final String USER_NAME_CACHE_FLAG = "PAGE_ROWS_USER_NAME";
    private static final int USER_NAME_CACHE_TTL_SECONDS = 300;

    public static <T> Map<Long, String> userNameMap(List<T> records){
        if (Cools.isEmpty(records)) {
            return Collections.emptyMap();
        }
        Set<Long> collect = records.stream()
                .filter(Objects::nonNull)
                .flatMap(item -> Stream.of(
                        readUserId(item, "createBy"),
                        readUserId(item, "updateBy")
                ))
                .filter(Objects::nonNull)
                .collect(Collectors.toSet());

        Map<Long, String> userNameMap = loadUserNameMap(collect);
        fillUserNameFields(records, userNameMap);
        return userNameMap;
    }

    private static Long readUserId(Object record, String fieldName) {
        if (record == null || Cools.isEmpty(fieldName)) {
            return null;
        }
        Field field = Cools.getField(record.getClass(), fieldName);
        if (field == null) {
            return null;
        }
        boolean accessible = field.isAccessible();
        try {
            field.setAccessible(true);
            Object value = field.get(record);
            if (value instanceof Long) {
                return (Long) value;
            }
            if (value instanceof Number) {
                return ((Number) value).longValue();
            }
            if (value instanceof String && !((String) value).trim().isEmpty()) {
                return Long.parseLong(((String) value).trim());
            }
        } catch (IllegalAccessException | NumberFormatException ignored) {
            return null;
        } finally {
            field.setAccessible(accessible);
        }
        return null;
    }

    private static Map<Long, String> loadUserNameMap(Set<Long> userIds) {
        if (Cools.isEmpty(userIds)) {
            return Collections.emptyMap();
        }
        List<Long> normalizedUserIds = userIds.stream()
                .filter(Objects::nonNull)
                .toList();
        if (normalizedUserIds.isEmpty()) {
            return Collections.emptyMap();
        }
        RedisService redisService = getRedisService();
        Map<Long, String> userNameMap = new HashMap<>();
        List<Long> missingUserIds = new ArrayList<>();
        for (Long userId : normalizedUserIds) {
            String cachedUserName = getCachedUserName(redisService, userId);
            if (cachedUserName == null) {
                missingUserIds.add(userId);
                continue;
            }
            userNameMap.put(userId, cachedUserName);
        }
        if (missingUserIds.isEmpty()) {
            return userNameMap;
        }
        UserService userService = SpringUtils.getBean(UserService.class);
        Map<Long, String> loadedUserNameMap = userService.listByIds(missingUserIds)
                .stream()
                .filter(Objects::nonNull)
                .filter(user -> user.getId() != null && user.getNickname() != null)
                .collect(Collectors.toMap(User::getId, User::getNickname, (left, right) -> left));
        userNameMap.putAll(loadedUserNameMap);
        cacheUserNames(redisService, loadedUserNameMap);
        return userNameMap;
    }

    private static RedisService getRedisService() {
        try {
            return SpringUtils.getBean(RedisService.class);
        } catch (Exception ignored) {
            return null;
        }
    }

    private static String getCachedUserName(RedisService redisService, Long userId) {
        if (redisService == null || userId == null) {
            return null;
        }
        try {
            String value = redisService.getValue(USER_NAME_CACHE_FLAG, String.valueOf(userId));
            return Cools.isEmpty(value) ? null : value;
        } catch (Exception ignored) {
            return null;
        }
    }

    private static void cacheUserNames(RedisService redisService, Map<Long, String> userNameMap) {
        if (redisService == null || Cools.isEmpty(userNameMap)) {
            return;
        }
        userNameMap.forEach((userId, userName) -> {
            if (userId == null || Cools.isEmpty(userName)) {
                return;
            }
            try {
                redisService.setValue(USER_NAME_CACHE_FLAG, String.valueOf(userId), userName, USER_NAME_CACHE_TTL_SECONDS);
            } catch (Exception ignored) {
            }
        });
    }

    private static <T> void fillUserNameFields(List<T> records, Map<Long, String> userNameMap) {
        if (Cools.isEmpty(records) || Cools.isEmpty(userNameMap)) {
            return;
        }
        records.stream()
                .filter(Objects::nonNull)
                .forEach(record -> {
                    writeUserName(record, "createBy$", userNameMap.get(readUserId(record, "createBy")));
                    writeUserName(record, "updateBy$", userNameMap.get(readUserId(record, "updateBy")));
                });
    }

    private static void writeUserName(Object record, String fieldName, String userName) {
        if (record == null || Cools.isEmpty(fieldName) || userName == null) {
            return;
        }
        Field field = Cools.getField(record.getClass(), fieldName);
        if (field == null || !String.class.equals(field.getType())) {
            return;
        }
        boolean accessible = field.isAccessible();
        try {
            field.setAccessible(true);
            field.set(record, userName);
        } catch (IllegalAccessException ignored) {
        } finally {
            field.setAccessible(accessible);
        }
    }
}