package jnpf.dmsIntegration.audit;

import jnpf.dmsEntity.permission.entity.DmsAccessExclusionEntity;
import jnpf.dmsEntity.permission.entity.DmsDocumentEntity;
import jnpf.dmsEntity.permission.entity.DmsFilePermissionEntity;
import jnpf.dmsEntity.permission.entity.DmsFileVersionEntity;
import jnpf.dmsEntity.permission.entity.DmsFolderEntity;
import jnpf.dmsMapper.DmsDocumentMapper;
import jnpf.dmsMapper.DmsFileVersionMapper;
import jnpf.dmsMapper.DmsFolderMapper;
import jnpf.dmsMapper.DmsPermissionGroupMapper;
import jnpf.permission.OrganizeApi;
import jnpf.permission.PositionApi;
import jnpf.permission.RoleApi;
import jnpf.permission.UserApi;
import jnpf.permission.entity.OrganizeEntity;
import jnpf.permission.entity.PermissionGroupEntity;
import jnpf.permission.entity.PositionEntity;
import jnpf.permission.entity.RoleEntity;
import jnpf.permission.entity.UserEntity;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.function.Function;

/** Resolves occurrence-time display labels for permission audit evidence. */
@Slf4j
@Component
@RequiredArgsConstructor
public class DmsPermissionAuditDisplayResolver {
    private final DmsFolderMapper folderMapper;
    private final DmsDocumentMapper documentMapper;
    private final DmsFileVersionMapper fileVersionMapper;
    private final UserApi userApi;
    private final OrganizeApi organizeApi;
    private final PositionApi positionApi;
    private final RoleApi roleApi;
    private final DmsPermissionGroupMapper permissionGroupMapper;

    public DisplayValues resolvePermissions(String tenantId, Collection<DmsFilePermissionEntity> values) {
        DisplayValues result = new DisplayValues();
        resolveResources(tenantId, permissionResources(values), result);
        Map<String, Set<String>> principals = new LinkedHashMap<>();
        Set<String> users = new LinkedHashSet<>();
        if (values != null) {
            for (DmsFilePermissionEntity value : values) {
                if (value == null) continue;
                add(principals, value.getPrincipalType(), value.getPrincipalId());
                add(users, value.getGrantedById());
                add(users, value.getRevokedById());
            }
        }
        resolvePrincipals(principals, result);
        resolveUsers(users, result);
        return result;
    }

    public DisplayValues resolveExclusions(String tenantId, Collection<DmsAccessExclusionEntity> values) {
        DisplayValues result = new DisplayValues();
        resolveResources(tenantId, exclusionResources(values), result);
        Set<String> users = new LinkedHashSet<>();
        if (values != null) {
            for (DmsAccessExclusionEntity value : values) {
                if (value == null) continue;
                add(users, value.getUserId());
                add(users, value.getExcludedById());
                add(users, value.getRevokedById());
            }
        }
        resolveUsers(users, result);
        return result;
    }

    private void resolveResources(String tenantId, Map<String, Set<UUID>> ids, DisplayValues result) {
        try {
            List<UUID> folderIds = list(ids.get("FOLDER"));
            if (!folderIds.isEmpty()) {
                for (DmsFolderEntity item : orEmpty(folderMapper.selectByTenantAndIds(tenantId, folderIds))) {
                    result.resources.put(key("FOLDER", item.getId()), fallback(item.getName(), item.getId()));
                }
            }
        } catch (RuntimeException ex) {
            log.warn("DMS permission audit folder display lookup failed", ex);
        }
        try {
            List<UUID> documentIds = list(ids.get("DOCUMENT"));
            if (!documentIds.isEmpty()) {
                for (DmsDocumentEntity item : orEmpty(documentMapper.selectByTenantAndIds(tenantId, documentIds))) {
                    String label = joinCode(item.getDocumentNo(), item.getName());
                    result.resources.put(key("DOCUMENT", item.getId()), fallback(label, item.getId()));
                }
            }
        } catch (RuntimeException ex) {
            log.warn("DMS permission audit document display lookup failed", ex);
        }
        try {
            List<UUID> versionIds = list(ids.get("FILE_VERSION"));
            if (!versionIds.isEmpty()) {
                for (DmsFileVersionEntity item : orEmpty(fileVersionMapper.selectByTenantAndIds(
                        tenantId, versionIds))) {
                    String version = trim(item.getVersionLabel());
                    String label = trim(item.getFileName());
                    if (label != null && version != null) label = label + " - " + version;
                    result.resources.put(key("FILE_VERSION", item.getId()), fallback(label, item.getId()));
                }
            }
        } catch (RuntimeException ex) {
            log.warn("DMS permission audit file version display lookup failed", ex);
        }
    }

    private void resolvePrincipals(Map<String, Set<String>> ids, DisplayValues result) {
        resolveUsers(ids.get("USER"), result);
        List<String> orgIds = list(ids.get("ORG"));
        if (!orgIds.isEmpty()) try {
            putNames(result.principals, "ORG", organizeApi.getListByIds(orgIds),
                    OrganizeEntity::getId, OrganizeEntity::getFullName);
        } catch (RuntimeException ex) { log.warn("DMS permission audit organization display lookup failed", ex); }
        List<String> positionIds = list(ids.get("POSITION"));
        if (!positionIds.isEmpty()) try {
            putNames(result.principals, "POSITION", positionApi.getListByIds(positionIds),
                    PositionEntity::getId, PositionEntity::getFullName);
        } catch (RuntimeException ex) { log.warn("DMS permission audit position display lookup failed", ex); }
        List<String> roleIds = list(ids.get("ROLE"));
        if (!roleIds.isEmpty()) try {
            putNames(result.principals, "ROLE", roleApi.getListByIds(roleIds),
                    RoleEntity::getId, RoleEntity::getFullName);
        } catch (RuntimeException ex) { log.warn("DMS permission audit role display lookup failed", ex); }
        Set<String> groupIds = ids.get("GROUP");
        if (groupIds != null && !groupIds.isEmpty()) try {
            putNames(result.principals, "GROUP", permissionGroupMapper.selectEnabledByIds(groupIds),
                    PermissionGroupEntity::getId, PermissionGroupEntity::getFullName);
        } catch (RuntimeException ex) { log.warn("DMS permission audit group display lookup failed", ex); }
    }

    private void resolveUsers(Collection<String> ids, DisplayValues result) {
        List<String> requested = list(ids);
        if (requested.isEmpty()) return;
        try {
            for (UserEntity user : orEmpty(userApi.getUserName(requested))) {
                if (user == null || trim(user.getId()) == null) continue;
                String name = trim(user.getRealName());
                String account = trim(user.getAccount());
                String display = name != null && account != null ? name + "（" + account + "）"
                        : (name != null ? name : account);
                if (display != null) {
                    result.users.put(user.getId(), display);
                    result.principals.put(key("USER", user.getId()), display);
                }
            }
        } catch (RuntimeException ex) {
            log.warn("DMS permission audit user display lookup failed", ex);
        }
    }

    private static Map<String, Set<UUID>> permissionResources(Collection<DmsFilePermissionEntity> values) {
        Map<String, Set<UUID>> result = new LinkedHashMap<>();
        if (values != null) {
            for (DmsFilePermissionEntity value : values) {
                if (value != null) add(result, value.getResourceType(), value.getResourceId());
            }
        }
        return result;
    }

    private static Map<String, Set<UUID>> exclusionResources(Collection<DmsAccessExclusionEntity> values) {
        Map<String, Set<UUID>> result = new LinkedHashMap<>();
        if (values != null) {
            for (DmsAccessExclusionEntity value : values) {
                if (value != null) add(result, value.getResourceType(), value.getResourceId());
            }
        }
        return result;
    }

    private static <T> void putNames(Map<String, String> target, String type, Collection<T> values,
                                     Function<T, String> id, Function<T, String> name) {
        if (values == null) return;
        for (T value : values) {
            if (value == null || trim(id.apply(value)) == null || trim(name.apply(value)) == null) continue;
            target.put(key(type, id.apply(value)), name.apply(value).trim());
        }
    }

    private static String joinCode(String code, String name) {
        String normalizedCode = trim(code);
        String normalizedName = trim(name);
        if (normalizedCode != null && normalizedName != null) return "[" + normalizedCode + "] " + normalizedName;
        return normalizedName != null ? normalizedName : normalizedCode;
    }

    private static String fallback(String value, Object id) {
        return trim(value) == null ? String.valueOf(id) : value.trim();
    }

    private static String key(String type, Object id) {
        return String.valueOf(type) + ":" + String.valueOf(id);
    }

    private static <T> void add(Map<String, Set<T>> target, String type, T id) {
        if (trim(type) != null && id != null) {
            target.computeIfAbsent(type.trim(), ignored -> new LinkedHashSet<>()).add(id);
        }
    }

    private static void add(Set<String> target, String value) {
        if (trim(value) != null) target.add(value.trim());
    }

    private static <T> List<T> list(Collection<T> values) {
        return values == null || values.isEmpty() ? Collections.emptyList() : new ArrayList<>(values);
    }

    private static <T> List<T> orEmpty(List<T> values) {
        return values == null ? Collections.emptyList() : values;
    }

    private static String trim(String value) {
        return value == null || value.trim().isEmpty() ? null : value.trim();
    }

    public static final class DisplayValues {
        private final Map<String, String> resources = new LinkedHashMap<>();
        private final Map<String, String> principals = new LinkedHashMap<>();
        private final Map<String, String> users = new LinkedHashMap<>();

        public String resource(String type, UUID id) {
            return display(resources.get(key(type, id)), id);
        }

        public String principal(String type, String id) {
            return display(principals.get(key(type, id)), id);
        }

        public String user(String id) {
            return display(users.get(id), id);
        }

        DisplayValues addResource(String type, UUID id, String display) {
            resources.put(key(type, id), display);
            return this;
        }

        DisplayValues addPrincipal(String type, String id, String display) {
            principals.put(key(type, id), display);
            return this;
        }

        DisplayValues addUser(String id, String display) {
            users.put(id, display);
            principals.put(key("USER", id), display);
            return this;
        }

        private static String display(String resolved, Object raw) {
            return resolved != null ? resolved : (raw == null ? "" : raw + "（名称暂不可用）");
        }
    }
}